
    ^jڔ                    V   d Z ddlm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 ddlmZ ddlZddl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 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% e$d      Z& e$d      Z' G d dejP                        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)Iterable)AnyLiteraloverloadTYPE_CHECKING)override)GetItemSource   )graph_break_hints	variables)raise_observed_exceptionunimplemented)common_constant_typesistypenpraise_args_mismatchunpack_iterable   )ValueMutationNewVariableTracker)InstructionTranslatorBase)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dAd
Zd@dZdBdZdCdZdDdZdEdZdDdZedFd       Z	 	 	 	 	 	 dGdZ	 	 	 	 	 	 dHdZ	 	 	 	 	 	 dI fdZedJd       ZedKdLd       Z	 	 	 	 dMdZdNdZ 	 	 	 	 	 	 	 	 dOdZ!dCdZ"dCdZ#dCdZ$dCdZ%	 	 	 	 	 	 dPdZ&dQ fdZ'dC fd Z(	 	 	 	 	 	 	 	 	 	 dR fd!Z)	 	 	 	 	 	 	 	 	 	 	 	 dS fd"Z*dAd#Z+e,	 	 	 	 	 	 dTd$       Z-dUd%Z.dV fd&Z/dWd'Z0	 	 	 	 dX fd(Z1	 	 	 	 dXd)Z2	 	 	 	 dXd*Z3	 	 	 	 	 	 	 	 	 	 	 	 dYd+Z4	 dZ	 	 	 	 	 	 	 d[d,Z5	 dZ	 	 	 	 	 	 	 d[d-Z6	 dZ	 	 	 	 	 	 	 d[d.Z7	 dZ	 	 	 	 	 	 	 d[d/Z8	 dZ	 	 	 	 	 	 	 d[d0Z9	 dZ	 	 	 	 	 	 	 d[d1Z:	 dZ	 	 	 	 	 	 	 d[d2Z;	 dZ	 	 	 	 	 	 	 d[d3Z<	 dZ	 	 	 	 	 	 	 d\d4Z=	 	 	 	 	 	 d]d5Z>	 dZ	 	 	 	 	 	 	 d[d6Z?	 dZ	 	 	 	 	 	 	 d[d7Z@	 	 	 	 dXd8ZA	 	 	 	 dXd9ZB	 dZ	 	 	 	 	 	 	 d[d:ZC	 	 	 	 dXd;ZD xZES )^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    k/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/torch/_dynamo/variables/constant.pycreatezConstantVariable.create8       14    c                     y r   r   r   s    r!   r"   zConstantVariable.create<   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              r[| j                  | j                  | j                  f}|D cg c]  }t        j                  |       }}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 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source)r)   )CONSTANT_VARIABLE_NONECONSTANT_VARIABLE_TRUECONSTANT_VARIABLE_FALSEget
isinstancesetr   r"   r   SetVariable	frozensetFrozensetVariableslicestartstopstepSliceVariablelisttuple	enumerater
   appendBaseListVariablecls_fortype)
r    r'   r)   xitems
slice_argsargslice_args_varsiitem_sources
             r!   r"   zConstantVariable.createD   s    111122H% eS!9>?A%,,Q/?E?((9&99y)9>?A%,,Q/?E?..u???u%++uzz5::>J8B614 '',6O 6 **?EfEEe}-E!%( 1:@mFA6d$++* ,  --55d5kB5SFSS000/ @ @6s   GG9Gc                    t        |   di | t        j                  |      st	        dt        |       d      t        0t        |t        j                        r|j                         | _
        y || _
        y )Nz6Cannot 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_literalAssertionErrorr>   r   r.   numberitemr    )selfr    r'   	__class__s      r!   rH   zConstantVariable.__init__v   sl    "6"//6 He V7 7  >j		:DJDJr$   c                    | j                   S r   r   rM   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__reprrP   s    r!   __repr__zConstantVariable.__repr__   s2    "4

#3#<#<"=RTZZ@P?QQRSSr$   c                    | j                   S r   r   rP   s    r!   as_python_constantz#ConstantVariable.as_python_constant   rR   r$   c                     yNTr   rP   s    r!   is_python_constantz#ConstantVariable.is_python_constant   s    r$   c                R    t         j                  t        | j                              S r   )r   r"   rV   r    rM   txs     r!   	repr_implzConstantVariable.repr_impl   s    &&tDJJ'788r$   c                B    t        | j                  t        t        f      S r   )r.   r    intboolrP   s    r!   is_symnode_likez ConstantVariable.is_symnode_like   s    $**sDk22r$   c                    | j                   |v S r   r   )rM   valuess     r!   is_constant_matchz"ConstantVariable.is_constant_match   s    zzV##r$   c                    | j                   d u S r   r   rP   s    r!   is_constant_nonez!ConstantVariable.is_constant_none   s    zzT!!r$   c                    	 | j                   D cg c]  }t        j                  |       c}S c c}w # t        $ r}t        |d}~ww xY w)zz
        Need this when adding a BaseListVariable and a ConstantVariable together.
        Happens in detectron2.
        N)r    r   r"   	TypeErrorNotImplementedError)rM   r?   es      r!   r@   zConstantVariable.items   sC    	-8<

C1$++A.CCC 	-%1,	-s    4 /4 4 	A	AA	c                    t        | j                  t        t        f      r.ddlm} t        | j                  t              rdnd} ||||      }t        j                  | j                  |j                                  S )Nr   )validate_sequence_indexstringbytes)	r.   r    strrq   object_protocolro   r   r"   rY   )rM   r_   rB   ro   container_names        r!   getitem_constzConstantVariable.getitem_const   sc     djj3,/@)3DJJ)DX'N)"c>BC&&JJs--/0
 	
r$   c                    |j                         }	 t        j                  | j                  |         S # t        $ r/}t        t        |t        |j                               Y d }~y d }~ww xY wNargs)rY   r   r"   r    
IndexErrorr   r8   ry   )rM   r_   keyindexrm   s        r!   sq_item_implzConstantVariable.sq_item_impl   s[     &&(	H#**4::e+<== 	H$Z$qvv,GG	Hs   !4 	A,%A''A,c                   t        | j                  t        t        t        t
        f      st        |   ||      S |j                         }|dk  rt        d|       |t        | j                        k\  rt        t        |       t        j                  | j                  |         t        j                  |dz         fS )Nr   zInvalid index r   )r.   r    rr   rq   r8   r9   rG   tp_iteritem_implrY   rJ   lenr   rz   r   r"   )rM   r_   r|   rD   rN   s       r!   r   z!ConstantVariable.tp_iteritem_impl   s    
 $**sE4&?@7+B66$$&q5 >!!566DJJ$Z4&&tzz!}57G7N7NqSTu7UUUr$   c                $    t        |       t        v S r   )r>   r   )objs    r!   rI   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).0r?   caches     r!   	<genexpr>z.ConstantVariable.is_literal.<locals>.<genexpr>   s     J'221e<Js    #)idr>   r8   r9   r/   r1   torchSizeallr   rI   )r   r   s    `r!   r   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   )rY   r   r"   rk   rl   )rM   r_   r?   rm   s       r!   unpack_var_sequencez$ConstantVariable.unpack_var_sequence   sH    	-8<8O8O8QR1$++A.RRR 	-%1,	-s!   8 38 8 	AAAc                0    t        | j                        dfS )zADynamo tracing rule for long_hash, float_hash, unicode_hash, etc.Fhashr    r^   s     r!   	hash_implzConstantVariable.hash_impl   s    DJJ&&r$   c                $    ddl m}  || |||      S )Nr   ) python_constant_richcompare_impl)rs   r   )rM   r_   otheropr   s        r!   richcompare_implz!ConstantVariable.richcompare_impl   s     	F/b%DDr$   c                R    t         j                  t        | j                              S r   )r   r"   rr   r    r^   s     r!   str_implzConstantVariable.str_impl   s    &&s4::77r$   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).rx   N)	r   r"   r   r    rk   r   r>   r8   ry   rM   r_   rm   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   r^   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 rw   )hasattrr    r   AttributeErrorgetattrcallablerl   )rM   r_   namemembers       r!   const_getattrzConstantVariable.const_getattr  sC     tzz4($^RtfET*F%%r$   c                ,   |j                         r4|j                         }	 || j                  v }t        j	                  |      S t        | -  ||      S # t
        $ r4}t        t        |      |t        |j                               Y d}~Hd}~ww xY w)z Sequence contains for constants.rx   N)r\   rY   r    r   r"   rk   r   r>   r8   ry   rG   sq_contains)rM   r_   rL   searchresultrm   rN   s         r!   r   zConstantVariable.sq_contains  s    ""$,,.F4::-'..v66 w"2t,,  (Gaff s   "A 	B*BBc                   ddl m} t        | j                  t              r>	  || j                  D cg c]  }t
        j                  |       c}t                     S t        | )  |      S c c}w # t        $ r Y w xY w)Nr   )ListIteratorVariable)mutation_type)listsr   r.   r    r   r   r"   r   rl   rG   tp_iter_impl)rM   r_   r   crN   s       r!   r   zConstantVariable.tp_iter_impl  sv    /djj(++9=DA%,,Q/D"2"4  w#B'' E ' s"   A4 A/A4 /A4 4	B ?B 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       t        ||d         }	 |D cg c]  }|j                          }}t        j                  | j                  j                  |            S t'        fd	|D              rKt
        j                  j                  || j)                         | j                        j%                  ||||      S 	 |D cg c]  }|j                          }	}|j+                         D 
ci c]  \  }
}|
|j                          }}
}|d
k(  r| j-                  |      S t/        | j                  t              rD|t        j0                  v r2t3        | j                  |      }	 t        j                   ||	i |      S t/        | j                  t:        t<        f      r0t?        | j                  |      r|s1|s/	 t        j                   t3        | j                  |                   S t?        tH        |      rt        |      dk(  ru|d   jK                         ra|	d   }t3        tH        |      }t/        |tL        jN                  tL        jP                  tL        jR                  f      r=|jT                  jW                  d|| j                  |fi       }j                  |||      S 	 t        j                   || j                  |            S t/        | j                  tX              r6|dk(  r1t3        | j                  |      }t        j                   ||	i |      S t9        | j                        tZ        u rD|tZ        j0                  v r2t3        | j                  |      }	 t        j                   ||	i |      S |dk(  r\t        |      dk(  rN|d   jK                         r;	 t        j                  t]        | j                  |d   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# t4        $ r}t7        t9        |      |       Y d }~d }~ww xY w# t@        tB        f$ r5}t7        t9        |      |tE        |jF                               Y d }~d }~ww xY w# t4        $ r5}t7        t9        |      |tE        |jF                               Y d }~pd }~ww xY w# t4        $ r }t7        t9        |      |       Y d }~d }~ww xY w# t4        $ r5}t7        t9        |      |tE        |jF                               Y d }~|d }~ww xY w)Nr   SymNodeVariableformatjoinz1 args and 0 kwargsz
 args and z kwargsr   c              3  6   K   | ]  }t        |        y wr   )r.   )r   r?   r   s     r!   r   z/ConstantVariable.call_method.<locals>.<genexpr>J  s     <!z!_-<s   __iter__rx   call_functiondecode	__round__)/tensorr   r   r    rr   r   BuiltinVariabler   r   r   r   r   rY   r   r"   r   rl   rG   call_methodanyrQ   r@   r   r.   __dict__r   	Exceptionr   r>   floatrb   r   OverflowError
ValueErrorr8   ry   operatorr\   r   SymBoolSymFloatSymIntoutputcreate_proxyrq   complexround)rM   r_   r   ry   r'   arg_unpackedr?   	arg_consta
const_argskvconst_kwargsmethodrm   exc
add_targetr   proxyr   rN   s                      @r!   r   zConstantVariable.call_method,  s"    	,8tzz3 7,,SZZ8FF 
 V^tzz3 7Ta#)4ykCK=@	 +2tAw7LC=IJQ113J	J'..tzzy/IJJ <t<<,,33DMMOTZZk"dD&12	?:>?Q!..0?J?BH,,.Q$!QAq3355QLQ :$$R((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 
 w"2tT6::S 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s   R) R$/R) /S 3S

S S:S S6 .-T! %U( V) 9W $R) )SS
S S32S36	T?TT!U%0*U  U%(	V&1*V!!V&)	W2WW	X*XX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-   rc   rY   rl   _tree_map_fallbackr   
startswithr   ri   cloner.   rb   r   r   rr   rq   r   dtyperG   call_tree_map)rM   r_   tree_map_fnmap_fnresttree_map_kwargsnone_is_leaf_varr   tree_map_moduler   rN   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                ,    t        | j                        S r   )rV   r    rM   codegens     r!   reconstruct_pycodez#ConstantVariable.reconstruct_pycode  s    DJJr$   c                l    t        | j                  |      }t        j                  j	                  |      S r   )r   r    r   r   r"   )rM   r_   r   r   s       r!   call_obj_hasattrz!ConstantVariable.call_obj_hasattr  s+     T*))0088r$   c                    ddl m} t        ||      r!| j                         |j	                         k(  S t        |t
              xr! | j                         |j                         k(  S )Nr   r   )r   r   r.   rY   evaluate_exprr   )rM   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                   | j                   du s| j                   du rt        | j                         S t        |   |      S )NTF)r    r   rG   get_id)rM   r_   rN   s     r!   r   zConstantVariable.get_id  sB    ::t!3tzzU7Jdjj>!
 w~b!!r$   c                    | j                   S r   r   rP   s    r!   get_real_python_backed_valuez-ConstantVariable.get_real_python_backed_value  rR   r$   c                    ddl m}  |t        | j                              r2t        j                  t        j                  | j                              S t        | %  |      S )Nr   )type_implements_nb_index)
rs   r   r>   r    r   r"   r   r|   rG   nb_index_impl)rM   r_   r   rN   s      r!   r   zConstantVariable.nb_index_impl  sG     	>#D$45#**8>>$**+EFFw$R((r$   c                R    t         j                  t        | j                              S r   )r   r"   rb   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$   c                .    |t        | j                              st        j                  t              S |j                         st        j                  t              S |r|| fn| |f\  }}|j                         |j                         }	}	  |||	      }

t        u rt        j                  t              S t        j                  ||
      S # t        t        t        f$ r4}t        t        |      |t        |j                               Y d }~zd }~ww xY wrw   )r>   r    r   r"   NotImplementedr\   rY   rk   r   r   r   r8   ry   r   build)rM   r_   r   r   
type_checkreverseself_other_r   wr   rm   s               r!   _nb_binary_implz ConstantVariable._nb_binary_impl  s     $tzz*+#**>::'')#**>::)0tUmv'')6+D+D+F1	E1XF ^##**>::$$R00	 :}5 	E$T!WbtAFF|DD	Es   	C D *DDc                T    ddl m} | j                  ||t        j                  ||      S )Nr   )type_implements_nb_lshift)rs   r
  r  r   lshift)rM   r_   r   r  r
  s        r!   nb_lshift_implzConstantVariable.nb_lshift_impl  *     	?##x(A7
 	
r$   c                T    ddl m} | j                  ||t        j                  ||      S )Nr   )type_implements_nb_rshift)rs   r  r  r   rshift)rM   r_   r   r  r  s        r!   nb_rshift_implzConstantVariable.nb_rshift_impl+  r  r$   c                   t        | j                  t        t        f      st        j                  t              S |j                         st        j                  t              S |r|| fn| |f\  }}|j                         |j                         }}	 t        j                  |||z        S # t        t        t        t        f$ r4}t        t!        |      |t#        |j$                               Y d }~y d }~ww xY wrw   )r.   r    rb   r   r   r"   r  r\   rY   r   r  rk   r   ZeroDivisionErrorr   r   r>   r8   ry   	rM   r_   r   r  r  r  r   r  rm   s	            r!   nb_floor_divide_implz%ConstantVariable.nb_floor_divide_impl9  s     $**sEl3#**>::'')#**>::)0tUmv'')6+D+D+F1	E"((Q!V44:'8-H 	E$T!WbtAFF|DD	Es   B* *C7*C22C7c                   t        | j                  t        t        t        f      st
        j                  t              S |j                         st
        j                  t              S |r|| fn| |f\  }}|j                         |j                         }}	 t        j                  |||z        S # t        t        t        t        f$ r4}t!        t#        |      |t%        |j&                               Y d }~y d }~ww xY wrw   )r.   r    rb   r   r   r   r"   r  r\   rY   r   r  rk   r   r  r   r   r>   r8   ry   r  s	            r!   nb_true_divide_implz$ConstantVariable.nb_true_divide_implN  s     $**sE7&;<#**>::'')#**>::)0tUmv'')6+D+D+F1	E"((QU33:'8-H 	E$T!WbtAFF|DD	Es   B/ /C<*C77C<c                   t        | j                  t        t        t        t
        t        f      st        j                  t              S |j                         st        j                  t              S |r|| fn| |f\  }}|j                         |j                         }}	 t        j                  |||z        S # t        t        t         t"        f$ r4}t%        t'        |      |t)        |j*                               Y d }~y d }~ww xY wrw   )r.   r    rb   r   rr   rq   	bytearrayr   r"   r  r\   rY   r   r  rk   r   r  r   r   r>   r8   ry   r  s	            r!   nb_remainder_implz"ConstantVariable.nb_remainder_implc  s     $**sE3y&IJ#**>::'')#**>::)0tUmv'')6+D+D+F1	E"((QU33:'8-H 	E$T!WbtAFF|DD	Es    B9 9D*DDc                   t        | j                  t        t        f      st        j                  t              S |j                         st        j                  t              S |r|| fn| |f\  }}|j                         |j                         }}	 t        j                  |t        ||            S # t        t        t        t        f$ r4}t!        t#        |      |t%        |j&                               Y d }~y d }~ww xY wrw   )r.   r    rb   r   r   r"   r  r\   rY   r   r  divmodrk   r   r  r   r   r>   r8   ry   r  s	            r!   nb_divmod_implzConstantVariable.nb_divmod_imply  s     $**sEl3#**>::'')#**>::)0tUmv'')6+D+D+F1	E"((VAq\:::'8-H 	E$T!WbtAFF|DD	Es   B1 1C>
*C99C>c                T    ddl m} | j                  ||t        j                  ||      S )Nr   )type_implements_nb_or)rs   r  r  r   or_)rM   r_   r   r  r  s        r!   
nb_or_implzConstantVariable.nb_or_impl  s*     	;##x||%:G
 	
r$   c                T    ddl m} | j                  ||t        j                  ||      S )Nr   )type_implements_nb_subtract)rs   r#  r  r   sub)rM   r_   r   r  r#  s        r!   nb_subtract_implz!ConstantVariable.nb_subtract_impl  s+     	A##x||%@'
 	
r$   c                .   ddl m} |j                         st        j	                  t
              S |j                         }t        |t        t        t        f      st        j	                  t
              S | j                  ||t        j                  ||      S )Nr   )type_implements_nb_multiply)rs   r'  r\   r   r"   r  rY   r.   rb   r   r   r  r   mul)rM   r_   r   r  r'  	other_vals         r!   nb_multiply_implz!ConstantVariable.nb_multiply_impl  sz     	A'')#**>::,,.	 )c5'%:;#**>::##x||%@'
 	
r$   c                J   t        | j                  t        t        f      st	        d      |j                         }	 t        j                  | j                  |z        S # t        t        f$ r4}t        t        |      |t        |j                               Y d }~y d }~ww xY w)Nz'Expected str or bytes in sq_repeat_implrx   )r.   r    rr   rq   rJ   rY   r   r"   MemoryErrorr   r   r>   r8   ry   )rM   r_   countnrm   s        r!   sq_repeat_implzConstantVariable.sq_repeat_impl  s     $**sEl3 !JKK$$&	E#**4::>::]+ 	E$T!WbtAFF|DD	Es   !A B".*BB"c                T    ddl m} | j                  ||t        j                  ||      S )Nr   )type_implements_nb_and)rs   r1  r  r   and_)rM   r_   r   r  r1  s        r!   nb_and_implzConstantVariable.nb_and_impl  s*     	<##x}}&<g
 	
r$   c                T    ddl m} | j                  ||t        j                  ||      S )Nr   )type_implements_nb_xor)rs   r5  r  r   xor)rM   r_   r   r  r5  s        r!   nb_xor_implzConstantVariable.nb_xor_impl  *     	<##x||%;W
 	
r$   c                B    t         j                  | j                         S r   r   r"   r    r^   s     r!   nb_negative_implz!ConstantVariable.nb_negative_impl        &&

{33r$   c                B    t         j                  | j                        S r   r:  r^   s     r!   nb_positive_implz!ConstantVariable.nb_positive_impl  r<  r$   c                T    ddl m} | j                  ||t        j                  ||      S )Nr   )type_implements_nb_add)rs   r@  r  r   add)rM   r_   r   r  r@  s        r!   nb_add_implzConstantVariable.nb_add_impl  r8  r$   c                    	 t         j                  t        | j                              S # t        $ r/}t        t        |t        |j                               Y d }~y d }~ww xY wrw   )r   r"   absr    r   r   r8   ry   r   s      r!   nb_absolute_implz!ConstantVariable.nb_absolute_impl!  sJ    	K#**3tzz?;; 	K$]BT!&&\JJ	Ks   '* 	A"%AA")r    Nonereturnr   )r    rc   rG  r   )r    r   r'   r   rG  r   )r    r   r'   r   rG  rF  )rG  r   )rG  rr   )rG  zLiteral[True])r_   r   rG  r   rG  rc   )rf   r   rG  rc   )rG  list[VariableTracker])r_   r   rB   r   rG  r   )r_   r   r{   r   rG  r   )r_   r   r|   r   rG  z'tuple[VariableTracker, VariableTracker])r   objectrG  rc   r   )r   rJ  r   zdict[int, object] | NonerG  rc   )r_   z InstructionTranslatorBase | NonerG  rI  )r_   r   rG  tuple[int, bool])r_   r   r   r   r   rr   rG  r   )r_   r   r   rr   rG  r   )r_   r   rL   r   )
r_   r   r   rr   ry   rI  r'   dict[str, VariableTracker]rG  r   )r_   r   r   r   r   r   r   rI  r   rL  rG  r   )r_   r   r   rr   rG  r   r   rJ  rG  rc   )r_   r   rG  z
int | None)rG  rJ  )r_   r   rG  r   )r_   r   r   r   r   r   r  r   r  rc   rG  r   )F)r_   r   r   r   r  rc   rG  r   )r_   r   r   r   r  rc   rG  r   )r_   r   r-  r   rG  r   )FrU   r   __qualname____doc__rb   r   rr   rq   rc   r>   r   _cpython_typer   staticmethodr"   rH   rQ   rW   rY   r\   r`   rd   rg   ri   propertyr@   ru   r}   r   rI   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r	   r   r   r   r   r   r   r   r  r  r  r  r  r  r  r!  r%  r*  r/  r3  r7  r;  r>  rB  rE  __classcell__rN   s   @r!   r   r   &   s    %eT4:wS	RM4  44  4A  A/1 /1b"T93$" - -

+

2A

	

H+H2AH	HV+V4CV	0V 2 2 	5 	5-2-	-'E+E4CEILE	E8E!!+36	-(b;%b; b; $	b;
 +b; 
b;H2
%2
 *2
  	2

 $2
 42
 
2
h  9+9369	9 9
"
)
) 

)88 
8:: 
:11 1 	1
 1 1 
1< 	

 
 	

 

$ 	

 
 	

 

$ 	EE E 	E
 
E2 	EE E 	E
 
E2 	EE E 	E
 
E4 	EE E 	E
 
E2 	

 
 	

 

* 	

 
 	

 

( 	
%
 
 	

 

8E%E E 
	E, 	

 
 	

 

( 	

 
 	

 

 44 
444 
4 	

 
 	

 

 KK 
Kr$   r   TFc                      e Zd ZdZdZy)FakeValueKindr   r   N)rU   r   rN  IDHASHr   r$   r!   rV  rV  6  s    	BDr$   rV  c                       e Zd ZdZeZdhej                  Zej                  d	 	 	 	 	 	 	 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 )FakeIdVariablea  A compile-time-only id or hash value that can be used as a dict key but
    cannot be reconstructed across graph breaks.

    When dynamo evaluates ``id(x)`` or ``hash(x)`` on a variable tracker that
    has no corresponding runtime object, we mint a fake integer.  The ``kind``
    field tracks which builtin produced the value so that same-kind comparisons
    (e.g. ``id(a) != id(b)``) can be resolved at compile time while cross-kind
    comparisons graph-break.
    kind)r[  c               @    t        |   di | || _        || _        y )Nr   )rG   rH   r    r[  )rM   r    r[  r'   rN   s       r!   rH   zFakeIdVariable.__init__N  s#     	"6"
	r$   c                    | j                   S r   r   rP   s    r!   rY   z!FakeIdVariable.as_python_constantU  rR   r$   c                     yNFr   rP   s    r!   r\   z!FakeIdVariable.is_python_constantX  s    r$   c                    t         S r   )rb   rP   s    r!   python_typezFakeIdVariable.python_type[  s    
r$   c                0    t        | j                        dfS r[   r   r^   s     r!   r   zFakeIdVariable.hash_impl^  s    DJJ%%r$   c                   t        |t              ri| j                  |j                  k(  rP|dv rL|dk(  r| j                  |j                  k(  n| j                  |j                  k7  }t        j                  |      S t        dd| j                   d| dt        |      j                   ddgt        j                  	       y )
N)__eq____ne__rd  z0Comparison on compile-time-only id or hash valuezFakeIdVariable(z)  zYCannot compare a compile-time-only id() or hash() value. The comparison will run eagerly.zbAvoid comparing id() or hash() of objects created inside the compiled region against other values.gb_typecontextexplanationhints)r.   rZ  r[  r    r   r"   r   r>   rU   r   SUPPORTABLE)rM   r_   r   r   r   s        r!   r   zFakeIdVariable.richcompare_impla  s     un-		UZZ'** > u{{*jjEKK/ 
 $**622F%djj\B4qe9M9M8NO6< #..
	
r$   c                j    t        |t        t        f      r| j                  |j	                         k(  S yr_  )r.   rZ  r   r    rY   )rM   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.rg  )r   rr   r    r   s     r!   reconstructzFakeIdVariable.reconstruct  s)    6

O@ O
	
r$   )r    rb   r[  rV  r'   r   rG  rF  )rG  rb   rH  )rG  r>   )r_   r   rG  rK  )r_   r   r   r   r   rr   rG  r   rM  )r   r   rG  rF  )rU   r   rN  rO  rb   rP  r   _nonvar_fieldsrV  rW  rH   rY   r\   ra  r   r   r   ro  rS  rT  s   @r!   rZ  rZ  ;  s     M 			'	'N 4A3C3C#0OR	&

-
36
	
4

r$   rZ  )+rO  
__future__r   enumr   collections.abcr   typingr   r   r   r   typing_extensionsr	   r   torch._dynamo.sourcer
   r   r   r   r   r   r   utilsr   r   r   r   r   baser   r   torch._dynamo.symbolic_convertr   	functionsr   r   r*   r+   r,   EnumrV  rZ  r   r$   r!   <module>r|     s    #   $ 8 8 &  . + 9  4 H/HK HKV *$/ )$/ *51 DII 
P
_ P
r$   