
    JTh>q                       S SK Jr  S SKrS SKJr  S SKJr  S SKJr  S SK	J
s  Jr  S SKJrJrJrJrJrJr  S SKJr  S SKJrJrJrJrJrJrJrJr  S S	KJr  S S
K J!r!  S SK"J#r#J$r$J%r%J&r&J'r'J(r(J)r)J*r*J+r+  SS jr,SS jr-        S S jr.SS jr/S!S jr0\" SS9 " S S\5      5       r1\" SS9 " S S\15      5       r2\" SS9 " S S5      5       r3 " S S5      r4\" SS9 " S S5      5       r5      S"S jr6g)#    )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                d   [        U R                  5      (       Ga?  [        U R                  [        5      (       a~  U R                  (       a  SU R
                   3$ U R                  R                  [        L a  SU R
                   S3$ U R                  (       a  SU R
                   S3$ SU R
                   S3$ [        U R                  [        5      (       aj  U R                  (       a  U R
                   SU R
                   S3$ U R                  (       a  SU R
                   3$ SU R
                   S	U R
                   S
3$ [        SU R                   S35      e[        U R                  [        5      (       ao  U R                  R                  [        [        R                   5      :X  a>  U R"                  (       a  SU R
                   S3$ SU R
                   SU R
                   S3$ [        U R                  [$        5      (       ag  [        U R                  R                  [        5      (       a>  SU R                  R                  R                   SU R
                   SU R
                   S3$ [        U R                  [        5      (       a  [        U R                  R                  [$        5      (       an  [        U R                  R                  R                  [        5      (       a;  SU R                  R                  R                  R                   SU R
                   S3$ U R
                   $ )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    M/var/www/auris/envauris/lib/python3.13/site-packages/torchgen/dest/lazy_ir.pynode_ctor_arg_rvalue_stringr6   +   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
 zz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     c                    U R                  5        Vs/ s H  n[        U5      PM     nnSR                  U5      $ s  snf )z_
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   sG    
 5;4H4H4J4JS#C(4J   99%&&s   ;c                   [         R                  " U R                  5      n[        UR	                  5       UR	                  5       5      nSR                  U Vs/ s H  oUR                  PM     sn5      n[        U5      (       a  SU R                   SU S3nOSU R                   S3nS[        U 5       SU SU S	3$ s  snf )
zC
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)../F1/FGM
=!&"2"2!32m_AF !1!1 2!4""-f"5!6 7MMXM Z    0Gs   B=c                    S1nU R                   U;   a  SU R                    S3$ U R                   R                  S5      (       d  SU R                    3$ U R                   $ )Nsigmoid_backwardz#c10::Symbol::fromQualString("aten::z")zat::z
at::aten::)rE   
startswith)r<   missing_interned_stringss     r5   rF   rF      sk      334V5E5E4FbII&&v..F,,-..r7   c                   / n/ nU R                  5        H  n[        UR                  [        5      (       a|  UR                  R                  R                  5       (       aS  UR                   S3nUR                  SU SUR                   S35        UR                  UR                  U5      5        M  UR                  U5        M     SR                  U5      nXQ4$ )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--#,,2C2C2R2R2T2T #z/N!(('{388*B? NN3==89NN3  *../DE!**r7   T)frozenc                      \ rS rSr% S\S'   S\S'   S\S'   S\S'   \SS	 j5       rSS
 jrSS jrSS jr	SS jr
SS jrSrg)	GenLazyIR   r   backend_indexstrbackend_name	node_basebooluse_lazy_shapec                N   [        U[        5      (       a  UR                  R                  OUR                  nU R                  R                  [        U[        5      (       a  UR                  OU5      n[        X#S L=(       a    UR                  5       S9nU R                  U5      $ )Nr3   )	r*   r    
functionalrA   rd   
get_kernelr   supports_symintgen)selffrA   metadatar<   s        r5   __call__GenLazyIR.__call__   s    $.q2F$G$Gq||  QVV%%00&q*>??ALLQ
 -L(2J2J2L
 xxr7   c                    gN  )rp   r<   s     r5   lowering_functionGenLazyIR.lowering_function       r7   c                    grv   rx   rp   r<   node_ctor_argss      r5   create_functionGenLazyIR.create_function   r{   r7   c                    SU S3$ )Nbool CanBeReused(z!) const {
    return false;
    }rx   r}   s      r5   can_be_reused_function GenLazyIR.can_be_reused_function   s    $^$4 5 
 	
r7   c                   UR                  SSS9n/ nU H  n[        UR                  [        [        45      (       a  UR                  UR                   5        MF  [        UR                  [        5      (       a   UR                  UR                   S35        M  [        SUR                   S35      e   SR                  U5      nUR                  SSS9nUR                  R                  (       a  SnOUR                  R                  (       aV  U Vs/ s H  oR                  PM     n	nU	R                  S	 U 5       5        S
UR                   SSR                  U	5       S3nOUR                  R                  (       ac  [        [!        U5      5       V
s/ s H	  n
SU
 S3PM     n	n
U	R                  S U 5       5        SUR                   SSR                  U	5       S3nOSnSR                  S U 5       5      nU R"                   SUR$                   SU SU S[!        UR&                  5       SU S3$ s  snf s  sn
f )NTFvaluesscalars.value_or(kNullValue)zUnsupported type (z) - add support if necessaryr9   zstd::move(shapes),c              3  8   #    U  H  oR                   v   M     g 7fNr,   .0rK   s     r5   	<genexpr>0GenLazyIR.node_base_ctor_call.<locals>.<genexpr>        :kffk   compute_shape_(z),zoperand(r%   c              3  8   #    U  H  oR                   v   M     g 7fr   r   r   s     r5   r   r      r   r   z[&](){ return compute_shape_z)[0]; },rw   c              3  :   #    U  H  oR                    v   M     g 7fr   r   r   s     r5   r   r      s     !C{!VVH+{s   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   rg   	node_namereturns)rp   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_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   H8H=c                R   UR                   =(       d    [        U5      nUR                  5       nUR                  SSS9nU Vs/ s H-  nSUR                  R	                  5        SUR
                   3PM/     nnSR                  U5      nU R                  (       a,  UR                  R                  (       a  UR                  S5        SR                  U5      nSR                  U V	s/ s Hf  n	U	R                  R	                  5       S	:X  a)  U	R
                   S
U	R
                   SU	R
                   S3OU	R
                   S
U	R
                   S3PMh     sn	5      n
[        U
5      (       a  SU
 3n
SR                  U V	s/ s H  n	U	R                  R	                  5       S:X  a  SU	R
                   S3OWU	R                  R	                  5       S	:X  a  SU	R
                   S3O)U	R                  R	                  5        SU	R
                   S3PM     sn	5      nUR                  SSS9 Vs/ s H0  n[        UR                  [        5      (       d  M$  UR
                  PM2     nnSR                  U Vs/ s H	  nSU S3PM     sn5      nSR                  U Vs/ s H  nSU SU S3PM     sn5      n/ nU H  n[        UR                  [        5      (       a`  UR
                   S3nUR                  (       a  SnUR                  SUR
                   SUR
                   SU SUR
                   S3	5        M  UR                  S UR
                   SUR
                   S35        M     SR                  U5      nS!UR                   S"U R                    S#U S$UR                   S
U S%U R#                  U5       U
 S&U S'U R                    S(U S)U R%                  X5       S*U R'                  X5       S*U R)                  U5       S*U SU S+3/$ s  snf s  sn	f s  sn	f s  snf s  snf s  snf ),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;   ri   r   r   rY   rD   r*   r   is_generatorr   rg   r   r   r   ry   )rp   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   ro   GenLazyIR.gen   su   5+f"5 '')**%*FJRS(Qvakk2245Rx@(	S))I.6#4#4#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,   4P'A-P?BP(#PP0PP$rx   N)rq   z%NativeFunctionsGroup | NativeFunctionreturn	list[str]r<   r   r   re   r<   r   r~   re   r   re   )r<   r   r   r   )__name__
__module____qualname____firstlineno____annotations__r   rs   ry   r   r   r   ro   __static_attributes__rx   r7   r5   rb   rb      sF    N   ! 

(6T`
r7   rb   c                  2    \ rS rSrSS jrSS jrSS jrSrg)	GenTSLazyIRiT  c                    SnUR                   R                  (       a  U S3$ UR                   R                  (       a  U S[        U5       S3$ g)Nz
  torch::lazy::TSOpVector Lower(
      std::shared_ptr<torch::jit::GraphFunction> function,
      torch::lazy::TSLoweringContext* loctx) const overrider   z {
    z
  }
            rw   )r   LowerDeclOnlyLowerr   )rp   r<   	signatures      r5   ry   GenTSLazyIR.lowering_functionV  s^    ?	
 **[?"$$!{ #f  
 r7   c                    SU S3nUR                   R                  (       a  U S3$ UR                   R                  (       d  gU SUR                   S3$ )Nzstatic NodePtr Create(r%   r   rw   z {
    return ReuseOrMakeNode<z>(data);
  })r   CreateFnDeclOnlyCreateFnr   )rp   r<   r~   r   s       r5   r   GenTSLazyIR.create_functionf  sc    ,^,<A>	--[?"""++; ",,- . 	r7   c                   SU S3nUR                   R                  (       a  U S3$ UR                   R                  (       d  g/ n[        R                  " UR
                  UR                  5       Ha  n[        UR                  [        5      (       a!  UR                  SUR                   S35        MC  UR                  SUR                   35        Mc     [        R                  " UR                  UR                  5       H  n[        UR                  [        5      (       ab  UR                  SUR                   S	UR                   S
UR                   SUR                   SUR                   SUR                   S35        M  UR                  SUR                   SUR                   35        M     SR                  U5      nU SU S3$ )Nr   z) constr   rw   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;   )rp   r<   r~   r   value_comparisonr4   value_comparison_strs          r5   r   "GenTSLazyIR.can_be_reused_functionp  s   ''7w?	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; !" # 	r7   rx   Nr   r   )r   r   r   r   ry   r   r   r   rx   r7   r5   r   r   T  s     r7   r   c                  (   \ rS rSr% S\S'   S\S'   S\S'   S\S'   S\S	'   S\S
'   S\S'   S\S'   S\S'   S\S'   S\S'   S\S'   S\S'   S\S'   S\S'   SS jr          S S jrSS jrSS jrSS jr	SS jr
S!S"S jjrSS jr\S#S j5       rSrg)$GenLazyNativeFuncDefinitioni  re   class_method_namer   rd   tensor_classrh   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                
   UR                  SSS9n/ nU GHZ  nUR                  (       a  [        UR                  [        5      (       a;  UR                  SUR                   SUR                   SUR                   S35        Mo  UR                  SUR                   SUR                   S	35        M  UR                  (       a  M  [        UR                  [        5      (       a  UR                  R                  [        L aI  UR                  S
UR                   SU R                   SU R                   SUR                   S3	5        GM5  UR                  U R                   SUR                   SU R                   SU R                   SUR                   S	3
5        GM  [        UR                  [        5      (       a  UR                  R                  [        [!        5       5      :X  d   UR                  R                  5       eUR                  U R                   SUR                   SU R                   SU R"                   SUR                   S3
5        GMD  [%        SUR                   S35      e   SR'                  U5      $ )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;   )rp   rA   r<   r   lazy_tensor_declsr4   s         r5   r   -GenLazyNativeFuncDefinition.lazy_tensor_decls  sO   ))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}}))Yy{-CCWS]]EWEWWC "((++,F388*C--.b1D1D0EQsxxjPik
 %STWTaTaSbbcd I N ""#455r7   c                v    U R                   (       a(  [        X$UR                  R                  R                  S9$ g)N)rH   rw   )r   rN   rA   r,   rH   )rp   rA   r<   rr   rG   s        r5   force_eager_fallback0GenLazyNativeFuncDefinition.force_eager_fallback  s2     (($499>>+G+G  r7   c                     U R                    S3$ )Nr   )r   )rp   rA   r<   s      r5   metrics#GenLazyNativeFuncDefinition.metrics  s    &&'q))r7   c                   UR                  SSS9nUR                  SSS9nU Vs/ s H"  oUR                  (       a  M  UR                   PM$     nn[        [	        [
        5      5      nU Vs/ s H   oUR                  U:X  d  M  UR                  PM"     nn[        U5      S:  d  [        U5      S:  d   S5       eU R                   SSR                  Xh-   5       S3n	S	U	 S
3$ s  snf s  snf )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;   )
rp   rA   r<   r   r   rK   value_types_namesoptional_deviceoptional_devicesget_device_strs
             r5   
get_device&GenLazyNativeFuncDefinition.get_device  s	   ))u)E
**%*F2<X*QDWDW[x[*X'	'(:;'
'q;;/+IFAFFK 	 
 $%)S1A-BQ-F 	
8	
F !!"!DII.?.R$S#TTUV 	 )(8 9	  	 Y
s   C#C#,C(C(c           
     ^   U R                   R                  U5      nUc   eUR                  5       n[        UR                  5      nSUR
                  ;   nUR                  =(       d    UR                  S LnU(       d  U(       Ga)  SnUS:  a=  SS jn	SR                  [        U5       V
s/ s H
  o" U
5      PM     sn
5      nSU-   S-   n[        R                  " UR                  5      n[        U5      u  p[        XR                  5       SS	9 Vs/ s H  nUR                   PM     nnU(       a  UR"                  (       d   eS
nOSnUR$                  nUR                  R'                  5       (       a  UR)                  5       (       a  US-  nSU SU SU SSR                  U5       SU 3
nO2[+        UR,                  XR)                  5       S9nSUR.                   S3nUSU S3-  nS[1        UR                  5      -   nUSSR                  S U 5       5       SU S3-  nU$ s  sn
f s  snf )N	view_copyzl
std::vector<torch::lazy::Shape> shapes{torch::lazy::Shape(out_meta.scalar_type(), out_meta.sizes().vec())};   c                    SU  SU  S3$ )Nztorch::lazy::Shape(std::get<z$>(out_meta).scalar_type(), std::get<z>(out_meta).sizes().vec())rx   )r   s    r5   
this_shape?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);
        rk   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  L   #    U  H  n[        UR                  5      v   M     g 7fr   )re   r,   r   s     r5   r   >GenLazyNativeFuncDefinition.shape_inference.<locals>.<genexpr>2  s     Fe\dWXs166{{\ds   "$z. };
                const char* schema_str = "z^";
                applySymbolicShapesOnLT(schema_str, inputs, shapes);
            }
        )r   intr   re   )rd   rm   r:   rD   r   tags
structuredstructured_delegater;   r   r   r@   rA   r_   r   rB   rC   5has_composite_explicit_autograd_non_functional_kernelrE   
has_symintrn   ComputeShapeSignaturekernel
shape_callre   )rp   rA   r<   rr   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_inference+GenLazyNativeFuncDefinition.shape_inference  sk   %%006###'')V^^, &2O4+C+C4+OOoH! !XXeN>S&T>Sz!}>S&TU
DzQTXX 1<<TYYGN1H1X. #!#;#;#=eA    QQQQF$((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++:*; <	 		 a 'Us   *H%H*c                    [        U5      nSUR                   SU SU R                  X5       SUR                   SU S3$ )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"  )rp   rA   r<   node_ctor_input_strs       r5   build_ir_node)GenLazyNativeFuncDefinition.build_ir_node9  sd    .v6FvGWGWFXXZ[nZo p!!$/0 1**0*:*:);2>Q=R S	 	r7   Nc                    U R                   (       a  Uc   S5       eU SU R                   3$ U R                   SU R                   3$ )Nz+Requires first tensor to create lazy tensor.r   )r   r   r   )rp   first_tensor_names     r5   create_lazy_tensor.GenLazyNativeFuncDefinition.create_lazy_tensorC  s[    (($0 =0 (($*<*<)=>>(()D,>,>+?@@r7   c                   [        UR                  5      nUR                  SSS9nU Vs/ s H"  oUR                  (       a  M  UR                   PM$     nn[        U5      S:  a  US   OS nSU R
                   SU R                  U5       S3nUS:  aV  [        U5      S:  d   S	5       eS
U R                   SU SU R                  U5       S[        5        SU R                   SU S3nUR                  R                  R                  (       d  UR                  R                  5       (       a  US:X  d   SU S35       eSU SU S3nUS-  nU$ s  snf )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)	rp   rA   r<   r  r   rK   r   r*  
bridge_strs	            r5   return_aten_tensor.GenLazyNativeFuncDefinition.return_aten_tensorM  s   V^^,))u)E
2<X*QDWDW[x[*X478I4JQ4N-a0TX'(H(H'I J(():;<<_c
 A()A- E- *$*>*>)? @+, -$$($;$;<M$N#OqQZQ\P] ^778.9IIY	]J ;;##tyy':':'<'<!Q& ??M>NaQ& ##4"5 6)*!/J 	  	
3 Ys   EEc                   [        XR                  5      nU R                  R                  U5      nUc   e[        UR                  UR                  5       S9nSUR                  U R                   SUR                   3S9 SU R                  XX25       SU R                  X5       SU R                  X5       SU R                  X5       SU R                  X5       SU R                  X5       S3/$ )Nrk   z    r   r   z {
        rV   z
    }

    )r   rd   rm   r   rA   rn   declr   r  r   r   r   r   r&  r2  )rp   rA   rG   rr   r<   s        r5   rs   $GenLazyNativeFuncDefinition.__call__k  s   t%7%78%%006###dii0H0H0JKXXd,,-R/@AXBC D			"	"4	?@ A		d	#$ %			&' (					-. /				D	)* +			 	 	./ 0	
 	
r7   rx   )rA   r   r<   r   r   re   )
rA   r   r<   r   rr   r   rG   %DispatcherSignature | NativeSignaturer   re   r   )r*  z
str | Noner   re   )rA   r   r   r   )r   r   r   r   r   r   r   r   r   r"  r&  r+  r2  r   rs   r   rx   r7   r5   r   r     s    """"""!$$!$$+6Z  "	
 3 
*$IVA< !
 !
r7   r   c                  ^    \ rS rSrSrS
S jrSS jrSS jr\SS j5       r	\SS j5       r
Srg	)r  i  ze
Here we use the base name as the suffix of the signature to avoid generating for in-place variants.
c                  [        UR                  US9U l        SR                  [        R
                  " UR                  US9 Vs/ s H  oDR                  5       PM     sn5      U l        SR                  U R                  R                  SS9 Vs/ s H  oUR                   PM     sn5      U l
        Xl        g s  snf s  snf )Nrk   r9   T)	generator)r   rA   _ComputeShapeSignature__schemar;   
dispatcherrB   r5  %_ComputeShapeSignature__dispatch_argsr:   r,   !_ComputeShapeSignature__call_args#_ComputeShapeSignature__kernel_name)rp   kernel_namerq   r3   rK   r4   s         r5   __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   B:B?c                :    U R                    SU R                   S3$ Nr   r%   )r?  r=  rp   s    r5   __decl_suffix#ComputeShapeSignature.__decl_suffix  s#    $$%Qt';';&<A>>r7   c                :    U R                    SU R                   S3$ rD  )r?  r>  rE  s    r5   __call_suffix#ComputeShapeSignature.__call_suffix  s#    $$%Qt'7'7&8::r7   c                (    SU R                  5        3$ )Nz8TORCH_API std::vector<torch::lazy::Shape> compute_shape_)#_ComputeShapeSignature__decl_suffixrE  s    r5   
shape_decl ComputeShapeSignature.shape_decl  s    I$J\J\J^I_``r7   c                (    SU R                  5        3$ )Nztorch::lazy::compute_shape_)#_ComputeShapeSignature__call_suffixrE  s    r5   r   ComputeShapeSignature.shape_call  s    ,T-?-?-A,BCCr7   )__call_args__dispatch_args__kernel_name__schemaN)r@  re   rq   r   r3   rh   r   None)r   re   )r   r   r   r   __doc__rA  rL  rP  propertyrM  r  r   rx   r7   r5   r  r    sB    )?; a a D Dr7   r  c                  >    \ rS rSr% S\S'   S\S'   \S	S j5       rSrg)
GenLazyShapeInferenceDefinitioni  r   rd   re   r   c                F   U R                   R                  U5      nUc   eSUR                  ;   nUR                  =(       d    UR                  S LnU(       d  U(       a  / $ [        UR                  XR                  5       S9nSR                  UR                   S3/5      /$ )Nr   rk   
r   )
rd   rm   r  r  r  r  r  rn   r;   rM  )rp   rq   rr   r  r  r   s         r5   rs   (GenLazyShapeInferenceDefinition.__call__  s    %%003### &/I(=(=T(IOI-+C+C+EI II)"6"6!7q9:;<<r7   rx   N)rq   r   r   r   )r   r   r   r   r   r   rs   r   rx   r7   r5   rZ  rZ    s      = !=r7   rZ  c                6   / nU  H  n[        SSS5      nUR                  S/ 5       H  n[        XES5        M     [        [        R
                  " US   5      USS9nUR                  S5      Ul        UR                  UR                  U5      S	   5        M     U$ )
z,Generate the non-native lazy IR node classesr   r   r   r   TrA   rk   r   r   )	r
   getsetattrr   r   parser   rY   ro   )
non_nativegen_lazy_irnodesopr   pr<   s          r5   !generate_non_native_lazy_ir_nodesrg    s     E%lM?S
b)AJ4( * n222f:>
SWXx([__V,Q/0  Lr7   )r4   r	   r   re   r   )r<   r   rG   r7  rH   re   r   re   )rG   r   r   ztuple[str, list[Binding]])rb  zlist[dict[str, Any]]rc  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  rZ  rg  rx   r7   r5   <module>rt     s;   "   !  , ,  -	 	 	 9 ;
 
 
8!v'	.  		0
  +  $h
 h
 h
V $5) 5 5p $n
 n
 n
bD D< $= = =*$3<r7   