+
    &js                       ^ RI Ht ^ RIt^ RIHt ^ RIHt ^ RIHt ^ RI	H
u Ht ^ RIHtHtHtHtHtHt ^ RIHt ^ RIHtHtHtHtHtHtHtHt ^ R	IHt ^ R
I H!t! ^ RI"H#t#H$t$H%t%H&t&H't'H(t(H)t)H*t*H+t+ R R lt,R R lt-R R lt.R R lt/R R lt0]! RR7       ! R R]4      4       t1]! RR7       ! R R]14      4       t2]! RR7       ! R R4      4       t3 ! R R4      t4]! RR7       ! R  R!4      4       t5R" R# lt6R# )$    )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                    V ^8  d   QhRRRR/# )   argr	   returnstr )formats   "m/Users/jameslopez/projects/CWCArchive/cwc-podcast/.venv/lib/python3.14/site-packages/torchgen/dest/lazy_ir.py__annotate__r)   +   s     8! 8!\ 8!c 8!    c                   \        V P                  4      '       EdG   \        V P                  \        4      '       d   V P                  '       d   RV P
                   2# V P                  P                  \        J d   RV P
                   R2# V P                  '       d   RV P
                   R2# RV P
                   R2# \        V P                  \        4      '       dm   V P                  '       d   V P
                   RV P
                   R2# V P                  '       d   RV P
                   2# RV P
                   R	V P
                   R
2# \        RV P                   R24      h\        V P                  \        4      '       dr   V P                  P                  \        \        P                   4      8X  d@   V P"                  '       d   RV P
                   R2# RV P
                   RV P
                   R2# \        V P                  \$        4      '       di   \        V P                  P                  \        4      '       d?   RV P                  P                  P                   RV P
                   RV P
                   R2# \        V P                  \        4      '       d   \        V P                  P                  \$        4      '       dp   \        V P                  P                  P                  \        4      '       d<   RV P                  P                  P                  P                   RV P
                   R2# V P
                   # )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   )r#   s   &r(   node_ctor_arg_rvalue_stringr>   +   s    3==!!cmmY//$$$sxxj))##'77sxxj44&&&(
!44388*N33}55$$$ ((#I#((Sfgg&&&sxxj))z "++.88* 5!! !OPSP]P]^_`  cmmX..3==3E3EMMJ
 4
 zzz0
!<<.sxxj
388*GTT{33
MM	9
 9
 "#--"4"4"9"9!:"SXXJjQTQYQYPZZabbs}}m443==--{;;3==--22I>>3CMM4F4F4K4K4P4P3QQSTWT\T\S]]^__hhZ r*   c                    V ^8  d   QhRRRR/# r"   schemar   r$   r%   r&   )r'   s   "r(   r)   r)   f   s     ' '\ 'c 'r*   c                ~    V P                  4        Uu. uF  p\        V4      NK  	  ppRP                  V4      # u upi )z_
Produce a formatted string with the arguments as passed into the constructor of a node class.
, )filtered_argsr>   join)rA   r#   node_ctor_valuess   &  r(   node_ctor_inputsrG   f   sG    
 5;4H4H4J4JS#C(4J   99%&&s   :c               (    V ^8  d   QhRRRRRRRR/# )r"   rA   r   sig%DispatcherSignature | NativeSignatureoverload_namer%   r$   r&   )r'   s   "r(   r)   r)   p   s0      	.  		r*   c                   \         P                  ! V P                  4      p\        VP	                  4       VP	                  4       4      pRP                  V Uu. uF  qUP                  NK  	  up4      p\        V4      '       d   RV P                   RV R2pMRV P                   R2pR\        V 4       RV RV R	2# u upi )
zC
Generate code that falls back to eager conditioned on a predicate
z,
                z	ATEN_OP2(rC   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   	argumentsrE   exprlen	aten_nameaten_symbol)rA   rI   rK   dispatcher_sigexprsafallback_argsaten_op_strs   &&&     r(   gen_fallback_coderY   p   s     )44V[[ANcmmo~'?'?'ABE)../F1/FGM
=!&"2"2!32m_AF !1!1 2!4""-f"5!6 7MMXM Z    0Gs   B=c                    V ^8  d   QhRRRR/# r@   r&   )r'   s   "r(   r)   r)      s     
  
  
  
 r*   c                    R 0pV P                   V9   d   RV P                    R2# V P                   P                  R4      '       g   RV P                    2# V P                   # )sigmoid_backwardz#c10::Symbol::fromQualString("aten::z")zat::z
at::aten::)rR   
startswith)rA   missing_interned_stringss   & r(   rS   rS      sk      334V5E5E4FbII&&v..F,,-..r*   c                    V ^8  d   QhRRRR/# )r"   rI   r   r$   ztuple[str, list[Binding]]r&   )r'   s   "r(   r)   r)      s     + +!4 +9R +r*   c                   . p. pV P                  4        F  p\        VP                  \        4      '       d~   VP                  P                  P                  4       '       dT   VP                   R 2pVP                  RV RVP                   R24       VP                  VP                  V4      4       K  VP                  V4       K  	  RP                  V4      pWQ3# )_metazauto z = to_meta();	
        )
rO   r4   argumentr   r7   is_tensor_liker6   append	with_namerE   )rI   contextunwrapped_tensor_argsr#   unwrapped_nameunwrap_tensor_args_strs   &     r(   convert_to_meta_tensorsrl      s    G')}}cllH--#,,2C2C2R2R2T2T #z/N!(('{388*B? NN3==89NN3  *../DE!**r*   T)frozenc                      ] tR t^t$ R]R&   R]R&   R]R&   R]R&   ]R R	 l4       tR
 R ltR R ltR R lt	R R lt
R R ltRtR# )	GenLazyIRr   backend_indexr%   backend_name	node_basebooluse_lazy_shapec                    V ^8  d   QhRRRR/# )r"   fz%NativeFunctionsGroup | NativeFunctionr$   	list[str]r&   )r'   s   "r(   r)   GenLazyIR.__annotate__   s        ?  I  r*   c                	Z   \        V\        4      '       d   VP                  P                  MVP                  pV P                  P                  \        V\        4      '       d   VP                  MT4      p\        Y#R J;'       d    VP                  4       R7      pV P                  V4      # )Nr=   )	r4   r    
functionalrN   rp   
get_kernelr   supports_symintgen)selfrv   rN   metadatarA   s   &&   r(   __call__GenLazyIR.__call__   s    $.q2F$G$Gq||  QVV%%00&q*>??ALLQ
 -LL(2J2J2L
 xxr*   c                    V ^8  d   QhRRRR/# r@   r&   )r'   s   "r(   r)   rx      s        r*   c                	    R #  r&   )r   rA   s   &&r(   lowering_functionGenLazyIR.lowering_function       r*   c               $    V ^8  d   QhRRRRRR/# r"   rA   r   node_ctor_argsr%   r$   r&   )r'   s   "r(   r)   rx      s!      l C C r*   c                	    R # r   r&   r   rA   r   s   &&&r(   create_functionGenLazyIR.create_function   r   r*   c               $    V ^8  d   QhRRRRRR/# r   r&   )r'   s   "r(   r)   rx      s"     
 
\ 
3 
SV 
r*   c                	    R V R2# )bool CanBeReused(z!) const {
    return false;
    }r&   r   s   &&&r(   can_be_reused_function GenLazyIR.can_be_reused_function   s    $^$4 5 
 	
r*   c                    V ^8  d   QhRRRR/# r@   r&   )r'   s   "r(   r)   rx      s     (6 (6, (63 (6r*   c                	   VP                  R RR7      p. pV F  p\        VP                  \        \        34      '       d   VP                  VP                   4       KG  \        VP                  \        4      '       d!   VP                  VP                   R24       K  \        RVP                   R24      h	  RP                  V4      pVP                  RR R7      pVP                  P                  '       d   RpMVP                  P                  '       dV   V Uu. uF  qP                  NK  	  p	pV	P                  R V 4       4       R	VP                   R
RP                  V	4       R2pMVP                  P                  '       dc   \        \!        V4      4       U
u. uF	  p
RV
 R2NK  	  p	p
V	P                  R V 4       4       RVP                   R
RP                  V	4       R2pMRpRP                  R V 4       4      pV P"                   RVP$                   RV RV R\!        VP&                  4       RV R2# u upi u up
i )TFvaluesscalars.value_or(kNullValue)zUnsupported type (z) - add support if necessaryrC   zstd::move(shapes),c              3  8   "   T F  qP                   x  K  	  R # 5iNr6   .0rV   s   & r(   	<genexpr>0GenLazyIR.node_base_ctor_call.<locals>.<genexpr>        :kffk   compute_shape_(z),zoperand(r/   c              3  8   "   T F  qP                   x  K  	  R # 5ir   r   r   s   & r(   r   r      r   r   z[&](){ return compute_shape_z)[0]; },r   c              3  :   "   T F  qP                    x  K  	  R # 5ir   r   r   s   & r(   r   r      s     !C{!VVH+{s   z(
              z&::ClassOpKind(),
              OpList{z},
              z!
              /* num_outputs */ z#,
              torch::lazy::MHash()))rD   r4   r3   r   r   rf   r6   r   r9   rE   
propertiesShapePrecomputeShapeComputeextend
ShapeCacherangerQ   rr   	node_namereturns)r   rA   
value_argsbase_ctor_value_args_listr#   base_ctor_value_argsscalar_argsshape_ctor_argrV   
shape_argsiscalar_hashess   &&          r(   node_base_ctor_callGenLazyIR.node_base_ctor_call   s+   ))u)E
 %'!C#--)[)ABB)00CHH:?CMM=99)00CHH:=R1ST$(7ST    $yy)BC**%*F ,,,1N+++*45*Q&&*J5:k::-fkk]!DIIj<Q;RRTUN)))38Z3IJ3IaHQCq/3IJJ:k::<V[[M499U_K`JaajkNN		!C{!CCNN# $  !+, - !!$V^^!4 5 6""/6 	6 6 Ks   I Ic                    V ^8  d   QhRRRR/# )r"   rA   r   r$   rw   r&   )r'   s   "r(   r)   rx      s     `
 `
, `
9 `
r*   c                	f   VP                   ;'       g    \        V4      pVP                  4       pVP                  R RR7      pV Uu. uF-  pRVP                  P	                  4        RVP
                   2NK/  	  ppRP                  V4      pV P                  '       d.   VP                  P                  '       d   VP                  R4       RP                  V4      pRP                  V U	u. uFg  p	V	P                  P	                  4       R8X  d*   V	P
                   R	V	P
                   R
V	P
                   R2MV	P
                   R	V	P
                   R2NKi  	  up	4      p
\        V
4      '       d   RV
 2p
RP                  V U	u. uF  p	V	P                  P	                  4       R8X  d   RV	P
                   R2MXV	P                  P	                  4       R8X  d   RV	P
                   R2M)V	P                  P	                  4        RV	P
                   R2NK  	  up	4      pVP                  RR R7       Uu. uF1  p\        VP                  \        4      '       g   K%  VP
                  NK3  	  ppRP                  V Uu. uF	  pRV R2NK  	  up4      pRP                  V Uu. uF  pRV RV R2NK  	  up4      p. pV F  p\        VP                  \        4      '       db   VP
                   R2pVP                  '       d   RpVP                  RVP
                   RVP
                   RV RVP
                   R2	4       K  VP                  RVP
                   RVP
                   R24       K  	  RP                  V4      pR VP                   R!V P                    R"V R#VP                   R	V R$V P#                  V4       V
 R%V R&V P                    R'V R(V P%                  W4       R)V P'                  W4       R)V P)                  V4       R)V RV R*2.# u upi u up	i u up	i u upi u upi u upi )+FTr   zconst z& rC   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

};

)opkindrS   rD   r3   cpp_typer6   rE   rt   r   r   rf   rQ   r4   r   is_generatorr   rr   r   r   r   r   )r   rA   r   all_argsr   r   	ctor_argsreuse_ctor_argsr   rV   scalar_initializersscalar_declsr#   optional_valuesvaluehas_optional_declshas_optional_defsmembers_to_stringmembers_to_string_strs   &&                 r(   r~   GenLazyIR.gen   s   55+f"5 '')**%*FJRS(Qvakk2245Rx@(	S))I.6#4#4#D#D#DGH9-+00 %
 %A ;;'')-PP 66(!AFF8#TUVU[U[T\\pqxq*+ %
 "##$/0C/D"E{{ % %A	 ;;'')-?? qvvha( ;;'')-PP 5QVVHA>,,./q:	;
 %	
 ++4+G
G#--7 CHHG 	 

 $[[2AB/yt$/B
 %MM6EFoUtE7%wa(oF
 C#--7788*H-###1E!((SXXJ 'zw 'z 
 "((9SXXJfSXXJa)PQ  !).? @
4>>"2 3  !'x ( 
An% &			!	!&	)*+>*? @ 
 >>
   01 2v78 9&!" #.  7!
 !	
o T
 C Gs,   3P,A-PBP2"P$P$:P)P.r&   N)__name__
__module____qualname____firstlineno____annotations__r   r   r   r   r   r   r~   __static_attributes__r&   r*   r(   ro   ro      sL    N   ! 

(6T`
 `
r*   ro   c                  :    ] tR tRtR R ltR R ltR R ltRtR	# )
GenTSLazyIRiT  c                    V ^8  d   QhRRRR/# r@   r&   )r'   s   "r(   r)   GenTSLazyIR.__annotate__V  s        r*   c                	    R pVP                   P                  '       d   V R2# VP                   P                  '       d   V R\        V4       R2# R# )z
  torch::lazy::TSOpVector Lower(
      std::shared_ptr<torch::jit::GraphFunction> function,
      torch::lazy::TSLoweringContext* loctx) const overrider   z {
    z
  }
            r   )r   LowerDeclOnlyLowerr   )r   rA   	signatures   && r(   r   GenTSLazyIR.lowering_functionV  sd    ?	
 ***[?"$$$!{ #f  
 r*   c               $    V ^8  d   QhRRRRRR/# r   r&   )r'   s   "r(   r)   r   f  s!      l C C r*   c                	    R V R2pVP                   P                  '       d   V R2# VP                   P                  '       g   R# V RVP                   R2# )zstatic NodePtr Create(r/   r   r   z {
    return ReuseOrMakeNode<z>(data);
  })r   CreateFnDeclOnlyCreateFnr   )r   rA   r   r   s   &&& r(   r   GenTSLazyIR.create_functionf  si    ,^,<A>	---[?"""+++; ",,- . 	r*   c               $    V ^8  d   QhRRRRRR/# r   r&   )r'   s   "r(   r)   r   p  s"      \ 3 SV r*   c                	   R V R2pVP                   P                  '       d   V R2# VP                   P                  '       g   R# . p\        P                  ! VP
                  VP                  4       Fb  p\        VP                  \        4      '       d"   VP                  RVP                   R24       KD  VP                  RVP                   24       Kd  	  \        P                  ! VP                  VP                  4       F  p\        VP                  \        4      '       dc   VP                  RVP                   RVP                   R	VP                   R
VP                   RVP                   RVP                   R24       K  VP                  RVP                   RVP                   24       K  	  RP                  V4      pV RV R2# )r   z) constr   r   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_valuesr4   r3   r   rf   r6   positional_scalarskeyword_scalarsrE   )r   rA   r   r   value_comparisonr#   value_comparison_strs   &&&    r(   r   "GenTSLazyIR.can_be_reused_functionp  s   ''7w?	000[?"""...??6#;#;V=R=RSC#--77 ''/z9NO !''*:388*(EF T ??6#<#<f>T>TUC#--77 ''zSXXJl388*BsxxjXdehememdnntuxu}u}t~  A  B !''&
$sxxj(IJ V  /334DE; !" # 	r*   r&   N)r   r   r   r   r   r   r   r   r&   r*   r(   r   r   T  s      r*   r   c                  (   ] tR tRt$ R]R&   R]R&   R]R&   R]R&   R]R	&   R]R
&   R]R&   R]R&   R]R&   R]R&   R]R&   R]R&   R]R&   R]R&   R]R&   R R ltR R ltR R ltR R ltR R lt	R R lt
R(R! R" lltR# R$ lt]R% R& l4       tR'tR # ))GenLazyNativeFuncDefinitioni  r%   class_method_namer   rp   tensor_classrs   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               $    V ^8  d   QhRRRRRR/# r"   rN   r   rA   r   r$   r%   r&   )r'   s   "r(   r)   (GenLazyNativeFuncDefinition.__annotate__  s!     /6 /6n /6l /6s /6r*   c                	T   VP                  R RR7      p. pV EF|  pVP                  '       d   \        VP                  \        4      '       d<   VP                  RVP                   RVP                   RVP                   R24       Kq  VP                  RVP                   RVP                   R24       K  VP                  '       d   K  \        VP                  \        4      '       d   VP                  P                  \        J dJ   VP                  R	VP                   R
V P                   RV P                   RVP                   R2	4       EK:  VP                  V P                   RVP                   RV P                   RV P                   RVP                   R2
4       EK  \        VP                  \        4      '       d   VP                  P                  \        \!        4       4      8w  d7   \#        R\        \!        4       4       RVP                  P                   24      hVP                  V P                   RVP                   RV P                   RV P$                   RVP                   R2
4       EKf  \#        RVP                   R24      h	  RP'                  V4      # )TFr   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   rb   z lazy_z"Expected OptionalCType elem to be z, got z.value_or(at::Tensor()));r0   r/   rc   )rD   r5   r4   r3   r   rf   r6   r8   r   r7   r   r   r   r   r   r;   r   r9   r   rE   )r   rN   rA   r   lazy_tensor_declsr#   s   &&&   r(   r  -GenLazyNativeFuncDefinition.lazy_tensor_decls  sw   ))u)E
')C$$$cmm];;%,,&sxxjCHH: >558XXJ ? # &,,&sxxj 1<<?HH:EW[ &&&CMM955==%%)99%,,$SXXJn112"T5H5H4I388*TVX
 &,,//0sxxj112"T5S5S4TTUVYV^V^U__qs CMM=99==%%9;)??(<Yy{=S<T U"}}1124  "((++,F388*C--.b1D1D0EQsxxjPik
 %STWTaTaSbbcd Q V ""#455r*   c          
     ,    V ^8  d   QhRRRRRRRRR	R
/# )r"   rN   r   rA   r   r   r   rI   rJ   r$   r%   r&   )r'   s   "r(   r)   r    s<        "	
 3 
r*   c                	    V P                   '       d,   \        W$VP                  P                  P                  R 7      # R# ))rK   r   )r   rY   rN   r6   rK   )r   rN   rA   r   rI   s   &&&&&r(   force_eager_fallback0GenLazyNativeFuncDefinition.force_eager_fallback  s5     ((($499>>+G+G  r*   c               $    V ^8  d   QhRRRRRR/# r  r&   )r'   s   "r(   r)   r    s!     * *N *L *S *r*   c                	     V P                    R 2# )r   )r   )r   rN   rA   s   &&&r(   metrics#GenLazyNativeFuncDefinition.metrics  s    &&'q))r*   c               $    V ^8  d   QhRRRRRR/# r  r&   )r'   s   "r(   r)   r    s!      ~ |  r*   c                	   VP                  R RR7      pVP                  RR R7      pV Uu. uF#  qUP                  '       d   K  VP                   NK%  	  pp\        \	        \
        4      4      pV Uu. uF!  qUP                  V8X  g   K  VP                  NK#  	  pp\        V4      ^ 8X  d   \        V4      ^ 8X  d   \        R4      hV P                   RRP                  Wh,           4       R2p	RV	 R2# u upi u upi )	TFr   z*Expected at least one Value or Device typer   rC   r/   zauto common_device = z8;
        TORCH_INTERNAL_ASSERT(common_device);
        )rD   r5   r6   r   r   r   r3   rQ   r9   r   rE   )
r   rN   rA   r   r   rV   value_types_namesoptional_deviceoptional_devicesget_device_strs
   &&&       r(   
get_device&GenLazyNativeFuncDefinition.get_device  s   ))u)E
**%*F2<X*QDWDW[x[*X'	'(:;'
'q;;/+IFAFFK 	 
  !Q&3/?+@A+E !MNN!!"!DII.?.R$S#TTUV 	 )(8 9	  	 Y
s   C3C32C8	C8c               $    V ^8  d   QhRRRRRR/# r  r&   )r'   s   "r(   r)   r    s&     N NN NL NS Nr*   c           
     	,   V P                   P                  V4      pVf#   \        RVP                  P                   24      hVP                  4       p\        VP                  4      pRVP                  9   pVP                  ;'       g    VP                  R JpV'       g
   V'       Ed^   RpV^8  dF   R R lp	RP                  \        V4       U
u. uF
  q! V
4      NK  	  up
4      pRV,           R,           p\        P                  ! VP                  4      p\        V4      w  r\!        WP#                  4       R	R
7       Uu. uF  pVP$                  NK  	  ppV'       d9   VP&                  '       g$   \        RVP                  P                   R24      hRpMRpVP(                  pVP                  P+                  4       '       d    VP-                  4       '       d
   VR,          pRV RV RV RRP                  V4       RV 2
pM5\/        VP0                  WP-                  4       R7      pRVP2                   R2pVRV R2,          pR\5        VP                  4      ,           pVRRP                  R V 4       4       RV R2,          pV# u up
i u upi ) NNo kernel metadata found for 	view_copyzl
std::vector<torch::lazy::Shape> shapes{torch::lazy::Shape(out_meta.scalar_type(), out_meta.sizes().vec())};c                    V ^8  d   QhRRRR/# )r"   r   intr$   r%   r&   )r'   s   "r(   r)   AGenLazyNativeFuncDefinition.shape_inference.<locals>.__annotate__  s      # # r*   c                    R V  RV  R2# )ztorch::lazy::Shape(std::get<z$>(out_meta).scalar_type(), std::get<z>(out_meta).sizes().vec())r&   )r   s   &r(   
this_shape?GenLazyNativeFuncDefinition.shape_inference.<locals>.this_shape  s    9!<`ab`cc}~~r*   ,z'std::vector<torch::lazy::Shape> shapes{z};F)methodzview_copy op z8 must have CompositeExplicitAutogradNonFunctional kernel&compositeexplicitautogradnonfunctionalmeta_symintz        z
        auto out_meta = at::r  r   rC   z);
        rz   z
            auto shapes = r   z4
            TORCH_INTERNAL_ASSERT(shapes.size() == rb   zaten::zq
            if(torch::lazy::symbolicShapeEnabled()){
                std::vector<torch::jit::IValue> inputs = { c              3  L   "   T F  p\        VP                  4      x  K  	  R # 5ir   )r%   r6   r   s   & r(   r   >GenLazyNativeFuncDefinition.shape_inference.<locals>.<genexpr>:  s     Fe\dWXs166{{\ds   "$z. };
                const char* schema_str = "z^";
                applySymbolicShapesOnLT(schema_str, inputs, shapes);
            }
        )rp   r|   r9   rN   r6   rD   rQ   r   tags
structuredstructured_delegaterE   r   r   rM   rl   r   rO   rP   5has_composite_explicit_autograd_non_functional_kernelrR   
has_symintr}   ComputeShapeSignaturekernel
shape_callr%   )r   rN   rA   r   r   returns_lengthis_view_copy_opis_structuredmeta_outr   r   
shapes_strrT   meta_conversion_strmeta_call_ctxemeta_call_argsdispatch_nsrR   	shape_str	shape_sigfunc_schema_strs   &&&                   r(   shape_inference+GenLazyNativeFuncDefinition.shape_inference  s   %%006 #@@P!QRR'')V^^, &2OO4+C+C4+OOOoH! !XXeN>S&T>Sz!}>S&TU
DzQTXX 1<<TYYGN1H1X. #!#;#;#=eA    QQQ('		'7 8H H  G$((Iyy##%%(*B*B*D*DY&			 (MI;a		.8Q7R S		
I
 ..F.F.HI$//05I 	 44B3C2I 	I	 #S^3 ==AYYFe\dFe=e<f g++:*; <	 		 i 'Us   JJc               $    V ^8  d   QhRRRRRR/# r  r&   )r'   s   "r(   r)   r  A  s!      . , 3 r*   c                	    \        V4      pR VP                   RV RV P                  W4       RVP                   RV R2# )z3torch::lazy::NodePtr node = torch::lazy::ReuseNode<r2   z$);
        if (!node) {
            z*
            node = torch::lazy::MakeNode<zE, std::move(shapes));
            CacheNode(node);
        }
        )rG   r   r>  )r   rN   rA   node_ctor_input_strs   &&& r(   build_ir_node)GenLazyNativeFuncDefinition.build_ir_nodeA  sd    .v6FvGWGWFXXZ[nZo p!!$/0 1**0*:*:);2>Q=R S	 	r*   Nc                    V ^8  d   QhRRRR/# )r"   first_tensor_namez
str | Noner$   r%   r&   )r'   s   "r(   r)   r  K  s     A AJ A# Ar*   c                	    V P                   '       d!   Vf   \        R4      hV RV P                   2# V P                   RV P                   2# )Nz+Requires first tensor to create lazy tensor.r  )r   r9   r   r   )r   rF  s   &&r(   create_lazy_tensor.GenLazyNativeFuncDefinition.create_lazy_tensorK  sX    ((( ($%RSS'($*<*<)=>>(()D,>,>+?@@r*   c               $    V ^8  d   QhRRRRRR/# r  r&   )r'   s   "r(   r)   r  T  s"      ~ | PS r*   c                	   \        VP                  4      pVP                  R RR7      pV Uu. uF#  qUP                  '       d   K  VP                   NK%  	  pp\        V4      ^ 8  d
   V^ ,          MRpRV P
                   RV P                  V4       R2pV^8  d\   \        V4      ^ 8X  d   \        R4      hRV P                   R	V R
V P                  V4       R\        4        RV P                   RV R2pVP                  P                  P                  '       g!   VP                  P                  4       '       d    V^8w  d   \        RV R24      hRV RV R2pVR,          pV# u upi )TFr   Nzauto result = z(
                z#(std::move(node), *common_device));z3Code below assumes there is at least one tensor argr1   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 rH  r-   z2->SetInPlaceIrValue(node);
        auto& result = r   z
        return result;)rQ   r   rD   r5   r6   r   rI  r9   r   r   r   inplacerN   	is_out_fn)	r   rN   rA   r1  r   rV   r  rF  
bridge_strs	   &&&      r(   return_aten_tensor.GenLazyNativeFuncDefinition.return_aten_tensorT  s   V^^,))u)E
2<X*QDWDW[x[*X478I4JQ4N-a0TX'(H(H'I J(():;<<_c
 A$%*$I  *$*>*>)? @+, -$$($;$;<M$N#OqQZQ\P] ^778.9IIY	]J ;;###tyy':':'<'<"$CCQBRRSU  ##4"5 6)*!/J 	  	
7 Ys   E'E'c                    V ^8  d   QhRRRR/# )r"   rN   r   r$   rw   r&   )r'   s   "r(   r)   r  u  s     
 
^ 
	 
r*   c                	2   \        WP                  4      pV P                  P                  V4      pVf#   \        RVP                  P
                   24      h\        VP                  VP                  4       R7      pRVP                  V P                   RVP                   2R7       RV P                  WW24       RV P                  W4       RV P                  W4       RV P                  W4       RV P                  W4       RV P!                  W4       R2.# )	Nr  rz   z    r  r   z {
        rc   z
    }

    )r   rp   r|   r9   rN   r6   r   r}   declr   r/  r
  r  r  r  rC  rQ  )r   rN   rI   r   rA   s   &&   r(   r   $GenLazyNativeFuncDefinition.__call__t  s(   t%7%78%%006 #@@P!QRRdii0H0H0JKXXd,,-R/@AXBC D			"	"4	?@ A		d	#$ %			&' (					-. /				D	)* +			 	 	./ 0	
 	
r*   r&   r   )r   r   r   r   r   r  r
  r  r  r>  rC  rI  rQ  r   r   r   r&   r*   r(   r   r     s    """"""!$$!$$/6b*"N`A@ !
 !
r*   r   c                  j    ] tR tRtRtR R ltR R ltR R lt]R	 R
 l4       t	]R R l4       t
RtR# )r.  i  ze
Here we use the base name as the suffix of the signature to avoid generating for in-place variants.
c               (    V ^8  d   QhRRRRRRRR/# )	r"   kernel_namer%   rv   r   r=   rs   r$   Noner&   )r'   s   "r(   r)   "ComputeShapeSignature.__annotate__  s)     ) )C )N )t )PT )r*   c               	   \        VP                  VR 7      V n        RP                  \        P
                  ! VP                  VR 7       Uu. uF  qDP                  4       NK  	  up4      V n        RP                  V P                  P                  RR7       Uu. uF  qUP                   NK  	  up4      V n
        Wn        R# u upi u upi )rz   rC   T)	generatorN)r   rN   _ComputeShapeSignature__schemarE   
dispatcherrO   rU  %_ComputeShapeSignature__dispatch_argsrD   r6   !_ComputeShapeSignature__call_args#_ComputeShapeSignature__kernel_name)r   rY  rv   r=   rV   r#   s   &&&$  r(   __init__ComputeShapeSignature.__init__  s    $QVVF;#yy)33AFF6JKJ!VVXJK 
  99&*mm&A&AD&A&QR&Qsz]&QR
 ) L Ss   CCc                   V ^8  d   QhRR/# r"   r$   r%   r&   )r'   s   "r(   r)   r[    s     ? ?s ?r*   c                	:    V P                    R V P                   R2# r   r/   )rb  r`  r   s   &r(   __decl_suffix#ComputeShapeSignature.__decl_suffix  s#    $$%Qt';';&<A>>r*   c                   V ^8  d   QhRR/# rf  r&   )r'   s   "r(   r)   r[    s     ; ;s ;r*   c                	:    V P                    R V P                   R2# rh  )rb  ra  ri  s   &r(   __call_suffix#ComputeShapeSignature.__call_suffix  s#    $$%Qt'7'7&8::r*   c                   V ^8  d   QhRR/# rf  r&   )r'   s   "r(   r)   r[    s     a aC ar*   c                	(    R V P                  4        2# )z8TORCH_API std::vector<torch::lazy::Shape> compute_shape_)#_ComputeShapeSignature__decl_suffixri  s   &r(   
shape_decl ComputeShapeSignature.shape_decl  s    I$J\J\J^I_``r*   c                   V ^8  d   QhRR/# rf  r&   )r'   s   "r(   r)   r[    s     D DC Dr*   c                	(    R V P                  4        2# )ztorch::lazy::compute_shape_)#_ComputeShapeSignature__call_suffixri  s   &r(   r0   ComputeShapeSignature.shape_call  s    ,T-?-?-A,BCCr*   )__call_args__dispatch_args__kernel_name__schemaN)r   r   r   r   __doc__rc  rr  rw  propertyrs  r0  r   r&   r*   r(   r.  r.    sB    )?; a a D Dr*   r.  c                  B    ] tR tRt$ R]R&   R]R&   ]R R l4       tRtR	# )
GenLazyShapeInferenceDefinitioni  r   rp   r%   r   c                    V ^8  d   QhRRRR/# )r"   rv   r   r$   rw   r&   )r'   s   "r(   r)   ,GenLazyShapeInferenceDefinition.__annotate__  s     = =. =Y =r*   c                	   V P                   P                  V4      pVf#   \        RVP                  P                   24      hRVP
                  9   pVP                  ;'       g    VP                  R JpV'       g	   V'       d   . # \        VP                  WP                  4       R7      pRP                  VP                   R2.4      .# )Nr  r  rz   
r   )rp   r|   r9   rN   r6   r)  r*  r+  r.  r/  r}   rE   rs  )r   rv   r   r2  r3  r<  s   &&    r(   r   (GenLazyShapeInferenceDefinition.__call__  s    %%003 #@!NOO &/II(=(=T(IOI-+C+C+EI II)"6"6!7q9:;<<r*   r&   N)r   r   r   r   r   r   r   r   r&   r*   r(   r  r    s      = !=r*   r  c               $    V ^8  d   QhRRRRRR/# )r"   
non_nativezlist[dict[str, Any]]gen_lazy_irro   r$   rw   r&   )r'   s   "r(   r)   r)     s$      $3<r*   c                L   . pV  F  p\        RRR4      pVP                  R. 4       F  p\        WER4       K  	  \        \        P
                  ! VR,          4      VRR7      pVP                  R4      Vn        VP                  VP                  V4      ^ ,          4       K  	  V# )	z,Generate the non-native lazy IR node classesr   r   r   r   TrN   rz   r   )	r
   getsetattrr   r   parser   rf   r~   )r  r  nodesopr   prA   s   &&     r(   !generate_non_native_lazy_ir_nodesr    s     E%lM?S
b)AJ4( * n222f:>
SWXx([__V,Q/0  Lr*   )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    r>   rG   rY   rS   rl   ro   r   r   r.  r  r  r&   r*   r(   <module>r     s    "   !  , ,  -	 	 	 9 ;
 
 
8!v'0
  +  $h
 h
 h
V $5) 5 5p $x
 x
 x
vD D< $= = =,r*   