Ë
    ÄÓ^j­  ã                   ó´   — d dl Z d dlmZ d dlmZ d dlZd dlZd dlmZ d dlmZm	Z	 d dl
mZmZmZmZ d dlmZmZmZ ddlmZ  G d	„ d
e	«      Z G d„ de«      Zy)é    N)ÚCallable)ÚAny)ÚProxyÚTransformer)ÚArgumentÚmap_aggregateÚNodeÚTarget)Úcreate_type_hintÚnormalize_functionÚnormalize_moduleé   )ÚAnnotateTypesWithSchemac                   óþ   ‡ — e Zd ZdZ	 ddej
                  j                  deddfˆ fd„Zde	de
fˆ fd„Z	 	 dd	ed
eedf   deee
f   dee
df   dz  deee
f   dz  defˆ fd„Zd	ed
eedf   deee
f   defˆ fd„Zˆ xZS )ÚNormalizeArgsa‡  
    Normalize arguments to Python targets. This means that
    `args/kwargs` will be matched up to the module/functional's
    signature and rewritten to exclusively kwargs in positional order
    if `normalize_to_only_use_kwargs` is true. Also populates default
    values. Does not support positional-only parameters or varargs
    parameters (*args, **kwargs).

    If the nodes have 'type' metadata, it will use it to disambiguate
    overloads. Otherwise, it will throw an error.

    Example usage:
        m = torchvision.models.resnet18()
        traced = torch.fx.symbolic_trace(m)
        traced = NormalizeArgs(traced).transform()
    ÚmoduleÚnormalize_to_only_use_kwargsÚreturnNc                 ó@   •— t         ‰| �  |«       i | _        || _        y ©N)ÚsuperÚ__init__Únode_mapr   )Úselfr   r   Ú	__class__s      €új/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/torch/fx/experimental/normalize.pyr   zNormalizeArgs.__init__%   s!   ø€ ô 	‰Ñ˜Ô Ø+-ˆŒØ,HˆÕ)ó    Únc                 óv  •‡— | j                  ‰«      \  }}dt        dt        fˆfd„}t        ‰j                  |«      }t        |t        «      st        dt        |«      › �«      ‚t        d„ |D «       «      }|j                  «       D ��ci c]  \  }}| ||«      “Œ }}}‰j                  dk(  r | j                  ‰j                  ||||«      }	nt        ‰
| �9  ‰«      }	‰j                  dk7  rE‰| j                  |	<   ‰j                   |	j"                  _        ‰j                  |	j"                  _        |	S c c}}w )NÚargr   c                 ó„   •— t        | t        j                  «      r‰j                  j	                  d«      S t        | «      S )NÚtype)Ú
isinstanceÚfxr	   ÚmetaÚgetr"   )r    r   s    €r   Úget_typez(NormalizeArgs.run_node.<locals>.get_type/   s.   ø€ Ü˜#œrŸw™wÔ'Ø—v‘v—z‘z &Ó)Ð)Ü˜“9Ðr   zExpected tuple, got c              3   ó2   K  — | ]  }t        |«      –— Œ y ­wr   )r   )Ú.0Úis     r   ú	<genexpr>z)NormalizeArgs.run_node.<locals>.<genexpr>7   s   è ø€ ÒA°!Ô*¨1×-ÑAùs   ‚Úcall_functionÚoutput)Úfetch_args_kwargs_from_envÚobjectr   r   Úargsr#   ÚtupleÚAssertionErrorr"   ÚitemsÚopr,   Útargetr   Úrun_noder   r%   Únode)r   r   r0   Úkwargsr'   Ú	arg_typesÚkÚvÚkwarg_typesÚoutr   s    `        €r   r6   zNormalizeArgs.run_node,   s  ù€ Ø×6Ñ6°qÓ9‰ˆˆfð	œ&ð 	¤Sõ 	ô
 " !§&¡&¨(Ó3ˆ	Ü˜)¤UÔ+Ü Ð#7¼¸Y»Ð7HÐ!IÓJÐJÜÑA°yÔAÓAˆ	Ø28·,±,³.×A©$¨!¨Q�q™( 1›+‘~ÐAˆÑAØ�4‰4�?Ò"Ø×$Ñ$ Q§X¡X¨t°V¸YÈÓT‰Cä‘'Ñ" 1Ó%ˆCØ�4‰4�8ÒØ!"ˆD�M‰M˜#ÑØŸF™FˆC�H‰HŒMØŸF™FˆC�H‰HŒMØˆ
ùó Bs   ÂD5r5   r0   .r8   r9   r<   c                 óè   •— t        |«      st        dt        |«      › �«      ‚t        |||||| j                  «      }|r#|\  }}| j
                  j                  d|||«      S t        ‰	| �!  |||«      S )NúExpected callable target, got r,   )	Úcallabler2   r"   r   r   ÚtracerÚcreate_proxyr   r,   )
r   r5   r0   r8   r9   r<   Únew_args_and_kwargsÚnew_argsÚ
new_kwargsr   s
            €r   r,   zNormalizeArgs.call_functionC   sŒ   ø€ ô ˜ÔÜ Ð#AÄ$ÀvÃ,ÀÐ!PÓQÐQÜ0ØØØØØØ×-Ñ-ó
Ðñ Ø#6Ñ ˆH�jØ—;‘;×+Ñ+Ø ¨°:óð ô ‘7Ñ(¨°°vÓ>Ð>r   c                 óê   •— t        |t        «      st        dt        |«      › �«      ‚t	        | j
                  |||| j                  «      }|r|\  }}t        ‰| �!  |||«      S t        ‰| �!  |||«      S )NzExpected str target, got )	r#   Ústrr2   r"   r   r   r   r   Úcall_module)r   r5   r0   r8   rC   rD   rE   r   s          €r   rH   zNormalizeArgs.call_module]   s�   ø€ ô ˜&¤#Ô&Ü Ð#<¼TÀ&»\¸NÐ!KÓLÐLÜ.Ø�K‰KØØØØ×-Ñ-ó
Ðñ Ø#6Ñ ˆH�jÜ‘7Ñ& v¨x¸ÓDÐDä‘7Ñ& v¨t°VÓ<Ð<r   )T)NN)Ú__name__Ú
__module__Ú__qualname__Ú__doc__Útorchr$   ÚGraphModuleÚboolr   r	   r   r6   r
   r1   r   ÚdictrG   r   r,   rH   Ú__classcell__©r   s   @r   r   r      sú   ø„ ñð$ RVñIØ—h‘h×*Ñ*ðIØJNðIà	õIð˜$ð  3õ ð8 -1Ø-1ñ?àð?ð �H˜c�MÑ"ð?ð �S˜#�X‘ð	?ð
 ˜˜c˜‘? TÑ)ð?ð ˜#˜s˜(‘^ dÑ*ð?ð 
õ?ð4=Øð=Ø$)¨(°C¨-Ñ$8ð=ØBFÀsÈCÀxÁ.ð=à	÷=ñ =r   r   c                   óŽ  ‡ — e Zd ZU dZej
                  ej
                  ej                  ej                  ej                  ej                  ej                  ej                  ej                  ej                  ej                  ej                  ej                  ej                  ej                   ej                   ej"                  ej"                  ej$                  ej$                  ej&                  ej&                  ej(                  ej(                  iZeeeegef   eeegef   f   ed<   dedeedf   deeef   defˆ fd„Zˆ xZ S )	ÚNormalizeOperatorsaÚ  
    Normalize callsites that are different ways of "spelling" the same
    invocation into a single, canonical call. Currently supports:

    1. Normalize operators (e.g. operator.add) to the `torch` ops they
       ultimately invoke (e.g. torch.add) when it is possible to statically
       reason that

    Example usage:

        m = torchvision.models.resnet18()

        traced = torch.fx.symbolic_trace(m)

        traced = NormalizeOperators(traced).transform()
    Úbinary_magic_method_remapr5   r0   .r8   r   c                 ó  •— t        |«      st        dt        |«      › �«      ‚|| j                  v rEt	        |«      dk7  rt
        ‰| �  |||«      S |\  }}t
        ‰| �  | j                  |   ||fi ¬«      S t
        ‰| �  |||«      S )Nr?   é   )r5   r0   r8   )r@   r2   r"   rU   Úlenr   r,   )r   r5   r0   r8   ÚlhsÚrhsr   s         €r   r,   z NormalizeOperators.call_function“   sŸ   ø€ ô ˜ÔÜ Ð#AÄ$ÀvÃ,ÀÐ!PÓQÐQà�T×3Ñ3Ñ3Ü�4‹y˜AŠ~Ü‘wÑ,¨V°T¸6ÓBÐBØ‰HˆC�ä‘7Ñ(Ø×5Ñ5°fÑ=Ø˜3�ZØð )ó ð ô ‰wÑ$ V¨T°6Ó:Ð:r   )!rI   rJ   rK   rL   rM   ÚaddÚoperatorÚmulÚsubÚdivÚtruedivÚfloor_divideÚfloordivÚ	remainderÚmodÚeqÚneÚltÚleÚgtÚgerU   rP   r   r   Ú__annotations__r
   r1   r   rG   r   r,   rQ   rR   s   @r   rT   rT   p   s  ø… ñð( 	�	‰	�8—<‘<Ø�	‰	�8—<‘<Ø�	‰	�8—<‘<Ø�	‰	�8×#Ñ#Ø×Ñ˜H×-Ñ-Ø�‰˜Ÿ™Ø�‰�(—+‘+Ø�‰�(—+‘+Ø�‰�(—+‘+Ø�‰�(—+‘+Ø�‰�(—+‘+Ø�‰�(—+‘+ð	ð ˜tØ�#�s�˜S�Ñ! 8¨S°#¨J¸¨OÑ#<Ð<ñ ó ð";Øð;Ø$)¨(°C¨-Ñ$8ð;ØBFÀsÈCÀxÁ.ð;à	÷;ñ ;r   rT   )r\   Úcollections.abcr   Útypingr   rM   Útorch.fxr$   r   r   Útorch.fx.noder   r   r	   r
   Útorch.fx.operator_schemasr   r   r   Úschema_type_annotationr   r   rT   © r   r   ú<module>rs      sK   ðÛ Ý $Ý ã Û Ý ß 'ß ?Ó ?÷ñ õ <ôZ=�Kô Z=ôz7;Ð0õ 7;r   