Ë
    Z^(h>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        «      r�t        | 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    úS/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/torchgen/dest/lazy_ir.pyÚnode_ctor_arg_rvalue_stringr6   +   sn  € ô �3—=‘=Õ!Ü�c—m‘m¤YÔ/Ø×$Ò$Ø˜sŸx™x˜jÐ)Ð)Ø—‘×#Ñ#Ô'7Ñ7Ø˜sŸx™x˜j¨Ð4Ð4Ø×&Ò&Ø(¨¯©¨
°!Ð4Ð4Ø˜3Ÿ8™8˜* NÐ3Ð3Ü˜Ÿ™¤}Ô5Ø×$Ò$ð Ÿ(™(˜Ð#IÈ#Ï(É(ÈÐSfÐgÐgØ×&Ò&Ø˜sŸx™x˜jÐ)Ð)à˜Ÿ™�zð "+Ø+.¯8©8¨*ð 5!ð!ðô !ØOÐPS×P]ÑP]ÈÐ^_Ð`óð ô �c—m‘m¤XÔ.°3·=±=×3EÑ3EÌÜ�M‰MóJ
ò 4
ð �zŠzØ0°·±°
¸!Ð<Ð<à.¨s¯x©x¨j¸
À3Ç8Á8À*ÈGÐTÐTÜ˜Ÿ™¤{Ô3¼
Ø�M‰M×Ñ¤	ô9
ð " #§-¡-×"4Ñ"4×"9Ñ"9Ð!:¸"¸S¿X¹X¸JÀjÐQT×QYÑQYÐPZÐZaÐbÐbä�s—}‘}¤mÔ4Ü˜3Ÿ=™=×-Ñ-¬{Ô;Ü˜3Ÿ=™=×-Ñ-×2Ñ2´IÔ>à3°C·M±M×4FÑ4F×4KÑ4K×4PÑ4PÐ3QÐQSÐTW×T\ÑT\ÐS]Ð]^Ð_Ð_à—h‘h�ZÐ ó    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;×4HÑ4HÓ4JöØ-0Ô# CÕ(ðÐð ð �9‰9Ð%Ó&Ð&ùò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Ñ4°V·[±[ÓA€NÜ�c—m‘m“o ~×'?Ñ'?Ó'AÓB€EØ)×.Ñ.ÀÖ/F¸1°·³Ò/FÓG€MÜ
ˆ=ÔØ! &×"2Ñ"2Ð!3°2°m°_ÀAÐF‰à  ×!1Ñ!1Ð 2°!Ð4ˆð"Ü"-¨fÓ"5Ð!6ð 7MØMXÈMð 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Ø4°V×5EÑ5EÐ4FÀbÐ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Ø')ÐØ�}‰}‹ò  ˆÜ�c—l‘l¤HÔ-°#·,±,×2CÑ2C×2RÑ2RÔ2TØ #§¡˜z¨Ð/ˆNØ!×(Ñ(Ø˜Ð' {°3·8±8°*¸BÐ?ôð �N‰N˜3Ÿ=™=¨Ó8Õ9à�N‰N˜3Õð ð *×.Ñ.Ð/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   € ä$.¨qÔ2FÔ$Gˆq�|‰|× Ò ÈQÏVÉVˆØ×%Ñ%×0Ñ0Ü& qÔ*>Ô?ˆA�LŠLÀQó
ˆô Ø˜¨Ð-ÒL°(×2JÑ2JÓ2Lô
ˆð �x‰x˜ÓÐ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>ß   ó   è ø€ Ò:¨˜aŸf�fÑ:ùó   ‚Ú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°! Q§V¡V H£+Ñ!Cù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   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Ñ0°C·H±H°:Õ?Ü˜CŸM™M¬=Ô9Ø)×0Ñ0°C·H±H°:Ð=RÐ1SÕTä$Ø(¨¯©¨Ð7SÐTóð ð	ð  $Ÿy™yÐ)BÓCÐà×*Ñ*°%ÀÐ*ÓFˆð ×Ñ×,Ò,Ø1‰NØ×Ñ×+Ò+Ø*4Ö5 Q˜!Ÿ&›&Ð5ˆJÐ5Ø×ÑÑ:¨kÔ:Ô:Ø-¨f¯k©k¨]¸!¸D¿I¹IÀjÓ<QÐ;RÐRTÐU‰NØ×Ñ×)Ò)Ü38¼¸Z»Ó3IÖJ¨a˜H Q C qš/ÐJˆJÐJØ×ÑÑ:¨kÔ:Ô:Ø<¸V¿[¹[¸MÈÈ4Ï9É9ÐU_ÓK`ÐJaÐajÐk‰NàˆNàŸ	™	Ñ!C°{Ô!CÓCˆà—N‘NÐ#ð $Ø×ÑÐ ð !Ø+Ð,ð -ØÐð !Ü!$ 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ÖSÀQ�v˜aŸk™k×2Ñ2Ó4Ð5°R¸¿¹°xÒ@ÐSˆ	ÐSØŸ)™) IÓ.ˆØ×Ò 6×#4Ñ#4×#DÒ#DØ×ÑÐGÔHØŸ™ 9Ó-ˆà+×0Ñ0ð %öð
 ð —;‘;×'Ñ'Ó)Ð-PÒPð —6‘6�(˜!˜AŸF™F˜8Ð#TÐUV×U[ÑU[ÐT\Ð\pÑqàŸ™�x˜q §¡ ¨Ð*ñ+òó
Ðô Ð"Ô#Ø$/Ð0CÐ/DÐ"EÐØ—{‘{ð %öð ð	 —;‘;×'Ñ'Ó)Ð-?Ò?ð ˜qŸv™v˜h aÑ(ð —;‘;×'Ñ'Ó)Ð-PÒPð 5°Q·V±V°H¸AÑ>àŸ™×,Ñ,Ó.Ð/¨q°·±°¸Ð:ñ	;òó	
ˆð ×+Ñ+°4ÀÐ+ÓGö
àÜ˜#Ÿ-™-¬Ô7ð �H‹Hð
ˆð 
ð
 $Ÿ[™[Ø2AÖB¨ˆy˜˜˜tÒ$ÒBó
Ðð %ŸM™MØ6EÖF¨Uˆt�E�7˜% ˜w aÒ(ÒFó
Ðð ÐØò 	RˆCÜ˜#Ÿ-™-¬Ô7ØŸ8™8˜* HÐ-�Ø×#Ò#Ø1�EØ!×(Ñ(Ø˜SŸX™X˜Jð 'Ø—‘ˆz˜ ˜wð 'à—‘ˆzð ð
õð "×(Ñ(¨9°S·X±X°J¸fÀSÇXÁXÀJÈaÐ)PÕQð	Rð !)§¡Ð.?Ó @ÐðØ×ÑÐ˜
 4§>¡>Ð"2ð 3 ð !'˜xð (ð 
×ÑÐ�A�nÐ%ð &	Ø	×	!Ñ	! &Ó	)Ð*Ð+>Ð*?ð @àÐð ð
 �>‰>Ð
ð ØÐð ð ×Ñ˜ Ó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ØÓà ò ó !ð óóó
ó
(6ôT`
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§  € Ø'¨Ð'7°wÐ?ˆ	Ø×Ñ×0Ò0Ø�[ �?Ð"Ø×"Ñ"×.Ò.ØØÐÜ—?‘? 6×#;Ñ#;¸V×=RÑ=RÓSò 	GˆCÜ˜#Ÿ-™-¬Ô7Ø ×'Ñ'Ø/°·±¨zÐ9NÐOõð !×'Ñ'Ð*:¸3¿8¹8¸*Ð(EÕFð	Gô —?‘? 6×#<Ñ#<¸f×>TÑ>TÓUò 	KˆCÜ˜#Ÿ-™-¬Ô7Ø ×'Ñ'Ø §¡˜z¨¨S¯X©X¨J°lÀ3Ç8Á8À*ÈBÈsÏxÉxÈjÐXdÐeh×emÑemÐdnÐntÐux×u}Ñu}Ðt~ð  Að  Bõð !×'Ñ'¨&°·±°
¸$¸s¿x¹x¸jÐ(IÕJð	Kð  /×3Ñ3Ð4DÓ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                  r�t        |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Ø×$Ò$Ü˜cŸm™m¬]Ô;Ø%×,Ñ,Ø& s§x¡x j°°C·H±H°:ð >5à58·X±X°Jð ? ð#õð &×,Ñ,Ø& s§x¡x jð 1<Ø<?¿H¹H¸:ÐEWð[õð ×&Ò&ØÜ˜CŸM™M¬9Ô5Ø—=‘=×%Ñ%Ô)9Ñ9Ø%×,Ñ,Ø$ S§X¡X J¨nØ×1Ñ1Ð2°"°T×5HÑ5HÐ4IÈÈ3Ï8É8È*ÐTVðXöð
 &×,Ñ,Ø×/Ñ/Ð0°°s·x±x°jÀØ×1Ñ1Ð2°"°T×5SÑ5SÐ4TÐTUÐVY×V^ÑV^ÐU_Ð_qðsöô ˜CŸM™M¬=Ô9Ø—}‘}×)Ñ)¬Y´y³{Ó-CÒCÐWÀSÇ]Á]×EWÑEWÓWÐCð "×(Ñ(Ø×+Ñ+Ð,¨F°3·8±8°*¸CØ×-Ñ-Ð.¨b°×1DÑ1DÐ0EÀQÀsÇxÁxÀjÐPiðköô
 %ØSÐTW×TaÑTaÐSbÐbcÐ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   € ð ×(Ò(Ü$Ø˜¨4¯9©9¯>©>×+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<ÖX¨QÀA×DWÓDW §¡˜x™[ÐXÐÐXÜ'¬	´'Ó(:Ó;ˆà'ö
Ø¨1¯;©;¸/Ó+IˆA�F‹Fð
Ðð 
ô Ð$Ó%¨Ò)¬SÐ1AÓ-BÀQÒ-Fð 	
Ø8ó	
ÐFð ×!Ñ!Ð" ! D§I¡IÐ.?ÐBRÑ.RÓ$SÐ#TÐTUÐ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Ð`cÐc}Ð~Ð~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   è ø€ ÒFeÐWXÄsÈ1Ï6É6Ç{ÑFeùs   ‚!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ˆØŸ™ÒO¨4×+CÑ+CÈ4Ð+OˆÙšOðoˆHà Ò!óð !ŸX™X¼eÀNÓ>SÖ&T¸¡z°!¥}Ò&TÓU�
ØDÀzÑQÐTXÑX�ô 1×<Ñ<¸T¿Y¹YÓGˆNÜ1HÈÓ1XÑ.Ð ô #Ø! >×#;Ñ#;Ó#=Àeôöàð —“ðˆNð ñ à×QÒQÐQÐQØF‘à$�Ø×(Ñ(ˆIà�y‰y×#Ñ#Ô%¨(×*BÑ*BÔ*DØ˜YÑ&�	ð	Ø	Ðð Ø(˜M¨¨I¨;°a¸¿	¹	À.Ó8QÐ7Rð S	Ø	ˆ
ð‰Iô
 .Ø—‘ ¨h×.FÑ.FÓ.HôˆIðØ$×/Ñ/Ð0°ð5ˆIð 	ð 4Ø4BÐ3CÀ2ðIñ 	Iˆ	ð #¤S¨¯©£^Ñ3ˆØð =à=A¿Y¹YÑFeÐ\dÔFeÓ=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ÐØFÀv×GWÑGWÐFXÐXZÐ[nÐZoð 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[   € à×(Ò(à$Ð0ð Ø=óÐ0ð (Ð(¨¨$×*<Ñ*<Ð)=Ð>Ð>Ø×(Ñ(Ð)¨¨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<ÖX¨QÀA×DWÓDW §¡˜x™[ÐXÐÐXÜ47Ð8IÓ4JÈQÒ4NÐ-¨aÒ0ÐTXÐØ'¨×(HÑ(HÐ'Ið JØ×(Ñ(Ð):Ó;Ð<Ð<_ðcˆ
ð ˜AÒÜÐ(Ó)¨AÒ-ð ØEóÐ-ð *¨$×*>Ñ*>Ð)?ð @Ø+Ð,ð -$Ø$(×$;Ñ$;Ð<MÓ$NÐ#OÈqÔQZÓQ\ÐP]ð ^à×7Ñ7Ð8¸¸.Ð9IÐIYð	]ˆJð �;‰;×Ñ×#Ò# t§y¡y×':Ñ':Ô'<Ø! QÒ&ð ð?Ø?MÐ>NÈað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"  € ä˜t T×%7Ñ%7Ó8ˆØ×%Ñ%×0Ñ0°Ó6ˆØÐ#Ð#Ð#Ü˜dŸi™i°×0HÑ0HÓ0JÔKˆðØ‡X�X�d×,Ñ,Ð-¨R°·±Ð/@ÐA€XÓBÐCð D	Ø	×	"Ñ	" 4¨°¸3Ó	?Ð@ð A	Ø	�‰�d˜FÓ	#Ð$ð %	Ø	�‰˜˜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Ì   … àÓØÓØÓØ"Ó"ØÓØÓØ"Ó"ØÓØÓØÓØ"Ó"Ø!$Ó$Ø!$Ó$ØÓØÓó+6ðZàðð ðð "ð	ð
 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›   € Ü$ Q§V¡V°FÔ;ˆŒØ#Ÿy™yÜ)×3Ñ3°A·F±FÀ6ÔJÖK˜!ˆQ�V‰V�XÒKó 
ˆÔð  Ÿ9™9Ø&*§m¡m×&AÑ&AÈDÐ&AÓ&QÖR˜s�—‘ˆ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#   € Ø×$Ñ$Ð% Q t×';Ñ';Ð&<¸AÐ>Ð>r7   c                ó:   — | j                   › d| j                  › d�S r+  )r'  r&  r,  s    r5   Ú__call_suffixz#ComputeShapeSignature.__call_suffix‘  s#   € Ø×$Ñ$Ð% Q t×'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ð —I‘I )×"6Ñ"6Ð!7°qÐ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ˆä% l°MÀ?ÓSˆ
Ø—‘˜ bÓ)ò 	)ˆAÜ�J  4Õ(ð	)ô œn×2Ñ2°2°f±:Ó>À
Ð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   