
    9jh)                        d dl mZ d dlZd dlZd dlZd dlmZmZ ddl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      Z G d dee      Z G d de      Z G d d      Z	 	 	 	 ddZddZ e        y)    )annotationsN)AnyTYPE_CHECKING   )is_function_or_wrapper   )VariableTrackerVariableTrackerMeta)Callable)Self)SymNodeVariablec                       e Zd ZdZddZddZy)	LazyCachez+Container to cache the real VariableTrackerc                d    t        |t              s|sJ || _        || _        d | _        d | _        y N)
isinstanceLazySymNodeFormatStringvaluesource	name_hintvt)selfr   r   s      \/media/conek/DATA/Code/OCR/venv/lib/python3.12/site-packages/torch/_dynamo/variables/lazy.py__init__zLazyCache.__init__   s0    %!89M6
%)*.    c                   | j                   J ddlm} ddlm} |j                         }t        | j                  t              r,|j                  j                  || j                        | _         n3 |j                  || j                  d      | j                        | _         | j                  %| j                   j                  | j                         | `| `| `y )Nr   InstructionTranslatorr   )builderFallow_lazy_constant)r   symbolic_convertr    r   
current_txr   r   r   SourcelessBuildercreateVariableBuilderr   r   set_name_hint)r   r   r   txs       r   realizezLazyCache.realize   s    ww<"--/djj"9://66r4::FDG
g--DKKU . jjDG >>%GG!!$..1JKNr   N)r   r   r   r   returnNoner+   r,   )__name__
__module____qualname____doc__r   r*    r   r   r   r      s    5/r   r   c                      e Zd ZdZdZdhej                  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ddZd dZd!dZej(                  ZeZe	 d"dd	 	 	 	 	 	 	 d#d       ZddZddZddZ xZS )$LazyVariableTrackera  
    A structure that defers the creation of the actual VariableTracker
    for a given underlying value until it is accessed.

    The `realize` function invokes VariableTracker.build() to produce the real object.
    Once a LazyVariableTracker has been realized, internal bookkeeping will
    prevent double realization.

    This object should be utilized for processing containers, or objects that
    reference other objects where we may not want to take on creating all the
    VariableTrackers right away.
    T_cachec                `   t        |       t        j                  v rt        j                  | |fi |S |c|saddlm} |j                         }|I|j                  j                  }|j                  |      }||S t        t        | |      |      }|||<   |S t        t        | |      fd|i|S )Nr   r   )r   r   )typeLazyConstantVariablesupported_typesr&   r"   r   r$   outputvariable_tracker_cachegetr4   r   )r   r   optionsr   r)   cachecachedr   s           r   r&   zLazyVariableTracker.createI   s    ;.>>>'..ufHHH g@&113B~		886*%!M(5&)A&Q "f	"9UF#;VFVgVVr   c                V    t        |t              sJ t        |   di | || _        y )Nr2   )r   r   superr   r5   )r   r5   kwargs	__class__s      r   r   zLazyVariableTracker.__init__^   s*    &),,,"6"r   c                    | j                   j                  2| j                   j                          | j                   j                  J | j                   j                  S )z.Force construction of the real VariableTracker)r5   r   r*   r   s    r   r*   zLazyVariableTracker.realizec   sB    ;;>>!KK!;;>>---{{~~r   c                J    t         j                  || j                               S )zNCheck isinstance after realizing, used by ImplicitRealizingVariableTrackerMeta)r7   __instancecheck__r*   )r   clss     r   lazy_isinstancez#LazyVariableTracker.lazy_isinstancej   s    %%c4<<>::r   c                    | j                         r.| j                  j                  J | j                  j                  S | S )z4Return the real VariableTracker if it already exists)is_realizedr5   r   rE   s    r   unwrapzLazyVariableTracker.unwrapn   s5    ;;>>---;;>>!r   c                2    | j                   j                  d uS r   )r5   r   rE   s    r   rK   zLazyVariableTracker.is_realizedu   s    {{~~T))r   c                   |j                  d| j                        | j                  u sJ |j                  d| j                        | j                  ur| j                          t	        j
                  | j                         fi |S )Nr5   r   )r<   r5   r   r*   r	   clonerL   )r   rB   s     r   rO   zLazyVariableTracker.clonex   sc    zz(DKK0DKK???::h,DKK?LLN$$T[[]=f==r   c                d    | j                         rJ t        | j                  j                        S r   )rK   r7   r5   r   rE   s    r   	peek_typezLazyVariableTracker.peek_type~   s)    ##%%%DKK%%&&r   c                R    | j                         rJ | j                  j                  S r   rK   r5   r   rE   s    r   
peek_valuezLazyVariableTracker.peek_value   s$    ##%%%{{   r   c                    | j                         r&| j                  j                  j                  |       y || j                  _        y r   )rK   r5   r   r(   r   )r   names     r   r(   z!LazyVariableTracker.set_name_hint   s0    KKNN((.$(DKK!r   c                    d}| j                         r"|dt        | j                                dz  }|S |d| j                          dz  }|S )NzLazyVariableTracker(z
realized: )zunrealized: )rK   reprrL   rQ   )r   variable_infos     r   __str__zLazyVariableTracker.__str__   s]    .z$t{{}*=)>a@@M  |DNN,<+=Q??Mr   c                6    t        | j                         |      S r   getattrr*   )r   items     r   __getattr__zLazyVariableTracker.__getattr__   s    t||~t,,r   Fr    c          
     
    i t        |      }|v r|   d   S t        |      }t        |t              r=xr t	        |t
              }|r|}n j                  |j                               }nt        |t              rH|}||f|<   |j                  }|j                  }	|D ]!  }
|
|	vs j                  ||
         ||
<   # n|t        u r"|D cg c]  } j                  |       }}nx|t        u rt         fd|D              }nY|t        t        j                  fv r?t        |j!                               D ci c]  \  }}| j                  |       }}}n|}||f|<   |S c c}w c c}}w )zP
        Walk an object and realize all LazyVariableTrackers inside it.
        r   r    c              3  F   K   | ]  }j                  |         yw)r    N)realize_all).0vr!   r>   rH   s     r   	<genexpr>z2LazyVariableTracker.realize_all.<locals>.<genexpr>   s)       5>QRs   !)idr7   
issubclassr4   r   r8   rc   r*   r	   __dict___nonvar_fieldslisttupledictcollectionsOrderedDictitems)rH   r   r>   r!   idx	value_cls	keep_lazyresult
value_dictnonvarskeyre   ks   ` ``         r   rc   zLazyVariableTracker.realize_all   s    =Ei%<:a= K	i!45+W
5BV0WIMMOU@S )  	?3F %E#JJ**G! g%&)oo"3DW '6 'JsO
 $  5>QRF  %  F 4!8!899 !/Aq 3??1eAT?UUF 
 F e_c
's   E:E?c                    dd| j                         rJ | j                  j                  }t        |t              rt        fd|D              S  |      S )Nc                |    t        j                  |       xs& t        t        |       t              xs t	        |       S r   )inspect	isbuiltinrh   r7   r   )r   s    r   _helperz0LazyVariableTracker.is_hashable.<locals>._helper   s7     !!%( 1d5k401)%0r   c              3  .   K   | ]  } |        y wr   r2   )rd   re   r}   s     r   rf   z2LazyVariableTracker.is_hashable.<locals>.<genexpr>   s     1awqz1s   )r   r   r+   bool)rK   r5   r   r   rl   all)r   r   r}   s     @r   is_hashablezLazyVariableTracker.is_hashable   sP    	 ##%%%!!eU#15111u~r   c                R    | j                         rJ | j                  j                  S r   rS   rE   s    r   original_valuez"LazyVariableTracker.original_value   s$    ##%%%{{   r   c                R    | j                         rJ | j                  j                  S r   )rK   r5   r   rE   s    r   original_sourcez#LazyVariableTracker.original_source   s$    ##%%%{{!!!r   )r   r   r   r   r=   r   r+   r	   )r5   r   rB   r   r+   r,   )r+   r	   )rH   r7   r+   r   )r+   zVariableTracker | Self)r+   r   )rB   r   r+   r	   )r+   z	type[Any])r+   r   )rV   strr+   r,   r+   r   )r_   r   r+   r   r   )r   r   r>   z!dict[int, tuple[Any, Any]] | Noner!   r   r+   r   )r.   r/   r0   r1   _no_implicit_realizer	   rj   staticmethodr&   r   r*   rI   rL   rK   rO   rQ   rT   r(   r[   r`   visit__repr__classmethodrc   r   r   r   __classcell__)rC   s   @r   r4   r4   7   s      @!?!?@NW W(
;*>'!)- !!EH 48;
 %*;; 1;
 "; 
; ;z$!
"r   r4   )	metaclassc                  >    e Zd ZdZeeeefZe		 	 	 	 	 	 	 	 dd       Z
y)r8   aU  
    A lazy variable tracker for constants (int, float, bool, str) that defers
    guarding until the value is actually used in a way that requires it.

    This allows constants that are just passed through (e.g., returned without
    being used in control flow or math) to avoid unnecessary recompilation when
    their values change.
    c                l    t        |       t        j                  v sJ t        t        | |      fd|i|S )Nr   )r7   r8   r9   r   )r   r   r=   s      r   r&   zLazyConstantVariable.create  s9     E{2BBBBB#IeV$<WVWwWWr   N)r   r   r   r   r=   r   r+   r8   )r.   r/   r0   r1   intfloatr   r   r9   r   r&   r2   r   r   r8   r8      sS     E4-OXXX X 
	X Xr   r8   c                  (    e Zd Z	 	 	 	 	 	 ddZddZy)r   c                r    ddl m} || _        |j                  d|j	                         z   dz         | _        y )Nr   )ConstantVariablez{:})constantr   sym_node_varr&   as_python_constantfmt_var)r   sym_node_variablefmt_spec_varr   s       r   r   z LazySymNodeFormatString.__init__  s7     	/-'..<2244s:
r   c                    t         j                  | j                  j                         t        | j                  j                                     S r   )r   formatr   r   r   evaluate_exprrE   s    r   r   z LazySymNodeFormatString.__repr__  s:    zzLL++-!!//12
 	
r   N)r   r   r   r	   r+   r,   r   )r.   r/   r0   r   r   r2   r   r   r   r     s$    
!0
@O
	

r   r   c                p     t        j                  t        t                     	 	 	 	 	 	 	 	 d fd       }|S )Nc                D     t        | j                               |i |S r   r]   )r   argsrB   rV   s      r   realize_and_forwardz8_create_realize_and_forward.<locals>.realize_and_forward"  s$     -wt||~t,d=f==r   )r   r4   r   r   rB   r   r+   r   )	functoolswrapsr^   r	   )rV   r   s   ` r   _create_realize_and_forwardr     sO     __W_d34>!>*->9<>	> 5>
 r   c                     t         j                  j                         D ]>  \  } }| t        j                  vst	        |      s%t        t        | t        |              @ y r   )r	   ri   rp   r4   callablesetattrr   )rV   r   s     r   	_populater   +  sO    &//557 Ve*333+T3Nt3TUVr   )rV   r   r+   z.Callable[[LazyVariableTracker, Any, Any], Any]r-   )
__future__r   rn   r   r{   typingr   r   utilsr   baser	   r
   collections.abcr   typing_extensionsr   tensorr   r   r4   r8   r   r   r   r2   r   r   <module>r      s    "    % * 6 (&'! !H}"/5H }"@X. X,
 
$	
	3	V 
r   