
    ivC                        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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' e'd      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)Never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                   v    e Zd ZdZeedddef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-dedeeef   dz  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ed   fd)Z&defd*Z'd+edef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.
    valueNreturnc                      y N r    s    q/var/www/vps2.regionflexible.com/Desarrollo/venv/lib/python3.12/site-packages/torch/_dynamo/variables/constant.pycreatezConstantVariable.create.   s    &)    c                      y r#   r$   r%   s    r&   r'   zConstantVariable.create2   s    36r(   kwargsc                      y r#   r$   )r    r*   s     r&   r'   zConstantVariable.create7   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>P   s     #WS$4$;$;C$@#Ws   !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.create;   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c                     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_literalrD   r   r4   numberitemr    selfr    r*   	__class__s      r&   rM   zConstantVariable.__init__`   so    "6"//6 	 =77;E{m D9 	6 >j		:DJDJr(   c                     | j                   S r#   r%   rR   s    r&   as_proxyzConstantVariable.as_proxyp       zzr(   c                 t    dt        | j                        j                   dt        | j                         dS )NzConstantVariable(z: ))rD   r    __name__reprrU   s    r&   __repr__zConstantVariable.__repr__s   s2    "4

#3#<#<"=RTZZ@P?QQRSSr(   c                     | j                   S r#   r%   rU   s    r&   as_python_constantz#ConstantVariable.as_python_constantv   rW   r(   Tc                      yNTr$   rU   s    r&   is_python_constantz#ConstantVariable.is_python_constanty       r(   c                 B    t        | j                  t        t        f      S r#   )r4   r    intboolrU   s    r&   is_symnode_likez ConstantVariable.is_symnode_like|   s    $**sDk22r(   valuesc                     | j                   |v S r#   r%   )rR   rg   s     r&   is_constant_matchz"ConstantVariable.is_constant_match   s    zzV##r(   c                     | j                   d u S r#   r%   rU   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_sequencerU   s    r&   rF   zConstantVariable.items   s     ''4'00r(   rm   r   r0   c                 b    t         j                  | j                  |j                                  S r#   )r   r'   r    r^   )rR   rm   r0   s      r&   getitem_constzConstantVariable.getitem_const   s,      &&JJs--/0
 	
r(   objc                 $    t        |       t        v S r#   )rD   r   )rq   s    r&   rN   z ConstantVariable.is_base_literal   s    Cy111r(   cachec                     i t        |       v ryt        |       t        t        t        t
        t        j                  fv r"| t        |       <   t        fd| D              S t        j                  |       S )NTc              3   J   K   | ]  }t         j                  |        y wr#   )r   
is_literal)r/   rE   rs   s     r&   r1   z.ConstantVariable.is_literal.<locals>.<genexpr>   s     J'221e<Js    #)idrD   r?   r=   r5   r7   torchSizeallr   rN   )rq   rs   s    `r&   rv   zConstantVariable.is_literal   sf    =Ec7e9uc9ejjAA E"S'NJcJJJ//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)rR   rm   rE   es       r&   rn   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}   )rR   rm   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      r0tE        | j                  |      r|s1|s/	 t        j                   t9        | j                  |                   S tE        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                  tg        | 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# tF        tH        f$ rM}t=        t?        |      |tK        tM        t        j                  |jN                                     Y d }~pd }~ww xY w# t:        $ rM}t=        t?        |      |tK        tM        t        j                  |jN                                     Y d }~4d }~ww xY w# t:        $ r }t=        t?        |      |       Y d }~`d }~ww xY w# td        $ r5}t=        t?        |      |tK        |jN                               Y d }~d }~ww xY w# t:        $ rM}t=        t?        |      |tK        tM        t        j                  |jN                                     Y d }~d }~ww xY w# td        $ rM}t=        t?        |      |tK        tM        t        j                  |jN                                     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#   )r4   )r/   rE   r   s     r&   r1   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}   rL   call_methodlistsr   rn   r   anyrV   rF   r4   __dict__r   	Exceptionr   rD   floatrd   r   OverflowError
ValueErrorr?   mapr   operatorra   rx   SymBoolSymFloatSymIntoutputcreate_proxybytescomplexr|   round)rR   rm   r   r   r*   arg_unpackedrE   	arg_constr   a
const_argskvconst_kwargsmethodr~   exc
add_targetopproxysearchresultr   rS   s                         @r&   r   zConstantVariable.call_method   sx    	,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1gdjj$6O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I'..s4::?? [ SY!^Q8R8R8T'..$**d1g&@&@&BC  ^#D	Q47;U;U;W:!W//1F4::-'..v66
 w"2tT6::I 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  I(a"4<HHI  (GRd3/?/F/F+O&P   (GRd3/?/F/F+O&P s   	U1 U,$/U1 :V >VV *VV V> #-W* %Y	 Z" 0'[ ?9\ 7"]( ,U1 1VVV V;:V;>	W'W""W'*Y9AYY		ZAZZ"	[+[[	\*\\	]%A]  ]%(	^>1A^99^>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    r3   re   r^   r}   _tree_map_fallbackr   
startswithr   rk   cloner4   rd   r   r   r   r   rx   dtyperL   call_tree_map)rR   rm   r   r   r   r   none_is_leaf_varr   tree_map_moduleotherrS   s             r&   r   zConstantVariable.call_tree_map1  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'   )rR   rm   r   r   s       r&   call_obj_hasattrz!ConstantVariable.call_obj_hasattre  s+     T*))0088r(   c                      yr`   r$   rU   s    r&   is_python_hashablez#ConstantVariable.is_python_hashablel  rb   r(   c                 ,    t        | j                        S r#   )hashr    rU   s    r&   get_python_hashz ConstantVariable.get_python_hasho  s    DJJr(   r   c                     ddl m} t        ||      r!| j                         |j	                         k(  S t        |t
              xr! | j                         |j                         k(  S )Nr   r   )r   r   r4   r^   evaluate_exprr   )rR   r   r   s      r&   is_python_equalz ConstantVariable.is_python_equalr  s[    +e_-**,0C0C0EEEuo. H'')U-E-E-GG	
r(   r#   )*rZ   r   __qualname____doc__r   staticmethodr
   r'   re   r   r   rM   rV   r   r\   r^   r   ra   rf   ri   rk   propertyr?   rF   rp   objectrN   dictrd   rv   r   rn   r   r   r   r   r   r   r   r   r   __classcell__rS   s   @r&   r   r   %   s    )d)u)  )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 	5tCK'84'? 	54 	5 	5-23-	o	- 7 s  {;#{; {; ?#	{;
 S/)*{; 
{;z2
#2
 ,2
  	2

 '2
 c?232
 
2
h 9)9149	9 9GDM    	
V 	
 	
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ed   fdZdefdZdedef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$   )rL   rM   r    rQ   s      r&   rM   zEnumVariable.__init__  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)ra   r?   r    r^   r   r   
USER_ERRORSUPPORTABLE)clsr   r   r   r   s        r&   r'   zEnumVariable.create  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#   )r4   r    rd   rU   s    r&   rV   zEnumVariable.as_proxy  s(    djj#&tzz?"zzr(   c                 4    dt        | j                         dS )NzEnumVariable(rY   )rD   r    rU   s    r&   r\   zEnumVariable.__repr__  s    tDJJ/022r(   c                     | j                   S r#   r%   rU   s    r&   r^   zEnumVariable.as_python_constant  rW   r(   rm   r   r   c                    t        | j                  |      st        |t        v rt	        j
                  | |      S t        | j                  |      }| j                  xr t        | j                  |      }t        j                  |||      S )Nr2   )r   r    r}   r   r   GetAttrVariabler   r-   r   r   build)rR   rm   r   r   r-   s        r&   var_getattrzEnumVariable.var_getattr  sp    tzz4(%%)),,T488T*>DKK!>$$R??r(   Tc                 0    t        | j                  |        yr`   )r   r    rU   s    r&   r   zEnumVariable.is_python_hashable  s     T2r(   c                 4    t        | j                               S r#   )r   r^   rU   s    r&   r   zEnumVariable.get_python_hash  s    D++-..r(   r   c                 h    t        |t              xr! | j                         |j                         k(  S r#   )r4   r   r^   )rR   r   s     r&   r   zEnumVariable.is_python_equal  s1    uo. H'')U-E-E-GG	
r(   )rZ   r   r   r   r	   enumEnumIntEnumr   rM   classmethodr   r'   rd   rV   r   r\   r^   r   r   r   r   r   re   r   r   r   s   @r&   r   r     s    eDIIt||$;<  PT  

&5
@C
	
 
 %		3/ 
3# 3E$))T\\*A$B @5 @S @_ @GDM / /
V 
 
r(   r   )*r   r   r   collections.abcr   typingr   r   r   r   r   r	   typing_extensionsr
   r   rx   torch._dynamo.sourcer   r   r   r   r   r   r   r   utilsr   r   r   r   r   r   baser   r   torch._dynamo.symbolic_convertr   	functionsr   r   CONSTANT_VARIABLE_NONEr   r$   r(   r&   <module>r     sl      $ I I -  : + 9  4 D/V
 V
r
 *$/ ;
? ;
r(   