
    קg*                     x   d dl Z d dlZd dlmZmZmZmZ d dlZd dlmZmZm	Z	m
Z
 d dlmZ  ed          dddej        dee         d	efd
            Zd Zd Ze	dej        e	         dededede
j        diZd Z e            Zde j        d	efdZdej        ej                 d	ej        ej                 fdZdS )    N)ListOptionalSequenceUnion)devicedtypeTensortypes)
exposed_inztorch.library)op_nameprototype_functionr   returnc               "	   d}t          j        |           fddt          ffd}g }t                      }d}t	          j                                                  D ]\  }\  }	}
t          |
          s d           |
j        t           j	        j
        k    r|s|                    d           d}|
j        t           j	        j        u r d	|	 d
           |
j        }t          |          t          k    r ||          }|t                                          vr|j        t$          u rgt'          |          }d}|t                                          v rd| d} d	|	 d|
j         d| dt                                           d	           n1 d	|	 d|
j         dt                                           d           t          |         }t          |          t          k    rH||k    rt)          d          |                    d          rd| d|t-          d          d          }nE|	|v rA|                    d          s d	|	 d           d| d|t-          d          d          }|                    |	           |
j        t           j	        j        u r|                    | d|	            cd}|
j        't3          |
j        t4          t6          t8          f          rt          |
j                  }nt3          |
j        t          t:          j        f          rd|
j         d}nt3          |
j        t:          j                  rEt          |
j                  }d}|                    |          sJ |t-          |          d         }n$ d	|	 dt          |
j                   d           |                    | d|	 d|            ||k    r3t          |          |z
  }t-          |          dk    r | d            j         }t          |          t          k    r ||          }tC          |          }|| d!d""                    |           d#| S d!d""                    |           d#| S )$aJ  Parses the schema of a given function with type hints. The schema is inferred from the
    function's type hints, and can be used to define a new operator.

    We make the following assumptions:

    * None of the outputs alias any of the inputs or each other.
    * | String type annotations "device, dtype, Tensor, types" without library specification are
      | assumed to be torch.*. Similarly, string type annotations "Optional, List, Sequence, Union"
      | without library specification are assumed to be typing.*.
    * | Only the args listed in ``mutates_args`` are being mutated. If ``mutates_args`` is "unknown",
      | it assumes that all inputs to the operator are being mutates.

    Callers (e.g. the custom ops API) are responsible for checking these assumptions.

    Args:
        prototype_function: The function from which to infer a schema for from its type annotations.
        op_name (Optional[str]): The name of the operator in the schema. If ``name`` is None, then the
            name is not included in the inferred schema. Note that the input schema to
            ``torch.library.Library.define`` requires a operator name.
        mutates_args ("unknown" | Iterable[str]): The arguments that are mutated in the function.

    Returns:
        The inferred schema.

    Example:
        >>> def foo_impl(x: torch.Tensor) -> torch.Tensor:
        >>>     return x.sin()
        >>>
        >>> infer_schema(foo_impl, op_name="foo", mutates_args={})
        foo(Tensor x) -> Tensor
        >>>
        >>> infer_schema(foo_impl, mutates_args={})
        (Tensor x) -> Tensor
    unknownc                 0    t          d|  d d          )Nzinfer_schema(func): z Got func with signature ))
ValueError)whatsigs    W/var/www/html/ai-engine/env/lib/python3.11/site-packages/torch/_library/infer_schema.pyerror_fnzinfer_schema.<locals>.error_fn9   s+    L4LLcLLL
 
 	
    annotation_typec                 r    	 t          |           S # t          $ r} d|  d           Y d }~d S d }~ww xY w)NzUnsupported type annotation z. It is not a type.)eval	Exception)r   er   s     r   convert_type_stringz)infer_schema.<locals>.convert_type_string>   su    	((( 	 	 	HSSSS        	s    
616Fz>We do not support positional-only args, varargs, or varkwargs.*Tz
Parameter z must have a type annotation.z

zFor example, z.

z has unsupported type z]. We do not support Tuple inputs in schema. As a workaround, please try to use List instead. zThe valid types are: .. The valid types are: zomutates_args must either be a sequence of the names of the arguments that are mutated or the string 'unknown'. r	   zTensor(az!)NzM is in mutable_args but only Tensors or collections of Tensors can be mutated "ztorch.z' has an unsupported default value type z;. Please file an issue on GitHub so we can prioritize this.=r   z in mutates_args were not found in the custom op's signature. mutates_args should contain the names of all args that the custom op mutates, or just the string 'unknown' if you don't know.(, z) -> )#inspect	signaturestrset	enumerate
parametersitemssupported_paramkind	ParameterKEYWORD_ONLYappend
annotationemptytypeSUPPORTED_PARAM_TYPESkeys
__origin__tupletuple_to_listr   
startswithlenadddefault
isinstanceintfloatbooltorchr   r   return_annotationparse_returnjoin)r   mutates_argsr   UNKNOWN_MUTATESr   params	seen_argssaw_kwarg_only_argidxnameparamr   	list_typeexample_type_strschema_typedefault_repr
dtype_repr	torch_dotmutates_args_not_seenrD   retr   r   s                        @@r   infer_schemarW      s   T  O

.
/
/C
 
 
 
 

S       FI'(<(<(>(>?? HB HB]dEu%% 	WHUVVV:*777% *c"""%)"w0666HE$EEEFFF  *  C''11/BBO"7"<"<">">>>)U22)/::	#)  5 : : < <<<'Gy'G'G'G$L L LU=M L L'L L -B,F,F,H,HL L L    L L LU=M L L,A,F,F,H,HL L L  
 ,O<$$.. O   %%h// NMMMCMMNN0KMM\!!))(33 tttt   JSIIKH,GIIKd=G-333MM[114112222L}$
5=3tBT(U(U$"5=11EMC+>?? 35=333EM5;77 	 //
$	!,,Y77777)#i..*:*:;Q Q QdSXS`NaNa Q Q Q   MM[@@4@@,@@AAAA&& #L 1 1I =$%%))H( V V V   -#%%//0ABB
((
3
3C99DIIf--99C999,tyy  ,,s,,,r   c                 ~   | |ft           j        |          | dfg}d }|r( ||           D ]}|                    || df           |r8 |t           j        |                    D ]}|                    || df           |r8 ||           D ],}|                    t           j        |         | df           -|S )N?c                 J    t           j        |          t           j        |          gS N)typingr   r   )typs    r   derived_seq_typesz(derived_types.<locals>.derived_seq_types   s     OC K
 	
r   z[]z?[]z[]?)r\   r   r2   )	base_typecpp_type	list_baseoptional_base_listoptional_list_baseresultr^   seq_typs           r   derived_typesrf      s    
H		#^^^4F

 
 
  6((33 	6 	6GMM7xOOO45555 7(()CDD 	7 	7GMM7x$4$4$456666 H((33 	H 	HGMM6?735E5E5EFGGGGMr   c                  $   t           ddddft          ddddft          ddddft          ddddft          ddddft
          j        ddddft          d	dddft          d
dddfg} g }| D ]}|	                    t          |            t          |          S )Nr	   TFSymIntrA   rB   r)   Scalar
ScalarTypeDevice)r	   r@   rA   rB   r)   r
   Numberr   r   extendrf   dict)datard   lines      r   get_supported_param_typesrq      s     
4u-	heT*	ud+	vtUD)	eUE5)	xue4	eUE2	5%/
D F , ,mT*++++<<r   r	   zTensor[]rh   rA   rB   ri   c                    | dS | t           j        j        u r |d           t          j        |           }|t
          ur?| t                                          vr |d|  dt           d           t          |          S t          j        |           }|D ]"}|t          vr |d|  dt           d           #dd	                    d |D                       z   d	z   S )
Nz()z7No return type annotation was provided. Please add one.zReturn has unsupported type r!   r    r%   r&   c                 (    g | ]}t           |         S  )SUPPORTED_RETURN_TYPES).0args     r   
<listcomp>z parse_return.<locals>.<listcomp>   s    HHHC237HHHr   r   )
r'   r0   r4   r\   
get_originr9   ru   r7   get_argsrF   )r3   r   originargsrw   s        r   rE   rE      sA   tW&,,,JKKKz**FU388::::HBz B B(>B B B   &j11?:&&D  ,,,HBz B B(>B B B  
 HH4HHHIIICOOr   rN   c                 T    | j         t          j        j        t          j        j        fv S r[   )r/   r'   r0   POSITIONAL_OR_KEYWORDr1   )rN   s    r   r.   r.      s(    :/&  r   
tuple_typec                    t          | dd          }| t          j        u s|dk    s|t          j        S t	          |          dk    rt          j        |d                  S t	          |          dk    r'|d         t
          u rt          j        |d                  S t          j        t          j        t          |                            S )z}
    Convert `tuple_type` into a list type with the same type arguments. Assumes that `tuple_type` is typing.Tuple type.
    __args__Nrt      r      )getattrr\   Tupler   r<   Ellipsisr   r9   )r   	type_argss     r   r:   r:      s     
J55I V\!!Y"__	8I{	Y1		{9Q<((	Y1		1!9!9{9Q<(({6<i(8(89::r   )r'   r\   r   r   r   r   rC   r   r   r	   r
   torch.utils._exposed_inr   Callabler)   rW   rf   rq   r@   rA   rB   rl   ru   rE   r6   r0   r.   Typer   r:   rt   r   r   <module>r      s     2 2 2 2 2 2 2 2 2 2 2 2  . . . . . . . . . . . . . . . . . . O "T- T- T-T-
 c]T- 	T- T- T- T-n  4  & H
K	7&	L( P P P6 2133 7,     ;fk&,7 ;FK<T ; ; ; ; ; ;r   