
    i5@                         d Z ddlZddlZddlmZ ddlmZmZmZm	Z	m
Z
mZ ddlmZ ddlZddlmZmZ ddlmZmZ dd	lmZmZ dd
lmZmZmZmZmZmZ ddlm Z m!Z! e
rddl"m#Z# ddl$m%Z%  G d de!      Z& G d de!      Z'y)a  
Constant and enum variable tracking in Dynamo.

This module is fundamental to Dynamo's ability to track and propagate constant
values during compilation, ensuring proper handling of Python literals and
maintaining type safety through the compilation process.
    N)Sequence)AnyLiteralOptionaloverloadTYPE_CHECKINGUnion)override)
AttrSourceGetItemSource   )graph_break_hints	variables)raise_observed_exceptionunimplemented)cmp_name_to_op_mappingcommon_constant_typesistypenpraise_args_mismatchraise_on_overridden_hash   )ValueMutationNewVariableTracker)InstructionTranslator)UserFunctionVariablec                        e Zd ZdZeededd fd              Zeededede	fd              Zededede	fd       Zdededdf fd	Z
defd
ZdefdZdefdZded   fdZdefdZdedefdZdefdZedee	   fd       Zddde	de	fdZededefd       Zededefd       Zded   dee	   fdZdddede	fdZdddedee	   deee	f   de	f
 fdZddd d!d"e	d#e e	   d$eee	f   de	f fd%Z!e"dddedd fd&       Z#d' Z$d( Z%d) Z& xZ'S )*ConstantVariablea  
    Variable tracker for Python literals and basic immutable types, with automatic
    routing support for collection types (lists, tuples, sets, etc.).

    The create() method intelligently constructs appropriate variable types for
    nested collections.
    valuereturnc                      y N r   s    Z/var/www/html/engine/venv/lib/python3.12/site-packages/torch/_dynamo/variables/constant.pycreatezConstantVariable.create.   s    36    kwargsc                      y r"   r#   )r   r(   s     r%   r&   zConstantVariable.create2   s    >Ar'   c                 D   |j                  d      }t        | t              r8| D cg c]  }t        j	                  |       }}t        j                  |fi |S t        | t              r8| D cg c]  }t        j	                  |       }}t        j                  |fi |S t        | t              rK| j                  | j                  | j                  f}t        d |D              }t        j                  |fi |S t        | t        t        f      ryg }t!        |       D ];  \  }}|rt#        ||      nd}|j%                  t        j	                  ||             = t        j&                  j)                  t+        |             |fi |S t        | fi |S c c}w c c}w )aV  
        Create a `ConstantVariable` based on the given value, and supports
        automatic routing for collection types like `tuple` (in which case we'd
        create `ConstantVariable` for the leaf items).

        NOTE: the caller must install the proper guards if needed; most often
        the guard will be `CONSTANT_MATCH`.
        sourcec              3   F   K   | ]  }t         j                  |        y wr"   )r   r&   ).0args     r%   	<genexpr>z*ConstantVariable.create.<locals>.<genexpr>K   s     #WS$4$;$;C$@#W   !Nr+   )get
isinstancesetr   r&   r   SetVariable	frozensetFrozensetVariableslicestartstopsteptupleSliceVariablelist	enumerater   appendBaseListVariablecls_fortype)	r   r(   r+   xitems
slice_argsslice_args_varsiitem_sources	            r%   r&   zConstantVariable.create6   s}    H% eS!9>?A%,,Q/?E?((9&99y)9>?A%,,Q/?E?..u???u%++uzz5::>J##WJ#WWO**?EfEEe}-E!%( 1:@mFA6d$++* ,  --55d5kB5SFSS000+ @ @s   F.FNc                     t        |   di | t        j                  |      sJ dt	        |       d       t
        0t        |t
        j                        r|j                         | _	        y || _	        y )Nz7
Cannot construct `ConstantVariable` for value of type a`  .

This failure likely due to PyTorch-internal use of `ConstantVariable` on
non-literal python values, please try using `VariableTracker.build` instead. If
you believe it's a necessary and legitimate use case (the value is immutable and
can't easily be represented with another `VariableTracker` class), please add
its type to `common_constant_types`.
r#   )
super__init__r   is_base_literalrC   r   r3   numberitemr   selfr   r(   	__class__s      r%   rL   zConstantVariable.__init__[   so    "6"//6 	 =77;E{m D9 	6 >j		:DJDJr'   c                     | j                   S r"   r$   rQ   s    r%   as_proxyzConstantVariable.as_proxyk       zzr'   c                 t    dt        | j                        j                   dt        | j                         dS )NzConstantVariable(z: ))rC   r   __name__reprrT   s    r%   __repr__zConstantVariable.__repr__n   s2    "4

#3#<#<"=RTZZ@P?QQRSSr'   c                     | j                   S r"   r$   rT   s    r%   as_python_constantz#ConstantVariable.as_python_constantq   rV   r'   Tc                      yNTr#   rT   s    r%   is_python_constantz#ConstantVariable.is_python_constantt       r'   c                 B    t        | j                  t        t        f      S r"   )r3   r   intboolrT   s    r%   is_symnode_likez ConstantVariable.is_symnode_likew   s    $**sDk22r'   valuesc                     | j                   |v S r"   r$   )rQ   rf   s     r%   is_constant_matchz"ConstantVariable.is_constant_matchz   s    zzV##r'   c                     | j                   d u S r"   r$   rT   s    r%   is_constant_nonez!ConstantVariable.is_constant_none}   s    zzT!!r'   c                 &    | j                  d      S )zz
        Need this when adding a BaseListVariable and a ConstantVariable together.
        Happens in detectron2.
        N)tx)unpack_var_sequencerT   s    r%   rE   zConstantVariable.items   s     ''4'00r'   rl   r   r.   c                 b    t         j                  | j                  |j                                  S r"   )r   r&   r   r]   )rQ   rl   r.   s      r%   getitem_constzConstantVariable.getitem_const   s,      &&JJs--/0
 	
r'   objc                 $    t        |       t        v S r"   )rC   r   rp   s    r%   rM   z ConstantVariable.is_base_literal   s    Cy111r'   c                     t        |       t        t        t        t        t
        j                  fv rt        d | D              S t        j                  |       S )Nc              3   F   K   | ]  }t         j                  |        y wr"   )r   
is_literal)r-   rD   s     r%   r/   z.ConstantVariable.is_literal.<locals>.<genexpr>   s     C!'2215Cr0   )
rC   r>   r<   r4   r6   torchSizeallr   rM   rr   s    r%   ru   zConstantVariable.is_literal   s?    9uc9ejjAACsCCC//44r'   c                     	 | j                         D cg c]  }t        j                  |       c}S c c}w # t        $ r}t        |d }~ww xY wr"   )r]   r   r&   	TypeErrorNotImplementedError)rQ   rl   rD   es       r%   rm   z$ConstantVariable.unpack_var_sequence   sH    	-8<8O8O8QR1$++A.RRR 	-%1,	-s!   8 38 8 	AAAnamec                     t        | j                  |      st        t        ||g       t	        | j                  |      }t        |      rt        |S )Nargs)hasattrr   r   AttributeErrorgetattrcallabler{   )rQ   rl   r}   members       r%   const_getattrzConstantVariable.const_getattr   sA    tzz4($^RtfET*F%%r'   r   c                    ddl m |dk(  rQt        | j                  t              r7t        j                  t        j                        j                  || g||      S |dk(  rt        | j                  t              r|st        |      dk7  r&t        ||dt        |       dt        |       d       |d   j                  |      }	 |D cg c]  }|j                          }}t        j                  | j                  j                  |            S |d	k(  rAt        | j                  t              r'dd
lm}  || j+                  |      t-                     S t/        fd|D              rKt
        j                  j                  || j1                         | j                        j%                  ||||      S 	 |D 	cg c]  }	|	j                          }
}	|j3                         D ci c]  \  }}||j                          }}}t5        | j                  t              rD|t        j6                  v r2t9        | j                  |      }	 t        j                   ||
i |      S t5        | j                  t@        tB        f      r|s1|s/	 t        j                   t9        | j                  |                   S tO        tP        |      rt        |      dk(  ru|d   jS                         ra|
d   }t9        tP        |      }t5        |tT        jV                  tT        jX                  tT        jZ                  f      r=|j\                  j_                  d|| j                  |fi       }j                  |||      S 	 t        j                   || j                  |            S t5        | j                  t`              r6|dk(  r1t9        | j                  |      }t        j                   ||
i |      S t?        | j                        tb        u rD|tb        j6                  v r2t9        | j                  |      }	 t        j                   ||
i |      S |dk(  r,|s*|s(t        j                  t        | j                              S |dk(  r\t        |      dk(  rN|d   jS                         r;	 t        j                  te        | j                  |d   j                                     S |dk(  r\t        |      dk(  rN|d   jS                         r;|rJ |d   j                         }	 || j                  v }t        j                  |      S t"        | I  ||||      S c c}w # t         $ r t"        | I  ||||      cY S w xY wc c}	w c c}}w # t         $ r t"        | I  ||||      cY S w xY w# t:        $ r }t=        t?        |      |       Y d }~{d }~ww xY w# tD        tF        f$ rM}t=        t?        |      |tI        tK        t        j                  |jL                                     Y d }~od }~ww xY w# t:        $ rM}t=        t?        |      |tI        tK        t        j                  |jL                                     Y d }~3d }~ww xY w# t:        $ r }t=        t?        |      |       Y d }~_d }~ww xY w# t:        $ rM}t=        t?        |      |tI        tK        t        j                  |jL                                     Y d }~d }~ww xY w# tf        $ rM}t=        t?        |      |tI        tK        t        j                  |jL                                     Y d }~d }~ww xY w)Nr   SymNodeVariableformatjoinz1 args and 0 kwargsz
 args and z kwargsr   __iter__)ListIteratorVariable)mutation_typec              3   6   K   | ]  }t        |        y wr"   )r3   )r-   rD   r   s     r%   r/   z/ConstantVariable.call_method.<locals>.<genexpr>   s     <!z!_-<s   r   call_functiondecode__len__	__round____contains__)4tensorr   r   r   strr   BuiltinVariabler   r   lenr   force_unpack_var_sequencer]   r   r&   r   r{   rK   call_methodlistsr   rm   r   anyrU   rE   r3   __dict__r   	Exceptionr   rC   floatrc   OverflowError
ValueErrorr>   mapr   r   operatorr`   rv   SymBoolSymFloatSymIntoutputcreate_proxybytescomplexroundrz   )rQ   rl   r}   r   r(   arg_unpackedrD   	arg_constr   a
const_argskvconst_kwargsmethodr|   exc
add_targetopproxysearchresultr   rR   s                         @r%   r   zConstantVariable.call_method   s5    	,8tzz3 7,,SZZ8FFTMDM6  V^tzz3 7Ta#)4ykCK=@	  7<<R@LC=IJQ113J	J'..tzzy/IJJ ZF4::s$; 4'((,<L<N  <t<<,,33DMMOTZZk"dD&12	?:>?Q!..0?J?BH,,.Q$!QAq3355QLQ djj#&43<<+?TZZ.F6'..vz/R\/RSS 

UCL1F+223L74::t3L3NOO $'ING..0']
Xt, M II22'djj*-ErE +11"eZHH/66r$**j7QRR
 

E*tx/?TZZ.F#**6:+N+NOO$**(TW5E5E-ETZZ.F6'..vz/R\/RSS 9df#**3tzz?;;[ SY!^Q8R8R8T'..$**d1g&@&@&BC  ^#D	Q47;U;U;W:!W//1F4::-'..v66
 w"2tT6::C K& Cw*2tT6BBC$ @Q" 	?7&r4v>>	?  6(a"556 &z2 ,S	!#&6&=&=sxx"HI 0 % 0 GRd37G7N7NPQPVPV3W.X   6(a"556  (GRd3/?/F/F+O&P   (GRd3/?/F/F+O&P s   	U U$/U :V >U:V *U?V V& -W :%X1 4Z
 '9Z6 "\ U U76U7:V V#"V#&	W/W

WX.!AX))X.1	Z:AZZ
	Z3Z..Z36	\?A\\	]%A]  ]%tree_map_fnr   map_fnresttree_map_kwargsc           
         | j                   |j                  d      }|	 t        |j                               }n*t        t        |dd       dd      }|j                  d       }|r|j                  || g|i       S |D ])  }	|	j                         r| j                  |||||      c S  | j                         S t        | j                   t        t        t        t        t        t         t"        j$                  f      r|j                  || g|i       S t&        
| Q  |||||      S # t        $ r | j                  |||||      cY S w xY w)Nnone_is_leaffn
__module__ optree)r   r2   rd   r]   r{   _tree_map_fallbackr   
startswithr   rj   cloner3   rc   r   r   r   r   rv   dtyperK   call_tree_map)rQ   rl   r   r   r   r   none_is_leaf_varr   tree_map_moduleotherrR   s             r%   r   zConstantVariable.call_tree_map#  si    ::.22>B+	#'(8(K(K(M#NL #*Kt4lB# $3#=#=h#GG++BrBB! E 113#66'" +   zz|#djj3tWc5%++"VW''TMDM2>>w$
 	
? + 22#' s   D( (E	E	c                 l    t        | j                  |      }t        j                  j	                  |      S r"   )r   r   r   r   r&   )rQ   rl   r}   r   s       r%   call_obj_hasattrz!ConstantVariable.call_obj_hasattrW  s+     T*))0088r'   c                      yr_   r#   rT   s    r%   is_python_hashablez#ConstantVariable.is_python_hashable^  ra   r'   c                 ,    t        | j                        S r"   )hashr   rT   s    r%   get_python_hashz ConstantVariable.get_python_hasha  s    DJJr'   c                     ddl m} t        ||      r!| j                         |j	                         k(  S | j                         |j                         k(  S )Nr   r   )r   r   r3   r]   evaluate_expr)rQ   r   r   s      r%   is_python_equalz ConstantVariable.is_python_equald  sI    +e_-**,0C0C0EEE&&(E,D,D,FFFr'   )(rY   r   __qualname____doc__r   staticmethodrd   r&   r   r   rL   rU   r   r[   r]   r   r`   re   rh   rj   propertyr>   rE   ro   objectrM   ru   r   rm   r   dictr   r   r   r
   r   r   r   r   __classcell__rR   s   @r%   r   r   %   s    6d616  6AcASA_A  A"1c "1S "1_ "1 "1Hc S T  # T# TC GDM 3 3$ $ $"$ " 1tO, 1 1
)
0?
	
 2V 2 2 2 5 54 5 5
-23-	o	- 7 s  x;#x; x; ?#	x;
 S/)*x; 
x;t2
#2
 ,2
  	2

 '2
 c?232
 
2
h 9)9149	9 9 Gr'   r   c            	           e Zd ZdZdeej                  ej                  f   deddf fdZ	e
deded	edd fd
       Zdeej                  ef   fdZdefdZdeej                  ej                  f   fdZdddedefdZd Zd Zd Z xZS )EnumVariablezVariableTracker for enum.Enum and enum.IntEnum instances

    Provides specialized handling for Python enum types, supporting
    both standard Enum and IntEnum with proper value tracking and comparison.
    r   r(   r    Nc                 2    t        |   di | || _        y )Nr#   )rK   rL   r   rP   s      r%   rL   zEnumVariable.__init__t  s    "6"
r'   cls_typevalue_vtoptionsc           
      0   |j                         r8t        |      D ]*  }|j                  |j                         k(  s! | |fi |c S  t	        dd| dt        |       d| dt        |       dg t
        j                  t
        j                         y )Nz!Failed to construct Enum variablezvalue: z, allowed enum values: zAttempted to construct an Enum value that is non-constant (e.g. int, string) or is not an acceptable value for the Enum. Acceptable values for Enum `z`: .)gb_typecontextexplanationhints)r`   r>   r   r]   r   r   
USER_ERRORSUPPORTABLE)clsr   r   r   r   s        r%   r&   zEnumVariable.createx  s     &&(x. 2<<8#>#>#@@v1112 	7hZ'>tH~>NO++3*CX7GqJ R%00Q3D3P3PQ	
r'   c                 x    t        | j                  t              rt        | j                        S | j                  S r"   )r3   r   rc   rT   s    r%   rU   zEnumVariable.as_proxy  s(    djj#&tzz?"zzr'   c                 4    dt        | j                         dS )NzEnumVariable(rX   )rC   r   rT   s    r%   r[   zEnumVariable.__repr__  s    tDJJ/022r'   c                     | j                   S r"   r$   rT   s    r%   r]   zEnumVariable.as_python_constant  rV   r'   rl   r   r}   c                    t        | j                  |      st        |t        v rt	        j
                  | |      S t        | j                  |      }| j                  xr t        | j                  |      }t        j                  |||      S )Nr1   )r   r   r{   r   r   GetAttrVariabler   r+   r   r   build)rQ   rl   r}   r   r+   s        r%   var_getattrzEnumVariable.var_getattr  sp    tzz4(%%)),,T488T*>DKK!>$$R??r'   c                 0    t        | j                  |        yr_   )r   r   rT   s    r%   r   zEnumVariable.is_python_hashable  s     T2r'   c                 4    t        | j                               S r"   )r   r]   rT   s    r%   r   zEnumVariable.get_python_hash  s    D++-..r'   c                 D    | j                         |j                         k(  S r"   )r]   )rQ   r   s     r%   r   zEnumVariable.is_python_equal  s    &&(E,D,D,FFFr'   )rY   r   r   r   r	   enumEnumIntEnumr   rL   classmethodr   r&   rc   rU   r   r[   r]   r   r   r   r   r   r   s   @r%   r   r   m  s    eDIIt||$;<  PT  

&5
@C
	
 
 %		3/ 
3# 3E$))T\\*A$B @5 @S @_ @/Gr'   r   )(r   r   r   collections.abcr   typingr   r   r   r   r   r	   typing_extensionsr
   rv   torch._dynamo.sourcer   r   r   r   r   r   r   r   utilsr   r   r   r   r   r   baser   r   torch._dynamo.symbolic_convertr   	functionsr   r   r   r#   r'   r%   <module>r     sc      $ I I &  : + 9  4 D/EG EGP
8G? 8Gr'   