
    קgr)                     B   d dl Z d dlZd dlZd dlmZmZmZmZmZm	Z	 d dl
Z
d dl
mZmZ d dlmZ e j         G d d                      Z G d d          Zd	ed
efdZded
eeef         fdZded
efdZded
efdZded
efdZded
efdZded
efdZdefdZd Zdej        deedf         deeef         d
eeej        ef                  fdZ d Z!ded
efdZ"d
efdZ#d Z$dej        fd Z%dej        fd!Z&dej        d
efd"Z'dej        d
e	edf         fd#Z(dS )$    N)AnyCallableDictIterableTupleUnion)_C_utils_internal)
OpOverloadc                   .    e Zd ZU dZeed<   eed<   d ZdS )Kernelz$Models a (function, source location)funcsourcec                      | j         |i |S N)r   )selfargskwargss      P/var/www/html/ai-engine/env/lib/python3.11/site-packages/torch/_library/utils.py__call__zKernel.__call__   s    ty$)&)))    N)__name__
__module____qualname____doc__r   __annotations__strr    r   r   r   r      s=         ..
NNNKKK* * * * *r   r   c                   &    e Zd ZdZdefdZddZdS )RegistrationHandlez2Does something when someone calls .destroy() on it
on_destroyc                     || _         d S r   _on_destroy)r   r!   s     r   __init__zRegistrationHandle.__init__   s    %r   returnNc                 .    |                                   d S r   r#   )r   s    r   destroyzRegistrationHandle.destroy   s    r   )r&   N)r   r   r   r   r   r%   r(   r   r   r   r    r       sI        <<&8 & & & &     r   r    
stacklevelr&   c                 t    t          j        t          j        |                     }|j         d|j         }|S )zGet a string that represents the caller.

    Example: "/path/to/foo.py:42"

    Use stacklevel=1 to get the caller's source
    Use stacklevel=2 to get the caller's caller's source
    etc.
    :)inspectgetframeinfosys	_getframefilenamelineno)r)   framer   s      r   
get_sourcer3   !   s:      z!:!:;;E////FMr   qualnamec                     |                      d          }t          |          dk    rt          d|  d          |d         |d         fS )Nz::   zAExpected `qualname` to be of the form "namespace::name", but got zf. The qualname passed to the torch.library APIs must consist of a namespace and a name, e.g. aten::sinr      )splitlen
ValueError)r4   splitss     r   parse_namespacer<   /   sb    ^^D!!F
6{{a9*29 9 9
 
 	
 !9fQir   c                     t          |           \  }}d|v r|                    d          \  }}nd}t          t          j        |          }t          ||          }t          ||          S )N.default)r<   r8   getattrtorchops)r4   	namespacenameoverloadnspackets         r   	lookup_oprH   ;   sf    %h//OIt
d{{Chh	I	&	&BRF68$$$r   opc                 B    t          | t                    sJ | j        dv S )N>   atenprimprims)
isinstancer   rC   )rI   s    r   
is_builtinrO   F   s&    b*%%%%%<444r   schemac                     d }t          | t          j        j                  r ||           S ddlm} t          | t
                    r|                    |           } t          | |          sJ  ||           S )zCheck if the schema is functional.

    An operator is functional if:
    - it does not mutate any of its inputs
    - it does not return a view on any of its inputs
    - it has at least one return
    c                     | j         rdS | j        }t          |          dk    ot          d |D                       }|rdS | j        sdS dS )NFr   c              3   B   K   | ]}|j         d uo|j         j         V  d S r   )
alias_infois_write).0rs     r   	<genexpr>z>is_functional_schema.<locals>.is_functional.<locals>.<genexpr>X   sG       5
 5
GHAL$BQ\-B)B5
 5
 5
 5
 5
 5
r   T)
is_mutablereturnsr9   any)rP   retsis_non_mutating_views      r   is_functionalz+is_functional_schema.<locals>.is_functionalT   sy     	5~"4yy1}  
 5
 5
LP5
 5
 5
 2
 2
   	5~ 	5tr   r   )FunctionSchema)rN   rA   r	   r_   torchgen.modelr   parse)rP   r^   r_   s      r   is_functional_schemarb   K   s       &%(122 %}V$$$ .-----&# .%%f--fn-----=   r   typc           	      2   | t          j        t           j                                                  k    p| t          j        t          j        t           j                                                            k    p| t          j        t          j        t           j                                                            k    pW| t          j        t          j        t          j        t           j                                                                      k    S r   )r	   ListType
TensorTypegetOptionalTyperc   s    r   is_tensorlist_like_typerj   n   s    r{2=,,../// 	U"+bobm.?.?.A.ABBCCC	U"/"+bm.?.?.A.A"B"BCCC	U "/"+bobm>O>O>Q>Q.R.R"S"STTT	r   c                     | t           j                                        k    p3| t          j        t           j                                                  k    S r   )r	   rf   rg   rh   ri   s    r   is_tensor_like_typerl   x   s=    "-##%%%T@Q@Q@S@S0T0T)TTr   c                 T   | j         dk    rdS | j        }t          |j                  dk    sdS |j        d         j        dS |j        d         j        j        }t          |          dk    rdS t          t          |                    }t          |j                  dk     rdS |j        d         }|j        dS |j        j	        sdS |j        j        }t          |          dk    rdS |t          t          |                    k    rdS |j        dd         D ]}|j         dS dS )aN  Check if an op is an inplace aten op, i.e. it mutates and returns the first arg.

    TODO: torchgen/model.py's FunctionSchema.parse is the source of truth for this,
    but not all PyTorch builds have torchgen (due to the yaml dependency being weird).
    Figure this out.

    Example: add_(Tensor(a!) x, Tensor y) -> Tensor(a)
    rK   Fr7   r   NT)
rC   _schemar9   rZ   rT   	after_setnextiter	argumentsrU   )rI   rP   	alias_setloc	first_argargs         r   mutates_and_returns_first_argrw   |   sC    
|vuZFv~!##u~a#+uq!,6I
9~~u
tI

C
6q  u #I#u( u$.I
9~~u
d4	??####u#  >%55 &4r   c                    g }i }t          t          | j                            D ]}| j        |         }|j        r/|j        |v r||j                 ||j        <   5|j        ||j        <   E|t          |          k     r|                    ||                    t|                    |j                   t          |          |fS r   )ranger9   rr   
kwarg_onlyrD   default_valueappendtuple)rP   r   r   new_args
new_kwargsiinfos          r   fill_defaultsr      s    HJ3v'(()) 4 4"? 		4yF""(.ty(9
49%%(,(:
49%%3t99}}Q(((( 23333??J&&r   r   .r   c              #   ^  K   t          | j                  t          |          t          |          z   k    sJ t          t          | j                            D ]Q}| j        |         }|j        r|j        |v r|||j                 fV  1|t          |          k    rE|||         fV  RdS )zzips schema.arguments and (args, kwargs) together.

    Assumes that (args, kwargs) were the inputs to some torch._ops.OpOverload:
    that is, kwargs must be keyword-only arguments and default values may be omitted.
    N)r9   rr   ry   rz   rD   )rP   r   r   r   r   s        r   
zip_schemar      s       v  CIIF$;;;;;3v'(())  "? 	yF""F49-----D		>> DGm
Fr   c                    ddl m} | j        }t          |t          j        j                  st          d          d g }| j        D ]}t          |t          j	        j
        t          j	        j        j
        f          r|                     |                     Vt          |t          j	        j        j        t          t           f          r"|                    fd|D                        t          dt#          |                      t%          j        |j                  j        | } |           }|                    |j        t!          |j                                                  t          |          f          S )Nr   )FunctionSchemaGenzfx_node's target must be a hop.c                     | j                             dd           }|,| j        dk    sJ t          | j        j        | j                  }|S )Nvalget_attr)metarg   rI   r@   graphowning_moduletarget)nodemeta_vals     r   _collect_example_valz5hop_schema_from_fx_node.<locals>._collect_example_val   sK    9==--7j((((tz7EEHr   c                 &    g | ]} |          S r   r   )rV   xr   s     r   
<listcomp>z+hop_schema_from_fx_node.<locals>.<listcomp>   s%    "H"H"Hq#7#7#:#:"H"H"Hr   zUnsupported arg type )torchgen.gen_schema_utilsr   r   rN   rA   _opsHigherOrderOperatorRuntimeErrorr   fxNoder   r|   immutable_collectionsimmutable_listlistr}   typer,   	signaturer   bindfrom_example_namerr   items)r   r   hopexample_inputsrv   
bound_argsexample_outputr   s          @r   hop_schema_from_fx_noder      s   ;;;;;;
+Cc5:9:: ><===   Ny D DcEHM58=+=>?? 	D!!"6"6s";";<<<<%(0?uM
 
 	D !!"H"H"H"HC"H"H"HIIIIBtCyyBBCCC *N):3<)H)H)M	*J *)$//N))	5-335566n9M9M8O  r   c                     t          | t                    sJ t          |           rdS | j        }|j        sdS t          |j                  dk    rdS dS )NFr   T)rN   r   rO   rn   rY   r9   rZ   )rI   rP   s     r   can_generate_trivial_fake_implr      sc    b*%%%%%"~~  uZF u
6>Qu4r   c                  .    t          t          dd          S )zIf an op was defined in C++ and extended from Python using the
    torch.library APIs, returns if we require that there have been a
    m.set_python_module("mylib.ops") call from C++ that associates
    the C++ op with a python module.
    REQUIRES_SET_PYTHON_MODULET)r@   r
   r   r   r   requires_set_python_moduler     s     ?$@$GGGr   c                    t          | t          j        j        j                  sJ g }t          j        j                            ||                                f          \  }}|D ]}t          |t          j                  rht          j	        
                    |                              t          j	        j        j                  r"|                    t          |                     |                     ||||          S r   )rN   rA   utils_python_dispatchTorchDispatchMode_pytreetree_flattenvaluesTensorr	   _dispatch_keyshasDispatchKeyPythonr|   r   __torch_dispatch__)	curr_modeop_overloadr   r   overload_typesargs_flattened_as           r   handle_dispatch_moder     s    i!=!OPPPPPN+88$9PQQNA + +
 a&& 	+58+B+B1+E+E+I+IH ',
 ,
 	+ !!$q''*** ''^T6RRRr   c                 >    t          d | j        D                       S )Nc              3   $   K   | ]}|j         V  d S r   )rz   rV   r   s     r   rX   z&has_kwarg_only_args.<locals>.<genexpr>  s$      66q|666666r   r[   rr   rP   s    r   has_kwarg_only_argsr     s"    66V%5666666r   c                     | j         D ]5}t          |j                  st          |j                  s+|j        s3 dS dS )NTF)rr   rl   r   rj   rz   )rP   r   s     r   has_kwarg_only_tensorsr   !  sT      #AF++ 	/Fqv/N/N 	| 	tt5r   c                 >    t          d | j        D                       S )z
    Given a schema, returns True if the schema has a Tensor arg.
    A Tensor arg is any arg with a type annotation that might involve Tensor.
    c              3   f   K   | ],}t          |j                  pt          |j                  V  -d S r   )rl   r   rj   r   s     r   rX   z!has_tensor_arg.<locals>.<genexpr>0  sP         
QV	$	$	G(?(G(G     r   r   r   s    r   has_tensor_argr   +  s5    
   !     r   c                     t          | j                  D ]9\  }}|j        t          j                                        u r|j        dk    r|c S :dS )zx
    Given a schema, returns the id of the `device: torch.device` argument.
    If it does not exist, returns None.
    deviceN)	enumeraterr   r   r	   DeviceObjTyperg   rD   )rP   indexrv   s      r   get_device_arg_indexr   6  sY    
   011  
s8r'++----#(h2F2FLLL4r   ))dataclassesr,   r.   typingr   r   r   r   r   r   rA   r	   r
   
torch._opsr   	dataclassr   r    intr   r3   r<   rH   boolrO   rb   rj   rl   rw   r   r_   Argumentr   r   r   r   r   r   r   r   r   r   r   r   <module>r      sc        



 > > > > > > > > > > > > > > > >  % % % % % % % % ! ! ! ! ! ! * * * * * * * *       3 3    	 c 	 eCHo 	  	  	  	 % %
 % % % %5: 5$ 5 5 5 5
! ! ! ! ! !F     US UT U U U U#j # # # #L' ' '$%*38_>B38neBK$%&   0# # #Lz d     HD H H H HS S S$7 1 7 7 7 72#4    2,     !2 uS$Y7G      r   