
    ¯wg>q                       d dl mZ d dlZd dlmZ d dlmZ d dlmZ d dl	m
c mZ d dlmZmZmZmZmZmZ d dlmZ d dlmZmZmZmZmZmZmZmZ d d	lmZ d d
l m!Z! d dl"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+ ddZ,ddZ-	 	 	 	 	 	 	 	 d dZ.ddZ/d!dZ0 ed       G d de             Z1 ed       G d de1             Z2 ed       G d d             Z3 G d d      Z4 ed       G d d             Z5	 	 	 	 	 	 d"dZ6y)#    )annotationsN)ABC)	dataclass)Any)	getValueTisValueTypeLazyArgumentLazyIrPropertiesLazyIrSchematensorListValueT)	translate)	BaseCTypeBindingdeviceTDispatcherSignaturekernel_signatureNativeSignatureOptionalCTypeVectorCType)method_with_native_function)ts_lowering_body)	ArgumentBackendIndexBackendMetadataBaseTyBaseTypeFunctionSchemaListTypeNativeFunctionNativeFunctionsGroupc                   t        | j                        r t        | j                  t              rs| j                  rd| j
                   S | j                  j                  t        u rd| j
                   dS | j                  rd| j
                   dS d| j
                   dS t        | j                  t              r`| j                  r| j
                   d| j
                   dS | j                  rd| j
                   S d| j
                   d	| j
                   d
S t        d| j                   d      t        | j                  t              ri| j                  j                  t        t        j                         k(  r9| j"                  rd| j
                   dS d| j
                   d| j
                   dS t        | j                  t$              rbt        | j                  j                  t              r>d| j                  j                  j                   d| j
                   d| j
                   dS t        | j                  t              rt        | j                  j                  t$              rit        | j                  j                  j                  t              r;d| j                  j                  j                  j                   d| j
                   dS | j
                   S )z
    Given a LazyArgument,
    generate a c++ string for materializing an rvalue of that arg for passing into
    a lazy Node constructor.
    node_lazy__tensorlistzGetSymIntValue()z->GetIrValue()z& ? std::make_optional(GetSymIntValue(*z)) : ::std::nulloptz ? std::make_optional(lazy_z ->GetIrValue()) : ::std::nullopt=TODO not sure if there are other valid types to handle here (zGetSymIntArrayRefValue(zstd::vector<int64_t>(z
.begin(), z.end())std::vector<>(ztorch::lazy::ToOptionalVector<)r   	lazy_type
isinstancer   is_wrapped_scalarnametyper   is_symint_or_listr   AssertionError	orig_typer   elemr   r   SymIntsymintr   )args    Z/home/mcse/projects/flask/flask-venv/lib/python3.12/site-packages/torchgen/dest/lazy_ir.pynode_ctor_arg_rvalue_stringr6   +   sn    3==!cmmY/$$sxxj))##'77sxxj44&&(
!44388*N33}5$$ ((#I#((Sfgg&&sxxj))z "++.88* 5!! !OPSP]P]^_`  cmmX.3==3E3EMMJ
 4
 zz0
!<<.sxxj
388*GTT{3
MM	9
 "#--"4"4"9"9!:"SXXJjQTQYQYPZZabbs}}m43==--{;3==--22I>3CMM4F4F4K4K4P4P3QQSTWT\T\S]]^__hhZ     c                z    | j                         D cg c]  }t        |       }}dj                  |      S c c}w )zg
    Produce a formatted string with the arguments as passed into the constructor of a node class.
    , )filtered_argsr6   join)schemar4   node_ctor_valuess      r5   node_ctor_inputsr>   f   sE    
 5;4H4H4J-0#C(  99%&&s   8c                t   t        j                  | j                        }t        |j	                         |j	                               }dj                  |D cg c]  }|j                   c}      }t        |      rd| j                   d| d}nd| j                   d}dt        |        d| d| d	S c c}w )
zK
    Generate code that falls back to eager conditioned on a predicate
    z,
                z	ATEN_OP2(r9   r%   zATEN_OP(z"
        if (force_eager_fallback(zQ)) {
            return at::native::call_fallback_fn_symint<&ltc_eager_fallback, z>::call(
                z
            );
        }
)
r   from_schemafuncr   	argumentsr;   exprlen	aten_nameaten_symbol)r<   sigoverload_namedispatcher_sigexprsafallback_argsaten_op_strs           r5   gen_fallback_coderN   p   s     )44V[[ANcmmo~'?'?'ABE)../F1/FGM
=!&"2"2!32m_AF !1!1 2!4""-f"5!6 7MMXM Z    0Gs   B5c                    dh}| j                   |v rd| j                    dS | j                   j                  d      sd| j                    S | j                   S )Nsigmoid_backwardz#c10::Symbol::fromQualString("aten::z")zat::z
at::aten::)rE   
startswith)r<   missing_interned_stringss     r5   rF   rF      sh      334V5E5E4FbII&&v.F,,-..r7   c                   g }g }| j                         D ]  }t        |j                  t              rv|j                  j                  j                         rR|j                   d}|j                  d| d|j                   d       |j                  |j                  |             |j                  |        dj                  |      }||fS )N_metazauto z = to_meta();	
        )
rB   r*   argumentr   r-   is_tensor_liker,   append	with_namer;   )rG   contextunwrapped_tensor_argsr4   unwrapped_nameunwrap_tensor_args_strs         r5   convert_to_meta_tensorsr_      s    G')}}  cllH-#,,2C2C2R2R2T #z/N!(('{388*B? NN3==89NN3  *../DE!7**r7   T)frozenc                  p    e Zd ZU ded<   ded<   ded<   ded<   edd       Zdd	Zdd
ZddZddZ	ddZ
y)	GenLazyIRr   backend_indexstrbackend_name	node_basebooluse_lazy_shapec                8   t        |t              r|j                  j                  n|j                  }| j                  j                  t        |t              r|j                  n|      }t        ||d uxr |j                               }| j                  |      S )Nr3   )	r*   r    
functionalrA   rc   
get_kernelr   supports_symintgen)selffrA   metadatar<   s        r5   __call__zGenLazyIR.__call__   s    $.q2F$Gq||  QVV%%00&q*>?ALLQ
 -L(2J2J2L
 xxr7   c                     yN  )ro   r<   s     r5   lowering_functionzGenLazyIR.lowering_function       r7   c                     yrt   rv   ro   r<   node_ctor_argss      r5   create_functionzGenLazyIR.create_function   rx   r7   c                    d| dS )Nbool CanBeReused(z!) const {
    return false;
    }rv   rz   s      r5   can_be_reused_functionz GenLazyIR.can_be_reused_function   s    $^$4 5 
 	
r7   c                N   |j                  dd      }g }|D ]  }t        |j                  t        t        f      r|j                  |j                          @t        |j                  t              r|j                  |j                   d       yt        d|j                   d       dj                  |      }|j                  dd      }|j                  j                  rd}n|j                  j                  rT|D cg c]  }|j                   }	}|	j                  d	 |D               d
|j                   ddj                  |	       d}nx|j                  j                  r`t        t!        |            D 
cg c]  }
d|
 d
 }	}
|	j                  d |D               d|j                   ddj                  |	       d}nd}dj                  d |D              }| j"                   d|j$                   d| d| dt!        |j&                         d| dS c c}w c c}
w )NTFvaluesscalars.value_or(kNullValue)zUnsupported type (z) - add support if necessaryr9   zstd::move(shapes),c              3  4   K   | ]  }|j                     y wNr,   .0rK   s     r5   	<genexpr>z0GenLazyIR.node_base_ctor_call.<locals>.<genexpr>        :aff:   compute_shape_(z),zoperand(r%   c              3  4   K   | ]  }|j                     y wr   r   r   s     r5   r   z0GenLazyIR.node_base_ctor_call.<locals>.<genexpr>   r   r   z[&](){ return compute_shape_z)[0]; },ru   c              3  6   K   | ]  }|j                      y wr   r   r   s     r5   r   z0GenLazyIR.node_base_ctor_call.<locals>.<genexpr>   s     !C!QVVH+!Cs   z(
              z&::ClassOpKind(),
              OpList{z},
              z!
              /* num_outputs */ z#,
              torch::lazy::MHash()))r:   r*   r)   r   r   rY   r,   r   r/   r;   
propertiesShapePrecomputeShapeComputeextend
ShapeCacherangerD   rf   	node_namereturns)ro   r<   
value_argsbase_ctor_value_args_listr4   base_ctor_value_argsscalar_argsshape_ctor_argrK   
shape_argsiscalar_hashess               r5   node_base_ctor_callzGenLazyIR.node_base_ctor_call   s   ))u)E
 %'! 	C#--)[)AB)00CHH:?CMM=9)00CHH:=R1ST$(7ST 	  $yy)BC**%*F ,,1N++*45Q!&&5J5:k::-fkk]!DIIj<Q;RRTUN))38Z3IJaHQCq/JJJ:k::<V[[M499U_K`JaajkNN		!C{!CCNN# $  !+, - !!$V^^!4 5 6""/6 	6 6 Ks   H>H"c                   |j                   xs t        |      }|j                         }|j                  dd      }|D cg c],  }d|j                  j	                          d|j
                   . }}dj                  |      }| j                  r'|j                  j                  r|j                  d       dj                  |      }dj                  |D 	cg c]d  }	|	j                  j	                         d	k(  r)|	j
                   d
|	j
                   d|	j
                   dn|	j
                   d
|	j
                   df c}	      }
t        |
      rd|
 }
dj                  |D 	cg c]  }	|	j                  j	                         dk(  rd|	j
                   dnV|	j                  j	                         d	k(  rd|	j
                   dn)|	j                  j	                          d|	j
                   d c}	      }|j                  dd      D cg c](  }t        |j                  t              r|j
                  * }}dj                  |D cg c]  }d| d
 c}      }dj                  |D cg c]  }d| d| d c}      }g }|D ]  }t        |j                  t              rZ|j
                   d}|j                  rd}|j                  d|j
                   d|j
                   d| d|j
                   d	       w|j                  d |j
                   d|j
                   d        dj                  |      }d!|j                   d"| j                    d#| d$|j                   d
| d%| j#                  |       |
 d&| d'| j                    d(| d)| j%                  ||       d*| j'                  ||       d*| j)                  |       d*| d| d+gS c c}w c c}	w c c}	w c c}w c c}w c c}w ),NFTr   zconst z& r9   z(std::vector<torch::lazy::Shape>&& shapesz
,
        z!::std::optional<c10::string_view>r   z1.has_value() ? ::std::make_optional(std::string(*z)) : ::std::nullopt)r%   z
  zc10::string_viewzstd::string ;z::std::optional<std::string>  z	bool has_z: 1;z
    has_z = !!z.value()z"torch.Generator()"zif (z.has_value()) {
      ss << ", z=" << z;
    } else {
      ss << ", z=null";
    }z	ss << ", zclass z
 : public zX {
 public:
  static torch::lazy::OpKind ClassOpKind() {
    return torch::lazy::OpKind(z
);
  }

  z
)
      : z	
  {
    zT
  }

  std::string ToString() const override {
    std::stringstream ss;
    ss << z::ToString();
    z
    return ss.str();
  }

  z

  z

};

)opkindrF   r:   r)   cpp_typer,   r;   rh   r   r   rY   rD   r*   r   is_generatorr   rf   r   r|   r   rw   )ro   r<   r   all_argsr   r   	ctor_argsreuse_ctor_argsr{   rK   scalar_initializersscalar_declsr4   optional_valuesvaluehas_optional_declshas_optional_defsmembers_to_stringmembers_to_string_strs                      r5   rn   zGenLazyIR.gen   s^   5+f"5 '')**%*FJRSQvakk2245Rx@S	S))I.6#4#4#D#DGH9-+00 %
  ;;'')-PP 66(!AFF8#TUVU[U[T\\pqxq*+
 "#$/0C/D"E{{ % 	 ;;'')-?? qvvha( ;;'')-PP 5QVVHA>,,./q:	;	
 ++4+G
#--7 HH
 

 $[[2AByt$B
 %MM6EFUtE7%wa(F
  	RC#--788*H-##1E!((SXXJ 'zw 'z 
 "((9SXXJfSXXJa)PQ	R !).? @
4>>"2 3  !'x ( 
An% &			!	!&	)*+>*? @ 
 >>
   01 2v78 9&!" #.  7!
 !	
o T
 C Gs&   1OA)O'BO -O%O*/O/N)rp   z%NativeFunctionsGroup | NativeFunctionreturn	list[str]r<   r   r   rd   r<   r   r{   rd   r   rd   )r<   r   r   r   )__name__
__module____qualname____annotations__r   rr   rw   r|   r   r   rn   rv   r7   r5   rb   rb      sF    N   ! 

(6T`
r7   rb   c                  $    e Zd ZddZddZddZy)GenTSLazyIRc                    d}|j                   j                  r| dS |j                   j                  r| dt        |       dS y)Nz
  torch::lazy::TSOpVector Lower(
      std::shared_ptr<torch::jit::GraphFunction> function,
      torch::lazy::TSLoweringContext* loctx) const overrider   z {
    z
  }
            ru   )r   LowerDeclOnlyLowerr   )ro   r<   	signatures      r5   rw   zGenTSLazyIR.lowering_functionV  s^    ?	
 **[?"$$!{ #f  
 r7   c                    d| d}|j                   j                  r| dS |j                   j                  sy| d|j                   dS )Nzstatic NodePtr Create(r%   r   ru   z {
    return ReuseOrMakeNode<z>(data);
  })r   CreateFnDeclOnlyCreateFnr   )ro   r<   r{   r   s       r5   r|   zGenTSLazyIR.create_functionf  sc    ,^,<A>	--[?"""++; ",,- . 	r7   c                `   d| d}|j                   j                  r| dS |j                   j                  syg }t        j                  |j
                  |j                        D ]Z  }t        |j                  t              r |j                  d|j                   d       =|j                  d|j                          \ t        j                  |j                  |j                        D ]  }t        |j                  t              ra|j                  d|j                   d	|j                   d
|j                   d|j                   d|j                   d|j                   d       ~|j                  d|j                   d|j                           dj                  |      }| d| dS )Nr~   z) constr   ru   znullable_operand(i++) == r   zoperand(i++) == z	((!this->z&&!z) || (this->z&&z && *(this->z) == *r   zthis->z == z &&
        z! {
    size_t i = 0;
    return (z);
  })r   CanBeReusedDeclOnlyCanBeReused	itertoolschainpositional_valueskeyword_valuesr*   r)   r   rY   r,   positional_scalarskeyword_scalarsr;   )ro   r<   r{   r   value_comparisonr4   value_comparison_strs          r5   r   z"GenTSLazyIR.can_be_reused_functionp  s   ''7w?	00[?"""..??6#;#;V=R=RS 	GC#--7 ''/z9NO !''*:388*(EF	G ??6#<#<f>T>TU 	KC#--7 ''zSXXJl388*BsxxjXdehememdnntuxu}u}t~  A  B !''&
$sxxj(IJ	K  /334DE; !" # 	r7   Nr   r   )r   r   r   rw   r|   r   rv   r7   r5   r   r   T  s     r7   r   c                     e Zd ZU ded<   ded<   ded<   ded<   ded<   ded	<   ded
<   ded<   ded<   ded<   ded<   ded<   ded<   ded<   ded<   ddZ	 	 	 	 	 	 	 	 	 	 ddZddZddZddZddZ	dd dZ
ddZed!d       Zy)"GenLazyNativeFuncDefinitionrd   class_method_namer   rc   tensor_classrg   gen_forced_fallback_codebackend_namespaceget_tensorlistget_tensor_or_wrap_numbertry_get_tensormetrics_countercreate_tensorcreate_from_first_tensorcreate_aten_from_ltc_tensortuple_aten_from_ltc_tensorslazy_tensor_ptrget_device_fnc                   |j                  dd      }g }|D ]9  }|j                  rt        |j                  t              r:|j                  d|j                   d|j                   d|j                   d       d|j                  d|j                   d|j                   d	       |j                  rt        |j                  t              r|j                  j                  t        u rH|j                  d
|j                   d| j                   d| j                   d|j                   d	       |j                  | j                   d|j                   d| j                   d| j                   d|j                   d	
       pt        |j                  t              r|j                  j                  t        t!                     k(  sJ |j                  j                         |j                  | j                   d|j                   d| j                   d| j"                   d|j                   d
       #t%        d|j                   d       dj'                  |      S )NTFr   z
auto node_z = z ?
                std::make_optional(torch::lazy::LazyGraphExecutor::Get()->
                    GetIrValueForScalarFromCodegen(*z3, *common_device)):
                ::std::nullopt;zf = torch::lazy::LazyGraphExecutor::Get()->
                            GetIrValueForScalarFromCodegen(z, *common_device);z
auto lazy_z_tensorlist = ::r   rU   z lazy_z.value_or(at::Tensor()));r&   r%   rV   )r:   r+   r*   r)   r   rY   r,   r.   r   r-   r   r   r   r   r   r1   r   r   r/   r;   )ro   rA   r<   r   lazy_tensor_declsr4   s         r5   r   z-GenLazyNativeFuncDefinition.lazy_tensor_decls  sK   ))u)E
') &	C$$cmm];%,,&sxxjCHH: >558XXJ ? # &,,&sxxj 1<<?HH:EW[ &&CMM95==%%)99%,,$SXXJn112"T5H5H4I388*TVX
 &,,//0sxxj112"T5S5S4TTUVYV^V^U__qs CMM=9}}))Yy{-CCWS]]EWEWWC "((++,F388*C--.b1D1D0EQsxxjPik
 %STWTaTaSbbcd I&	N ""#455r7   c                t    | j                   r,t        |||j                  j                  j                        S y)N)rH   ru   )r   rN   rA   r,   rH   )ro   rA   r<   rq   rG   s        r5   force_eager_fallbackz0GenLazyNativeFuncDefinition.force_eager_fallback  s4     (($499>>+G+G  r7   c                     | j                    dS )Nr   )r   )ro   rA   r<   s      r5   metricsz#GenLazyNativeFuncDefinition.metrics  s    &&'q))r7   c                   |j                  dd      }|j                  dd      }|D cg c]  }|j                  r|j                    }}t        t	        t
                    }|D cg c]  }|j                  |k(  s|j                    }}t        |      dkD  st        |      dkD  sJ d       | j                   ddj                  ||z          d}	d	|	 d
S c c}w c c}w )NTFr   r   z*Expected at least one Value or Device typer   r9   r%   zauto common_device = z8;
        TORCH_INTERNAL_ASSERT(common_device);
        )
r:   r+   r,   r   r   r   r)   rD   r   r;   )
ro   rA   r<   r   r   rK   value_types_namesoptional_deviceoptional_devicesget_device_strs
             r5   
get_devicez&GenLazyNativeFuncDefinition.get_device  s
   ))u)E
**%*F2<XQADWDWx[XX'	'(:;'
1;;/+IAFF
 
 !"Q&#.>*?!*C	87	8C !!"!DII.?BR.R$S#TTUV 	 )(8 9	  	 Y
s   CC*C!?C!c           
        | j                   j                  |      }|J |j                         }t        |j                        }d|j
                  v }|j                  xs |j                  d u}|s|rd}|dkD  r:dd}	dj                  t        |      D 
cg c]
  }
 |	|
       c}
      }d|z   dz   }t        j                  |j                        }t        |      \  }}t        ||j                         d	      D cg c]  }|j                    }}|r|j"                  sJ d
}nd}|j$                  }|j                  j'                         r|j)                         r|dz  }d| d| d| ddj                  |       d| 
}n6t+        |j,                  ||j)                               }d|j.                   d}|d| dz  }dt1        |j                        z   }|ddj                  d |D               d| dz  }|S c c}
w c c}w )N	view_copyzl
std::vector<torch::lazy::Shape> shapes{torch::lazy::Shape(out_meta.scalar_type(), out_meta.sizes().vec())};   c                    d|  d|  dS )Nztorch::lazy::Shape(std::get<z$>(out_meta).scalar_type(), std::get<z>(out_meta).sizes().vec())rv   )r   s    r5   
this_shapez?GenLazyNativeFuncDefinition.shape_inference.<locals>.this_shape  s    9!<`ab`cc}~~r7   ,z'std::vector<torch::lazy::Shape> shapes{z};F)method&compositeexplicitautogradnonfunctionalmeta_symintz        z
        auto out_meta = at::r   r   r9   z);
        rj   z
            auto shapes = r   z4
            TORCH_INTERNAL_ASSERT(shapes.size() == rU   zaten::zq
            if(torch::lazy::symbolicShapeEnabled()){
                std::vector<torch::jit::IValue> inputs = { c              3  F   K   | ]  }t        |j                          y wr   )rd   r,   r   s     r5   r   z>GenLazyNativeFuncDefinition.shape_inference.<locals>.<genexpr>2  s     FeWXs166{Fes   !z. };
                const char* schema_str = "z^";
                applySymbolicShapesOnLT(schema_str, inputs, shapes);
            }
        )r   intr   rd   )rc   rl   r:   rD   r   tags
structuredstructured_delegater;   r   r   r@   rA   r_   r   rB   rC   5has_composite_explicit_autograd_non_functional_kernelrE   
has_symintrm   ComputeShapeSignaturekernel
shape_callrd   )ro   rA   r<   rq   r   returns_lengthis_view_copy_opis_structuredmeta_outr   r   
shapes_strrI   meta_conversion_strmeta_call_ctxemeta_call_argsdispatch_nsrE   	shape_str	shape_sigfunc_schema_strs                         r5   shape_inferencez+GenLazyNativeFuncDefinition.shape_inference  s^   %%006###'')V^^, &2O4+C+C4+OOoH! !XXeN>S&Tz!}&TU
DzQTXX 1<<TYYGN1H1X. #!>#;#;#=e N  QQQQF$((Iyy##%(*B*B*DY&			 (MI;a		.8Q7R S		
I
 .h.F.F.HI$//05I 	 44B3C2I 	I	 #S^3 ==AYYFe\dFe=e<f g++:*; <	 		 a 'Us   H Hc                    t        |      }d|j                   d| d| j                  ||       d|j                   d| dS )Nz3torch::lazy::NodePtr node = torch::lazy::ReuseNode<r(   z$);
        if (!node) {
            z*
            node = torch::lazy::MakeNode<zE, std::move(shapes));
            CacheNode(node);
        }
        )r>   r   r  )ro   rA   r<   node_ctor_input_strs       r5   build_ir_nodez)GenLazyNativeFuncDefinition.build_ir_node9  sf    .v6FvGWGWFXXZ[nZo p!!$/0 1**0*:*:);2>Q=R S	 	r7   Nc                    | j                   r|J d       | d| j                   S | j                   d| j                   S )Nz+Requires first tensor to create lazy tensor.r   )r   r   r   )ro   first_tensor_names     r5   create_lazy_tensorz.GenLazyNativeFuncDefinition.create_lazy_tensorC  s[    (( "-=<=-'($*<*<)=>>(()D,>,>+?@@r7   c                   t        |j                        }|j                  dd      }|D cg c]  }|j                  r|j                    }}t        |      dkD  r|d   nd }d| j
                   d| j                  |       d}|dkD  rUt        |      dkD  sJ d	       d
| j                   d| d| j                  |       dt                d| j                   d| d}|j                  j                  j                  s|j                  j                         r|dk(  sJ d| d       d| d| d}|dz  }|S c c}w )NTFr   r   zauto result = z(
                z#(std::move(node), *common_device));r   z3Code below assumes there is at least one tensor argr'   z,> lazy_tensors;
        for (int i = 0; i < z,; i++) {
            lazy_tensors.push_back(r   z=(node, i), *common_device));
        }
        auto result = <z>(lazy_tensors);zqWe assumed there was no such case where an op is an in-place variant and has tuple outputs, but got tuple of len r  r#   z2->SetInPlaceIrValue(node);
        auto& result = r   z
        return result;)rD   r   r:   r+   r,   r   r  r   r   r   inplacerA   	is_out_fn)	ro   rA   r<   r  r   rK   r   r  
bridge_strs	            r5   return_aten_tensorz.GenLazyNativeFuncDefinition.return_aten_tensorM  s   V^^,))u)E
2<XQADWDWx[XX478I4JQ4N-a0TX'(H(H'I J(():;<<_c
 A%&*EDE*)$*>*>)? @+, -$$($;$;<M$N#OqQZQ\P] ^778.9IIY	]J ;;##tyy':':'<!Q& ??M>NaQ& ##4"5 6)*!/J 	  	
3 Ys
   D;D;c                   t        || j                        }| j                  j                  |      }|J t        |j                  |j                               }d|j                  | j                   d|j                          d| j                  ||||       d| j                  ||       d| j                  ||       d| j                  ||       d| j                  ||       d| j                  ||       dgS )Nrj   z    r   r   z {
        rV   z
    }

    )r   rc   rl   r   rA   rm   declr   r   r   r   r   r   r  r  )ro   rA   rG   rq   r<   s        r5   rr   z$GenLazyNativeFuncDefinition.__call__k  s"   tT%7%78%%006###dii0H0H0JKXXd,,-R/@AXBC D			"	"43	?@ A		dF	#$ %		v	&' (				f	-. /				D&	)* +			 	 v	./ 0	
 	
r7   )rA   r   r<   r   r   rd   )
rA   r   r<   r   rq   r   rG   %DispatcherSignature | NativeSignaturer   rd   r   )r  z
str | Noner   rd   )rA   r   r   r   )r   r   r   r   r   r   r   r   r  r  r  r  r   rr   rv   r7   r5   r   r     s    """"""!$$!$$+6Z  "	
 3 
*$IVA< !
 !
r7   r   c                  L    e Zd ZdZddZd	dZd	dZed	d       Zed	d       Z	y)
r   zm
    Here we use the base name as the suffix of the signature to avoid generating for in-place variants.
    c                  t        |j                  |      | _        dj                  t	        j
                  |j                  |      D cg c]  }|j                          c}      | _        dj                  | j                  j                  d      D cg c]  }|j                    c}      | _
        || _        y c c}w c c}w )Nrj   r9   T)	generator)r   rA   _ComputeShapeSignature__schemar;   
dispatcherrB   r  %_ComputeShapeSignature__dispatch_argsr:   r,   !_ComputeShapeSignature__call_args#_ComputeShapeSignature__kernel_name)ro   kernel_namerp   r3   rK   r4   s         r5   __init__zComputeShapeSignature.__init__  s    $QVVF;#yy)33AFF6JK!QVVXK 
  99&*mm&A&AD&A&QRsz]R
 ) L Ss   B?Cc                :    | j                    d| j                   dS Nr   r%   )r'  r%  ro   s    r5   __decl_suffixz#ComputeShapeSignature.__decl_suffix  s#    $$%Qt';';&<A>>r7   c                :    | j                    d| j                   dS r+  )r'  r&  r,  s    r5   __call_suffixz#ComputeShapeSignature.__call_suffix  s#    $$%Qt'7'7&8::r7   c                (    d| j                          S )Nz8TORCH_API std::vector<torch::lazy::Shape> compute_shape_)#_ComputeShapeSignature__decl_suffixr,  s    r5   
shape_declz ComputeShapeSignature.shape_decl  s    I$J\J\J^I_``r7   c                (    d| j                          S )Nztorch::lazy::compute_shape_)#_ComputeShapeSignature__call_suffixr,  s    r5   r  z ComputeShapeSignature.shape_call  s    ,T-?-?-A,BCCr7   N)r(  rd   rp   r   r3   rg   r   None)r   rd   )
r   r   r   __doc__r)  r1  r4  propertyr2  r  rv   r7   r5   r   r     sB    )?; a a D Dr7   r   c                  4    e Zd ZU ded<   ded<   edd       Zy)GenLazyShapeInferenceDefinitionr   rc   rd   r   c                ,   | j                   j                  |      }|J d|j                  v }|j                  xs |j                  d u}|s|rg S t        |j                  ||j                               }dj                  |j                   dg      gS )Nr   rj   
r   )
rc   rl   r   r   r   r   r   rm   r;   r2  )ro   rp   rq   r  r  r  s         r5   rr   z(GenLazyShapeInferenceDefinition.__call__  s    %%003### &/I(=(=T(IOI-8+C+C+EI II)"6"6!7q9:;<<r7   N)rp   r   r   r   )r   r   r   r   r   rr   rv   r7   r5   r9  r9    s      = !=r7   r9  c                4   g }| D ]  }t        ddd      }|j                  dg       D ]  }t        ||d        t        t	        j
                  |d         |d      }|j                  d      |_        |j                  |j                  |      d	           |S )
z,Generate the non-native lazy IR node classesr   r   r   r   TrA   rj   r   r   )	r
   getsetattrr   r   parser   rY   rn   )
non_nativegen_lazy_irnodesopr   pr<   s          r5   !generate_non_native_lazy_ir_nodesrE    s     E 	1%lM?S
b) 	)AJ4(	) n222f:>
SWXx([__V,Q/0	1 Lr7   )r4   r	   r   rd   r   )r<   r   rG   r  rH   rd   r   rd   )rG   r   r   ztuple[str, list[Binding]])r@  zlist[dict[str, Any]]rA  rb   r   r   )7
__future__r   r   abcr   dataclassesr   typingr   torchgen.api.dispatcherapir$  torchgen.api.lazyr   r   r	   r
   r   r   torchgen.api.translater   torchgen.api.typesr   r   r   r   r   r   r   r   torchgen.contextr   torchgen.dest.lazy_ts_loweringr   torchgen.modelr   r   r   r   r   r   r   r   r    r6   r>   rN   rF   r_   rb   r   r   r   r9  rE  rv   r7   r5   <module>rR     s;   "   !  , ,  -	 	 	 9 ;
 
 
8!v'	.  		0
  +  $h
 h
 h
V $5) 5 5p $n
 n
 n
bD D< $= = =*$3<r7   