
    קg                         d dl Z d dlmZmZmZmZ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dS )    N)AnyCallableDictTupleOptional)TransformerProxy)ArgumentTargetNodemap_aggregate)normalize_modulenormalize_functioncreate_type_hint   )AnnotateTypesWithSchemac                       e Zd ZdZ	 ddej        j        de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e
df                  deeee
f                  f
 fdZd
edeedf         deee
f         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()
    Tmodulenormalize_to_only_use_kwargsc                 f    t                                          |           i | _        || _        d S N)super__init__node_mapr   )selfr   r   	__class__s      [/var/www/html/ai-engine/env/lib/python3.11/site-packages/torch/fx/experimental/normalize.pyr   zNormalizeArgs.__init__%   s2     	   +-,H)))    nreturnc                    |                                \  }}fdt          j                  }t          |t                    sJ t	          d |D                       }fd|                                D             }j        dk    r|                     j        ||||          }n!t                      
                              }j        dk    r,| j        |<   j        |j        _        j        |j        _        |S )Nc                     t          | t          j                  rdj        v rj        d         nd S t	          |           S )Ntype)
isinstancefxr   metar$   )argr    s    r   get_typez(NormalizeArgs.run_node.<locals>.get_type/   s@    #rw'' D)/16)9)9qvf~~tC99r   c                 ,    g | ]}t          |          S  )r   ).0is     r   
<listcomp>z*NormalizeArgs.run_node.<locals>.<listcomp>6   s!    BBB1+A..BBBr   c                 .    i | ]\  }}| |          S r+   r+   )r,   kvr)   s      r   
<dictcomp>z*NormalizeArgs.run_node.<locals>.<dictcomp>7   s'    AAA$!Qq((1++AAAr   call_functionoutput)fetch_args_kwargs_from_envr   argsr%   tupleitemsopr3   targetr   run_noder   r'   noder$   )	r   r    r6   kwargs	arg_typeskwarg_typesoutr)   r   s	    `     @r   r;   zNormalizeArgs.run_node,   s   66q99f	 	 	 	 	
 "!&(33	)U+++++BB	BBBCC	AAAA&,,..AAA4?""$$QXtVYTTCC''""1%%C48!"DM#FCHMFCHM
r   Nr:   r6   .r=   r>   r?   c                     t          |          sJ t          |||||| j                  }|r"|\  }}| j                            d|||          S t                                          |||          S )Nr3   )callabler   r   tracercreate_proxyr   r3   )
r   r:   r6   r=   r>   r?   new_args_and_kwargsnew_args
new_kwargsr   s
            r   r3   zNormalizeArgs.call_functionB   s     0-
 
  	?#6 Hj;++:   77((v>>>r   c                    t          |t                    sJ t          | j        |||| j                  }|r(|\  }}t                                          |||          S t                                          |||          S r   )r%   strr   r   r   r   call_module)r   r:   r6   r=   rE   rF   rG   r   s          r   rJ   zNormalizeArgs.call_module[   s     &#&&&&&.K-
 
  	=#6 Hj77&&vxDDD77&&vtV<<<r   )T)NN)__name__
__module____qualname____doc__torchr&   GraphModuleboolr   r   r   r;   r   r   r
   r   rI   r   r3   rJ   __classcell__r   s   @r   r   r      sj        $ RVI Ih*IJNI I I I I I$ 3      6 0404? ?? HcM"? S#X	?
 E#s(O,? d38n-? ? ? ? ? ?2==$)(C-$8=BFsCx.= = = = = = = = = =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         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_remapr:   r6   .r=   c                 V   t          |          sJ || j        v rlt          |          dk    r#t                                          |||          S |\  }}t                                          | j        |         ||fi           S t                                          |||          S )N   )r:   r6   r=   )rB   rV   lenr   r3   )r   r:   r6   r=   lhsrhsr   s         r   r3   z NormalizeOperators.call_function   s     T3334yyA~~ww,,VT6BBBHC77((5f=3Z )    ww$$VT6:::r   ) rK   rL   rM   rN   rO   addoperatormulsubdivtruedivfloor_dividefloordiv	remaindermodeqneltlegtgerV   r   r   r   __annotations__r   r   r
   rI   r3   rR   rS   s   @r   rU   rU   m   s%         ( 		8<	8<	8<	8#H-(+(+(+(+(+(+	 t#sS!8S#JO#<<    ";;$)(C-$8;BFsCx.; ; ; ; ; ; ; ; ; ;r   rU   )r]   typingr   r   r   r   r   rO   torch.fxr&   r   r	   torch.fx.noder
   r   r   r   torch.fx.operator_schemasr   r   r   schema_type_annotationr   r   rU   r+   r   r   <module>rr      sF    7 7 7 7 7 7 7 7 7 7 7 7 7 7         ' ' ' ' ' ' ' ' ? ? ? ? ? ? ? ? ? ? ? ?          < ; ; ; ; ;W= W= W= W= W=K W= W= W=t6; 6; 6; 6; 6;0 6; 6; 6; 6; 6;r   