
    9jI                       d Z ddlmZ ddlZddlmZmZmZmZ ddl	m
Z
 ddlZddlmZ ddlmZ dd	lmZmZ dd
l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 ddlm Z   G d de      Z! e!d      Z" e!d      Z# e!d      Z$ G d de      Z%y)z
Constant 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.
    )annotationsN)AnyLiteraloverloadTYPE_CHECKING)override)GetItemSource   )	variables)raise_observed_exceptionunimplemented)common_constant_typesistypenpraise_args_mismatch   )ValueMutationNewVariableTracker)Sequence)InstructionTranslator)UserFunctionVariablec            
           e Zd ZdZeeeee e	d      e
 e	d      fZeed#d              Zeed$d              Zeed%d              Zed%d       Zd& fdZd'd	Zd(d
Zd'dZd)dZd*dZd+dZd*dZed,d       Z	 	 	 	 	 	 d-dZed.d       Zed/d0d       Z	 	 	 	 d1dZd2dZd2dZd2dZd3dZ 	 	 	 	 	 	 	 	 	 	 d4 fdZ!	 	 	 	 	 	 	 	 	 	 	 	 d5 fdZ"e#	 	 	 	 	 	 d6d       Z$d)dZ%d7dZ&d8dZ'd9dZ(	 	 	 	 d: fd Z)	 	 	 	 d:d!Z*	 	 	 	 d: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.
    N.c                     y N values    `/media/conek/DATA/Code/OCR/venv/lib/python3.12/site-packages/torch/_dynamo/variables/constant.pycreatezConstantVariable.create2       14    c                     y r   r   r   s    r   r    zConstantVariable.create6   r!   r"   c                     y r   r   )r   kwargss     r   r    zConstantVariable.create:   s    >Ar"   c                   |s| x t         S xdu r t        S du rt        S |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/                  t1        |             |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`.
        NTFsourcec              3  F   K   | ]  }t         j                  |        y wr   )r   r    ).0args     r   	<genexpr>z*ConstantVariable.create.<locals>.<genexpr>^   s     #WS$4$;$;C$@#Ws   !)r'   )CONSTANT_VARIABLE_NONECONSTANT_VARIABLE_TRUECONSTANT_VARIABLE_FALSE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    111122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   F8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_literalr@   r   r0   numberitemr   selfr   r%   	__class__s      r   rI   zConstantVariable.__init__n   so    "6"//6 	 =77;E{m D9 	6 >j		:DJDJr"   c                    | j                   S r   r   rN   s    r   as_proxyzConstantVariable.as_proxy~       zzr"   c                t    dt        | j                        j                   dt        | j                         dS )NzConstantVariable(z: ))r@   r   __name__reprrQ   s    r   __repr__zConstantVariable.__repr__   s2    "4

#3#<#<"=RTZZ@P?QQRSSr"   c                    | j                   S r   r   rQ   s    r   as_python_constantz#ConstantVariable.as_python_constant   rS   r"   c                     yNTr   rQ   s    r   is_python_constantz#ConstantVariable.is_python_constant       r"   c                B    t        | j                  t        t        f      S r   )r0   r   intboolrQ   s    r   is_symnode_likez ConstantVariable.is_symnode_like   s    $**sDk22r"   c                    | j                   |v S r   r   )rN   valuess     r   is_constant_matchz"ConstantVariable.is_constant_match   s    zzV##r"   c                    | j                   d u S r   r   rQ   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_sequencerQ   s    r   rB   zConstantVariable.items   s     ''4'00r"   c                b    t         j                  | j                  |j                                  S r   )r   r    r   rZ   )rN   ri   r*   s      r   getitem_constzConstantVariable.getitem_const   s,      &&JJs--/0
 	
r"   c                $    t        |       t        v S r   )r@   r   )objs    r   rJ   z ConstantVariable.is_base_literal   s    Cy111r"   c                    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)   rA   caches     r   r+   z.ConstantVariable.is_literal.<locals>.<genexpr>   s     J'221e<Js    #)idr@   r;   r9   r1   r3   torchSizeallr   rJ   )rn   rr   s    `r   rq   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   )rZ   r   r    	TypeErrorNotImplementedError)rN   ri   rA   es       r   rj   z$ConstantVariable.unpack_var_sequence   sH    	-8<8O8O8QR1$++A.RRR 	-%1,	-s!   8 38 8 	AAAc                    	 t         j                  t        | j                              S # t        $ r4}t        t        |      |t        |j                               Y d}~yd}~ww xY w)z9Generic len for any constant value (sequence or mapping).argsN)	r   r    lenr   rx   r   r@   r;   r}   )rN   ri   rz   s      r   len_implzConstantVariable.len_impl   sN    	E#**3tzz?;; 	E$T!WbtAFF|DD	Es   '* 	A'*A""A'c                $    | j                  |      S )z6Sequence length - delegates to len_impl for constants.r   rN   ri   s     r   	sq_lengthzConstantVariable.sq_length       }}R  r"   c                $    | j                  |      S )z5Mapping length - delegates to len_impl for constants.r   r   s     r   	mp_lengthzConstantVariable.mp_length   r   r"   c                    t        | j                  |      st        t        ||g       t	        | j                  |      }t        |      rt        |S )Nr|   )hasattrr   r   AttributeErrorgetattrcallablery   )rN   ri   namemembers       r   const_getattrzConstantVariable.const_getattr   sA    tzz4($^RtfET*F%%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        tN        |      rt        |      dk(  ru|d   jQ                         ra|
d   }t9        tN        |      }t5        |tR        jT                  tR        jV                  tR        jX                  f      r=|jZ                  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                        t`        u rD|t`        j6                  v r2t9        | j                  |      }	 t        j                   ||
i |      S |dk(  r\t        |      dk(  rN|d   jQ                         r;	 t        j                  tc        | j                  |d   j                                     S |dk(  r\t        |      dk(  rN|d   jQ                         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 }~Jd }~ww xY w# tF        tH        f$ r5}t=        t?        |      |tK        |jL                               Y d }~&d }~ww xY w# t:        $ r5}t=        t?        |      |tK        |jL                               Y d }~d }~ww xY w# t:        $ r }t=        t?        |      |       Y d }~d }~ww xY w# t:        $ r5}t=        t?        |      |tK        |jL                               Y d }~}d }~ww xY w# td        $ r5}t=        t?        |      |tK        |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   )r0   )r)   rA   r   s     r   r+   z/ConstantVariable.call_method.<locals>.<genexpr>   s     <!z!_-<s   r|   call_functiondecode	__round____contains__)3tensorr   r   r   strr   BuiltinVariabler   r   r~   r   force_unpack_var_sequencerZ   r   r    r   ry   rH   call_methodlistsr   rj   r   anyrR   rB   r0   __dict__r   	Exceptionr   r@   floatr`   r   OverflowError
ValueErrorr;   r}   operatorr]   rt   SymBoolSymFloatSymIntoutputcreate_proxybytescomplexroundrx   )rN   ri   r   r}   r%   arg_unpackedrA   	arg_constr   a
const_argskvconst_kwargsmethodrz   exc
add_targetopproxysearchresultr   rO   s                         @r   r   zConstantVariable.call_method   s    	,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Q/66r$**j7QRR 

E*tx/?TZZ.F#**6:+N+NOO$**(TW5E5E-ETZZ.F6'..vz/R\/RSS ;3t9>d1g6P6P6RI'..$**d1g&@&@&BC 
 ^#D	Q47;U;U;W:!W//1FI4::-'..v66 w"2tT6::m K& Cw*2tT6BBC$ @Q" 	?7&r4v>>	?  6(a"556 &z2 ,S	!#((^ 0 % Q0a"4<PPQ  6(a"556  I(a"4<HHI  I(a"4<HHIs   	T? T:$/T? :U+ >U U+ *U%U+ V #-V8 %W? Y  9Y, "Z- :T? ?UU U+ +V	V		V5V00V58W<*W77W<?	X=*X88X= 	Y)	Y$$Y),	Z*5*Z%%Z*-	[+6*[&&[+c           
        | 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   r/   ra   rZ   ry   _tree_map_fallbackr   
startswithr   rg   cloner0   r`   r   r   r   r   rt   dtyperH   call_tree_map)rN   ri   tree_map_fnmap_fnresttree_map_kwargsnone_is_leaf_varr   tree_map_moduleotherrO   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    )rN   ri   r   r   s       r   call_obj_hasattrz!ConstantVariable.call_obj_hasattrt  s+     T*))0088r"   c                     yr\   r   rQ   s    r   is_python_hashablez#ConstantVariable.is_python_hashable{  r^   r"   c                ,    t        | j                        S r   hashr   rQ   s    r   get_python_hashz ConstantVariable.get_python_hash~      DJJr"   c                    ddl m} t        ||      r!| j                         |j	                         k(  S t        |t
              xr! | j                         |j                         k(  S )Nr   r   )r   r   r0   rZ   evaluate_exprr   )rN   r   r   s      r   is_python_equalz ConstantVariable.is_python_equal  s[    +e_-**,0C0C0EEEuo. H'')U-E-E-GG	
r"   c                    | j                   S r   r   rQ   s    r   get_real_python_backed_valuez-ConstantVariable.get_real_python_backed_value  rS   r"   c                    t        | j                  t        t        f      r2t        j                  t        j                  | j                              S t        | %  |      S r   )
r0   r   r`   ra   r   r    r   indexrH   nb_index_impl)rN   ri   rO   s     r   r   zConstantVariable.nb_index_impl  sE     djj3+.#**8>>$**+EFFw$R((r"   c                R    t         j                  t        | j                              S r   )r   r    r`   r   r   s     r   nb_int_implzConstantVariable.nb_int_impl  s      &&s4::77r"   c                R    t         j                  t        | j                              S r   )r   r    r   r   r   s     r   nb_float_implzConstantVariable.nb_float_impl  s      &&uTZZ'899r"   )r   Nonereturnr   )r   ra   r   r   )r   r   r%   r   r   r   )r   r   r%   r   r   r   )r   r   )r   r   )r   zLiteral[True]r   ra   )rd   r   r   ra   )r   list[VariableTracker])ri   r   r*   r   r   r   )rn   objectr   ra   r   )rn   r   rr   zdict[int, object] | Noner   ra   )ri   zInstructionTranslator | Noner   r   )ri   r   r   r   )ri   r   r   r   r   r   )
ri   r   r   r   r}   r   r%   dict[str, VariableTracker]r   r   )ri   r   r   r   r   r   r   zSequence[VariableTracker]r   r   r   r   )ri   r   r   r   r   r   r   r`   r   r   r   ra   )r   r   )ri   r   r   r   )-rV   r   __qualname____doc__r`   r   r   r   ra   r@   r   _cpython_typer   staticmethodr    rI   rR   rX   rZ   r]   rb   re   rg   propertyrB   rl   rJ   rq   rj   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   __classcell__rO   s   @r   r   r       s*    %eT4:wS	RM4  44  4A  A-1 -1^ T3$" 1 1
'
.=
	
 2 2 	5 	5-.-	-E!!m;!m; m; $	m;
 +m; 
m;^2
!2
 *2
  	2

 (2
 42
 
2
h 9'9/29	9 9 
)) 
)88 
8:: 
:r"   r   TFc                  `     e Zd ZdZeZd
 fdZddZddZddZ	ddZ
ddZddZdd	Z xZS )FakeIdVariablea6  A compile-time-only id value that can be used as a dict key but cannot
    be reconstructed across graph breaks.

    When dynamo evaluates ``id(x)`` on a variable tracker that has no
    corresponding runtime object (e.g. a ``ConstDictVariable`` created during
    tracing), we mint a fake integer id.  This variable holds that id and
    supports the minimal interface needed to participate as a dict key
    (hashing and equality).  It intentionally blocks reconstruction so that a
    graph break does not silently bake a stale id into the resumed bytecode.
    c                2    t        |   di | || _        y )Nr   )rH   rI   r   rM   s      r   rI   zFakeIdVariable.__init__  s    "6"
r"   c                    | j                   S r   r   rQ   s    r   rZ   z!FakeIdVariable.as_python_constant  rS   r"   c                     yNFr   rQ   s    r   r]   z!FakeIdVariable.is_python_constant  s    r"   c                    t         S r   )r`   rQ   s    r   python_typezFakeIdVariable.python_type  s    
r"   c                     yr\   r   rQ   s    r   r   z!FakeIdVariable.is_python_hashable  r^   r"   c                ,    t        | j                        S r   r   rQ   s    r   r   zFakeIdVariable.get_python_hash  r   r"   c                j    t        |t        t        f      r| j                  |j	                         k(  S yr   )r0   r   r   r   rZ   )rN   r   s     r   r   zFakeIdVariable.is_python_equal  s-    en.>?@::!9!9!;;;r"   c                J    t        dt        | j                        ddg       y )Nz Reconstruction of FakeIdVariablezdA fake id produced by id() on a compile-time container cannot be reconstructed across a graph break.z<Avoid using id() on containers in code that may graph-break.)gb_typecontextexplanationhints)r   r   r   )rN   codegens     r   reconstructzFakeIdVariable.reconstruct  s)    6

O@ O
	
r"   )r   r`   r%   r   r   r   r   r   )r   r@   r   )r  r   r   r   )rV   r   r   r   r`   r   rI   rZ   r]   r   r   r   r   r  r   r   s   @r   r   r     s7    	 M 

r"   r   )&r   
__future__r   r   typingr   r   r   r   typing_extensionsr   rt   torch._dynamo.sourcer	   r   r   r   r   r   utilsr   r   r   r   baser   r   collections.abcr   torch._dynamo.symbolic_convertr   	functionsr   r   r,   r-   r.   r   r   r"   r   <module>r     s|    #  8 8 &  .  9 J J 3 (D/H: H:V *$/ )$/ *51 2
_ 2
r"   