
    ¯wgB                    D   U d dl mZ d dlmZ d dlmZmZmZmZm	Z	m
Z
mZmZmZmZmZmZmZmZmZmZmZmZ d dlmZmZmZmZmZmZmZmZm Z m!Z! da"de#d<   ddZ$dd	Z% ed
d      Z&	 	 	 	 	 	 	 	 ddZ'dddZ(ddZ)ddZ*ddZ+ G d d      Z, G d d      Z- G d d      Z.y)    )annotations)Any)BaseCppType	BaseCTypeboolTCTypedeviceTdoubleT
generatorTlayoutT	ListCTypelongTmemoryFormatT
NamedCTypeOptionalCTypescalarTscalarTypeTstringTSymIntTVectorCType)
ArgumentBaseTyBaseTypeFunctionSchemaListTypeOperatorNameOptionalTypeReturnTensorOptionsArgumentsTypeNzBaseCppType | None_valueTc                 0    t         st        d      t         S )NzHThe value type needs to be set with setValueT() in run_gen_lazy_tensor())r!   NotImplementedError     V/home/mcse/projects/flask/flask-venv/lib/python3.12/site-packages/torchgen/api/lazy.py	getValueTr'   2   s    !V
 	
 Nr%   c                    | a y N)r!   )vals    r&   	setValueTr+   <   s    Gr%   ztorch::lazyValueLazyIrPropertiesc                  t        | t              r_| j                  t        j                  k(  rt        t                     S | j                  t        j                  k(  r.|j                  rt        t              S t        t                     S | j                  t        j                  k(  rt        t              S | j                  t        j                  k(  rt        t              S | j                  t        j                  k(  r$|rt        t                     S t        t              S | j                  t        j                  k(  rt        t               S | j                  t        j"                  k(  rt        t$              S | j                  t        j&                  k(  rt        t(              S | j                  t        j*                  k(  rt        t,              S | j                  t        j.                  k(  rt        t0              S | j                  t        j2                  k(  rt        t4              S | j                  t        j6                  k(  rt        t8              S t;        dt=        |              t        | t>              r!tA        tC        | jD                  ||            S t        | tF              rt'        | jD                        dk(  r%tI        tA        t        t                                 S t'        | jD                        dk(  rt        tJ              S | jD                  t        t        j                        k(  rtM        t        t                    S tM        tC        | jD                  ||            S t;        dt=        |              )a  
    This function takes a type from NativeFunctions and converts it for use with
    lazy tensor codegen.

    Type conversion for lazy currently consists of
     (1) changing at::Tensors into lazy::Values
     (2) wrapping everything in a BaseCType
     (3) making cpp-reference types into cpp-value types (e.g. vector instead of IntArrayRef)

    (1) converts at::Tensors to lazy::Values (which wrap lazy::Nodes, with which Lazy IR represents tensors.)
    There is special handling for Optional[Tensor] or List[Tensor], etc- hence 'tensor-like'

    This is incomplete- there are assertions in places that it's expected to need to add
    more types as the codegen is used with more operators.
    zTODO add support for type symintzTensor?Tensorzunrecognized type )'
isinstancer   namer   r1   r   r'   ScalarTreatScalarsAsConstantsr   
ScalarTyper   intr   SymIntboolr   floatr
   strr   Devicer	   	Generatorr   Layoutr   MemoryFormatr   AssertionErrorreprr   r   process_ir_typeelemr   r   tensorListValueTr   )typ
propertiesr0   s      r&   rB   rB   F   s`   $ #x 88v}}$Y[))XX&11 )) Y[))XX***[))XX#U##XX& -- ''XX$U##XX%W%%XX#W%%XX&W%%XX)))Z((XX&W%%XX,,,]++ #=d3i[!IJJ	C	&_SXXz&QRR	C	"sxx=I%]9Y[+ABCC]h&-..XX&--00 y/00 sxxFSTT1$s)=>>r%   c                j   t        | t              rV|xr |j                  }| j                  t	               k(  xs- | j                  t
        k(  xr | xs | j                  t        k(  S | t        t        t                    k(  ryt        | t        t        t        f      rt        | j                  |      S y)z
    Given a type, determine if it is a Value-like type.  This is equivalent to
    being Tensor-like, but assumes the type has already been transformed.
    F)r2   r   r5   typer'   r   r   r   r   r   isValueTyperC   )rE   rF   treat_scalars_as_constantss      r&   rI   rI      s    
 #y! &0%VJ4V4V"HH	# #G#F,F(F#xx7"	

 
Ig./	/	C-K@	A388Z00r%   c                `    t        | t              xr | j                  t        j                  k(  S r)   )r2   r   r3   r   r8   rE   s    r&   isSymIntTyperM      s!    c8$BV]])BBr%   c                    t        | t              r| j                  t        j                  k(  S t        | t
        t        f      rt        | j                        S y)a  
    Given a type, determine if it is a c10::scalar which we will wrap in a lazy Value.
    Since we literally change the type from scalarT to valueT, information is lost.
    This function helps build a list of wrapped scalars to save that information
    F)	r2   r   r3   r   r4   r   r   isWrappedScalarTyperC   rL   s    r&   rO   rO      sD     #x  xx6==((	C,1	2"388,,r%   c                    t        | t              r| j                  t        j                  k(  S t        | t
              rt        | j                        S y)NF)r2   r   r3   r   r=   r   isGeneratorTyperC   rL   s    r&   rQ   rQ      s=    #x xx6++++	C,	(sxx((r%   c                      e Zd ZU ded<   ded<   ded<   ded<   ded	<   ded
<   ded<   ded<   	 	 	 	 	 	 	 	 ddZedd       Zy)LazyArgumentr;   r3   r    	orig_typezCType | None
lazy_type_r9   is_wrapped_scalaris_generatoris_symint_or_listr0   is_lazy_valuec               "   |j                   | _         |j                  | _        || _        t	        |j                  t
              | _        t        |j                        | _        t        |j                  ||      | _
        t        |j                        | _        |xrR t        |j                        xs; t	        |j                  t
              xr t        |j                  j                        | _        t!        | j"                  |      | _        y )Nr/   )r3   rH   rT   r0   r2   r   is_optionalrQ   rW   rB   rU   rO   rV   rM   rC   rX   rI   	lazy_typerY   )selfargrF   r0   s       r&   __init__zLazyArgument.__init__   s     HH	%chh=+CHH5)#((JvN!4SXX!>!' "
" T388\2R|CHHMM7R 	 )Dr%   c                Z    | j                   J d| j                          | j                   S )Nz3Attempted to access lazy_type for invalid argument )rU   r3   r]   s    r&   r\   zLazyArgument.lazy_type   s5     OO'	M@L	M'r%   N)r^   r   rF   r-   r0   r9   returnNone)rb   r   )__name__
__module____qualname____annotations__r_   propertyr\   r$   r%   r&   rS   rS      sq    
IO L EE)9EFJE	E&  r%   rS   c                  8    e Zd ZU dZdZded<   d	dZd
dZddZy)r-   aD  Collection of properties for an IR node

    The property groups are listed below. Each group is mutually
    exclusive, meaning that only one property from each group can be True
    at any one time. The properties can be accessed as if they were normal
    attributes. The mutual exclusivity is automatically handled.
    ))ShapePrecomputeShapeCompute
ShapeCache)LowerLowerDeclOnly)CanBeReusedCanBeReusedDeclOnly)CreateFnCreateFnDeclOnly)r5   ztuple[tuple[str, ...], ...]
Propertiesc                    t         j                  t        j                        }|| j                  d<   |D ]  }t        | |d        y )NrF   T)dictfromkeysr-   rs   __dict__setattr)r]   default_propertiesrF   ps       r&   r_   zLazyIrProperties.__init__  sD    8<''9

 '1l## 	#AD!T"	#r%   c                    | j                   d   }t        j                  D ]  }||v s||   |k(  c S  | j                  |      S )NrF   )rw   r-   rs   __getattribute__)r]   keyrF   valuess       r&   __getattr__zLazyIrProperties.__getattr__  sO    ]]<0
&11 	1Ff}!&)S00	1 $$S))r%   c                    | j                   d   }t        j                  D ]  }||v s|r|nd ||<   |c S  t        d|       )NrF   zInvalid property: )rw   r-   rs   KeyError)r]   r}   valuerF   r~   s        r&   __setattr__zLazyIrProperties.__setattr__&  sT    ]]<0
&11 	Ff},1St
6"	
 +C5122r%   N)ry   r;   rb   rc   )r}   r;   rb   r   )r}   r;   r   r   rb   r   )	rd   re   rf   __doc__rs   rg   r_   r   r   r$   r%   r&   r-   r-      s%    /J+ .#*3r%   c                  F   e Zd ZU ded<   ded<   ded<   ded<   dZd	ed
<   ded<   ded<    eddd      Zded<   dZded<   	 d	 	 	 	 	 	 	 d dZe	d!d       Z
e	d!d       Ze	d!d       Z	 	 	 	 	 d"	 	 	 	 	 	 	 	 	 	 	 d#dZe	d$d       Ze	d$d       Ze	d$d       Ze	d$d       Zy)%LazyIrSchemar   r3   ztuple[LazyArgument, ...]positional_argskeyword_argsztuple[Return, ...]returnsNzNamedCType | Nonegenerator_argr   funcr9   r0   rj   rm   ro   r-   rF   z
str | Noneopkindc                   |r| _         | _         _        g }dD ]  }|dk(  r^|j                  j                  H|j                  j                  j
                  }|j                  t        | j                                ft        |j                  |      }|j                   fdt        |j                  |      D                t        |       _        g }dD ]  }t        |j                  |      }|t        |t              r|j                         }|D ]P  }t        |j                         s j"                  J d       t%        |j&                  |j                          _        R |j                   fd|D                t        |       _        |j&                   _        |j*                   _        y )N)pre_self_positionalself_argpost_self_positionalr   r/   c              3  N   K   | ]  }t        |j                           ywr/   NrS   rF   .0r^   r]   r0   s     r&   	<genexpr>z(LazyIrSchema.__init__.<locals>.<genexpr>f  s)      ' !doofEE'   "%)pre_tensor_options_kwarg_onlytensor_optionspost_tensor_options_kwarg_onlyoutz)We expect there is only one generator argc              3  N   K   | ]  }t        |j                           ywr   r   r   s     r&   r   z(LazyIrSchema.__init__.<locals>.<genexpr>  s)      $ !doofEE$r   )rF   r   r0   	argumentsr   argumentappendrS   getattrextendtupler   r2   r   allrQ   rH   r   r   r3   r   r   )	r]   r   rF   r0   r   	arg_fieldr^   r   	curr_argss	   `  `     r&   r_   zLazyIrSchema.__init__R  s    (DO	.0T 
	IJ&4>>+B+B+Nnn--66&& doofE 3?&& '&t~~yA' 
	  %_5+-
 	I  	:I$i)?@ )I$ C&sxx0 ..6GFG6-7HHchh.* ## $($ %	, ",/II	||r%   c                    | j                   j                    d| j                   j                   j                         }dj                  d |j	                  d      D              S )z
        Return camel-case version of op in node.

        Note: This function also appends any `overload_name` in the operation.
        For example, if the op is `bitwise_and.Tensor`, the returned name
        will be `BitwiseAndTensor`.
        _ c              3  D   K   | ]  }|j                         xs d   yw)r   N)
capitalize)r   words     r&   r   z)LazyIrSchema.node_name.<locals>.<genexpr>  s     N4t(.B.Ns    )r3   overload_namelowerjoinsplit)r]   op_names     r&   	node_namezLazyIrSchema.node_name  sO     YY^^$Adii&=&=%>?EEGwwN7==;MNNNr%   c                @    t        | j                  j                        S r)   )r;   r3   ra   s    r&   	aten_namezLazyIrSchema.aten_name  s    499>>""r%   c                D    | j                   j                   j                   S r)   )r3   basera   s    r&   	base_namezLazyIrSchema.base_name  s    ))..%%&'r%   c                   g }|r|j                  | j                         |r|j                  | j                         |r|r|r|S |r|r|D cg c]  }|j                  r| c}S |r|D cg c]  }|j                  s| c}S |r*|D cg c]  }|j                  s|s|j                  s|  c}S g S c c}w c c}w c c}w r)   )r   r   r   rW   rY   )r]   
positionalkeywordr~   scalars	generatorargsas           r&   filtered_argszLazyIrSchema.filtered_args  s     $&KK,,-KK))*g)K#:!1>>A::#7!qA77 IQ^^   	 ;7s   B3B3,B8>B8#B=c                ,    | j                  dddd      S NTFr   r   r~   r   r   ra   s    r&   positional_valueszLazyIrSchema.positional_values  s#    !!U4 " 
 	
r%   c                ,    | j                  dddd      S r   r   ra   s    r&   positional_scalarszLazyIrSchema.positional_scalars  s#    !!U5$ " 
 	
r%   c                ,    | j                  dddd      S NFTr   r   ra   s    r&   keyword_valueszLazyIrSchema.keyword_values  s#    !!d4 " 
 	
r%   c                ,    | j                  dddd      S r   r   ra   s    r&   keyword_scalarszLazyIrSchema.keyword_scalars  s#    !!d5$ " 
 	
r%   r)   )r   r   rF   LazyIrProperties | Noner0   r9   rb   rc   )rb   r;   )TTTTT)r   r9   r   r9   r~   r9   r   r9   r   r9   rb   list[LazyArgument])rb   r   )rd   re   rf   rg   r   r-   rF   r   r_   rh   r   r   r   r   r   r   r   r   r$   r%   r&   r   r   6  so   
--**   (,M$+  L#3	$J   FJ
 /33$3$ ,3$
 3$ 
3$j 	O 	O # # ( (
       	 
     
 D 
 

 
 

 
 

 
 
r%   r   )rb   r   )r*   r   rb   rc   )rE   r    rF   r-   r0   r9   rb   z3BaseCType | VectorCType | OptionalCType | ListCTyper)   )rE   r   rF   r   rb   r9   )rE   r    rb   r9   )/
__future__r   typingr   torchgen.api.typesr   r   r   r   r	   r
   r   r   r   r   r   r   r   r   r   r   r   r   torchgen.modelr   r   r   r   r   r   r   r   r   r    r!   rg   r'   r+   rD   rB   rI   rM   rO   rQ   rS   r-   r   r$   r%   r&   <module>r      s    "     (   #	 " }g6 J?	J?+J?8<J?8J?d,C ' 'T73 73@]
 ]
r%   