
    sg                         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y)    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()
    modulenormalize_to_only_use_kwargsc                 @    t         |   |       i | _        || _        y N)super__init__node_mapr   )selfr   r   	__class__s      R/var/www/html/venv/lib/python3.12/site-packages/torch/fx/experimental/normalize.pyr   zNormalizeArgs.__init__%   s!     	 +-,H)    nreturnc                 \   | j                        \  }}fd}t        j                  |      }t        |t              sJ t	        |D cg c]  }t        |       c}      }|j                         D ci c]  \  }}| ||       }	}}j                  dk(  r | j                  j                  ||||	      }
nt        | -        }
j                  dk7  rE| j                  |
<   j                  |
j                  _        j                  |
j                  _        |
S c c}w c c}}w )Nc                     t        | t        j                        rdj                  v rj                  d   S d S t	        |       S )Ntype)
isinstancefxr   metar$   )argr    s    r   get_typez(NormalizeArgs.run_node.<locals>.get_type/   s9    #rww')/166)9qvvf~CtC9r   call_functionoutput)fetch_args_kwargs_from_envr   argsr%   tupler   itemsopr*   targetr   run_noder   r'   noder$   )r   r    r-   kwargsr)   	arg_typesikvkwarg_typesoutr   s    `         r   r2   zNormalizeArgs.run_node,   s    66q9f	
 "!&&(3	)U+++	B1+A.BC	28,,.A$!Qq(1+~AA44?"$$QXXtVYTC'"1%C448!"DMM#FFCHHMFFCHHM
 CAs   D#9D(r1   r-   .r4   r5   r9   c                     t        |      sJ t        |||||| j                        }|r#|\  }}| j                  j	                  d|||      S t
        	|   |||      S )Nr*   )callabler   r   tracercreate_proxyr   r*   )
r   r1   r-   r4   r5   r9   new_args_and_kwargsnew_args
new_kwargsr   s
            r   r*   zNormalizeArgs.call_functionB   s{     0--
 #6 Hj;;++:  7(v>>r   c                     t        |t              sJ t        | j                  |||| j                        }|r|\  }}t
        |   |||      S t
        |   |||      S r   )r%   strr   r   r   r   call_module)r   r1   r-   r4   r?   r@   rA   r   s          r   rD   zNormalizeArgs.call_module[   sp     &#&&&.KK--
 #6 Hj7&vxDD7&vtV<<r   )T)NN)__name__
__module____qualname____doc__torchr&   GraphModuleboolr   r   r   r2   r   r   r
   r   rC   r   r*   rD   __classcell__r   s   @r   r   r      s    $ RVIhh**IJN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_remapr1   r-   .r4   c                     t        |      sJ || j                  v rEt        |      dk7  rt        |   |||      S |\  }}t        |   | j                  |   ||fi       S t        |   |||      S )N   )r1   r-   r4   )r<   rP   lenr   r*   )r   r1   r-   r4   lhsrhsr   s         r   r*   z NormalizeOperators.call_function   s     T3334yA~w,VT6BBHC7(55f=3Z )   w$VT6::r   ) rE   rF   rG   rH   rI   addoperatormulsubdivtruedivfloor_dividefloordiv	remaindermodeqneltlegtgerP   r   r   r   __annotations__r   r   r
   rC   r*   rL   rM   s   @r   rO   rO   m   s   ( 			8<<		8<<		8<<		8##H--(++(++(++(++(++(++	 t#sS!8S#JO#<<  ";;$)(C-$8;BFsCx.; ;r   rO   )rW   typingr   r   r   r   r   rI   torch.fxr&   r   r	   torch.fx.noder
   r   r   r   torch.fx.operator_schemasr   r   r   schema_type_annotationr   r   rO    r   r   <module>rm      sK     7 7    ' ? ?  <W=K W=t6;0 6;r   