tjL.ddlmZddlZddlZddlZddlmZmZddlm Z ddl m Z ddl m Z mZmZerdd lmZdd lmZdd lmZdd lmZGd dZGddeeZGddeZGddZddZddZedS)) annotationsN)Any TYPE_CHECKING)config)is_function_or_wrapper)SourceLocationVariableTrackerVariableTrackerMeta)Callable)Self)InstructionTranslatorBaseSymNodeVariablec"eZdZdZd dZd dZd S) LazyCachez+Container to cache the real VariableTrackervaluersourcereturnNonect|ts|std||_||_d|_d|_d|_dS)Nz9source is required for non-LazySymNodeFormatString values) isinstanceLazySymNodeFormatStringAssertionErrorrr name_hintsource_locationvt)selfrrs Z/var/www/html/CA-Chatbot/venv/lib/python3.11/site-packages/torch/_dynamo/variables/lazy.py__init__zLazyCache.__init__s\%!899  $O  %)6:*.c|jtdddlm}ddlm}|}t|jtr&|j ||j|_n0| ||j d|j|_|j|j|j|j+|jj|j|j|`|` |`|`dS)Nz0LazyCache.realize() called but vt is already setr)InstructionTranslatorr )builderFallow_lazy_constant)rrsymbolic_convertr$r% current_txrrrSourcelessBuildercreateVariableBuilderrr set_name_hintrset_source_location)rr$r%txs r realizezLazyCache.realize$s" 7  !STT T<<<<<< " - - / / dj"9 : : /66r4:FFDGG g--DKU.jDG > % G ! !$. 1 1 1   +0G0O G ' '(< = = = J K N  r"N)rrrrrrrr)__name__ __module__ __qualname____doc__r!r1r"r rrsB55 / / / /!!!!!!r"rceZdZdZdZdhejZeddd2dZd3fd Z d4dZ d5dZ d6dZ d7dZ d8dZd9dZd:dZd;d!Zdd'Zd?d(ZejZeZe d@d)d*dAd.Zd7d/Zd:d0Zd:d1ZxZS)BLazyVariableTrackera 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_cacheN)r0rrrr0 InstructionTranslatorBase | Noneoptionsrr c :t|tjvrtj||fi|S|O|M|sK|jj}||}||Stt|||}|||<|Stt||fd|i|S)N)rr) typeLazyConstantVariablesupported_typesr,outputvariable_tracker_cachegetr9r)rrr0r<cachecachedrs r r,zLazyVariableTracker.createTs ;;.> > >'.ufHHHH H >f00I4EYYv&&F! $Yuf%=%=fMMMBE&MI"9UF#;#;VVFVgVVVr"rkwargsrc t|ts$tdt|jt jdi|||_dS)Nz)_cache must be a LazyCache instance, got r7)rrrr>r3superr!r:rr:rF __class__s r r!zLazyVariableTracker.__init__kse&),,  SDLL ! K   ! ! !{~%$%IJJJ{~r"clsr>boolc\t||S)zNCheck isinstance after realizing, used by ImplicitRealizingVariableTrackerMeta)r>__instancecheck__r1)rrMs r lazy_isinstancez#LazyVariableTracker.lazy_isinstance{s %%c4<<>>:::r"VariableTracker | Selfc||r'|jjtd|jjS|S)z4Return the real VariableTracker if it already existsNz*is_realized() returned True but vt is None) is_realizedr:rrrLs r unwrapzLazyVariableTracker.unwraps>      "{~%$%QRRR;> ! r"c|jjduSN)r:rrLs r rTzLazyVariableTracker.is_realizeds{~T))r"c |d|j|jurtd|d|j|jur|t j|fi|S)Nr:z8cannot clone LazyVariableTracker with a different _cacher)rCr:rrr1r clonerU)rrFs r rYzLazyVariableTracker.clones ::h , ,DK ? ? J  ::h , ,DK ? ? LLNNN$T[[]]==f===r" type[Any]cz|rtdt|jjS)Nz=peek_type() called on an already realized LazyVariableTracker)rTrr>r:rrLs r peek_typezLazyVariableTracker.peek_types@       O DK%&&&r"c`|rtd|jjS)Nz>peek_value() called on an already realized LazyVariableTrackerrTrr:rrLs r peek_valuezLazyVariableTracker.peek_values8       P {  r"namestrc|r!|jj|dS||j_dSrW)rTr:rr.r)rr`s r r.z!LazyVariableTracker.set_name_hintsD      ) KN ( ( . . . . .$(DK ! ! !r"rr c||_|r!|jj|dS||j_dSrW)rrTr:rr/)rrs r r/z'LazyVariableTracker.set_source_locationsL.      : KN . . ? ? ? ? ?*9DK ' ' 'r"cd}|r)|dt|dz }n|d|dz }|S)NzLazyVariableTracker(z realized: )z unrealized: )rTreprrUr\)r variable_infos r __str__zLazyVariableTracker.__str__sj.      @ @$t{{}}*=*=@@@ @MM ?DNN,<,<??? ?Mr"itemcFt||SrWgetattrr1)rris r __getattr__zLazyVariableTracker.__getattr__st||~~t,,,r"ctS)aReturn the VariableTracker type to use for builtin handler dispatch. For regular LazyVariableTracker (not LazyConstantVariable), we return LazyVariableTracker itself so that _make_handler knows it needs to realize the arguments before calling the handler. LazyConstantVariable overrides this to return ConstantVariable since it can stay lazy. )r9rLs r get_handler_type_for_dispatchz1LazyVariableTracker.get_handler_type_for_dispatchs #"r"Fr&rD!dict[int, tuple[Any, Any]] | Noner'cit|}|vr|dSt|}t|trHot |t }|r|}n |}nt|trB|}||f|<|j }|j } |D]'} | | vr!|| || <(n|turfd|D}nn|turtfd|D}nG|ttjfvr0fdt|D}n|}||f|<|S)zP Walk an object and realize all LazyVariableTrackers inside it. Nrr&c@g|]}|Sr& realize_all.0vr'rDrMs r z3LazyVariableTracker.realize_all..s<5>QRRr"c3HK|]}|VdS)r&Nrtrvs r z2LazyVariableTracker.realize_all..sJ5>QRRr"cHi|]\}}||Srsrt)rwkrxr'rDrMs r z3LazyVariableTracker.realize_all..sBAq3??1eAT?UUr")idr> issubclassr9rr?rur1r __dict___nonvar_fieldslisttupledict collections OrderedDictitems) rMrrDr'idx value_cls keep_lazyresult value_dictnonvarskeys ` `` r ruzLazyVariableTracker.realize_alls =Eii %<<:a= KK i!4 5 5% +W 5BV0W0WI MMOOU@S) ? 3 3 F %E#JJ*G!  g%%&)oo"3DW'6''JsO  $  FF%  FF4!89 9 9 //FF Fe_c  r"cdd|rtd|jj}t |t rt fd|DS|S) NrrrrNctj|p0tt|tpt |SrW)inspect isbuiltinrr>r)rs r _helperz5LazyVariableTracker.is_hashable_lazy.._helper s?!%((1d5kk4001)%00 r"z?is_hashable() called on an already realized LazyVariableTrackerc3.K|]}|VdSrWr7)rwrxrs r r{z7LazyVariableTracker.is_hashable_lazy..s+11awwqzz111111r")rrrrN)rTrr:rrrall)rrrs @r is_hashable_lazyz$LazyVariableTracker.is_hashable_lazys           Q  ! eU # # 21111511111 1wu~~r"c`|rtd|jjS)NzBoriginal_value() called on an already realized LazyVariableTrackerr^rLs r original_valuez"LazyVariableTracker.original_values8       T {  r"c`|rtd|jjS)NzCoriginal_source() called on an already realized LazyVariableTracker)rTrr:rrLs r original_sourcez#LazyVariableTracker.original_source#s8       U {!!r") rrrrr0r;r<rrr r:rrFrrrrr rMr>rrN)rrRrrN)rFrrr )rrZ)rr)r`rarr)rr rrrra)rirarrrr>rW)rrrDrpr'rNrr)r3r4r5r6_no_implicit_realizer r staticmethodr,r!r1rQrUrTrYr\r_r.r/rhrmrovisit__repr__ classmethodrurrr __classcell__rJs@r r9r9Bs   @!?@N 04 WWWWW\W,;;;;****>>>>''''!!!!)))) ::::----####  !EH48; %* ;;;;;[;z*!!!!""""""""r"r9) metaclassceZdZdZeeeefZdddhe j Z e dd Z dfd Z ddZd fd Zd!fd Zd"dZd"dZd#dZd!dZd$fd ZxZS)%r?az 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. Guards are installed lazily: - TYPE_MATCH guard is installed when type-based methods (python_type, is_tensor, lazy_isinstance) are called - CONSTANT_MATCH guard is installed on full realization (e.g., used in control flow or math), which subsumes any TYPE_MATCH guard _type_guard_installed_type_guard_ref _handler_typerrrr<rr c ,ddlm}ddlm}t |t jvr%tdt |jd|td||r|j |fd|i|St t||fd|i|S) Nr)is_constant_sourcer ConstantVariablezunsupported type z for LazyConstantVariablez0source must not be None for LazyConstantVariabler) rrconstantrr>r?r@rr3r,r)rrr<rrs r r,zLazyConstantVariable.createDs 0/////...... ;;2B B B SDKK$8SSS  > !STT T  f % % L*#*5KKK7KK K#IeV$<$<WWVWwWWWr"r:rrFrc ftj|fi|d|_d|_d|_dSNF)rHr!rrrrIs r r!zLazyConstantVariable.__init__[s@**6***%*"$(*.r"c|js|rdSddlm}m}|jt d|j|j}||d|_||_ dS)zCInstall TYPE_MATCH guard if not already installed and not realized.Nr GuardBuilder install_guardz2source must not be None when installing type guardT) rrTguardsrrrr make_guard TYPE_MATCHr)rrrguards r _ensure_type_guardz'LazyConstantVariable._ensure_type_guardas  % )9)9););  F88888888 ;  !UVV V &&|'>?? e%)"$r"c |r tSddlm}ddlm}m}ddlm }|j tdt}t||rs|j D|}|jjj|j d|_ ||j |j|S) z/Force construction of the real VariableTracker.r)TracingContextrrr rNz;source must not be None when realizing LazyConstantVariable)rTrHr1 torch._guardsrrrrrrrrrrrCguards_context dynamo_guardsinnerdiscardrCONSTANT_MATCH)rrrrrrtracing_contextrJs r r1zLazyConstantVariable.realizeos"      %77??$$ $00000088888888...... ;  M "" f. / / O#/"0"4"4"6"6.<BJJ((,$ M$+001LMM N N N r"r>c|r tS||S)z6Return the Python type without triggering realization.)rTrH python_typerr\)rrJs r rz LazyConstantVariable.python_typesO      )77&&(( ( !!!~~r"rNc.|dS)z&Primitive constants are never tensors.FrrLs r is_tensorzLazyConstantVariable.is_tensors !!!ur"c.|dSrrrLs r is_constant_nonez%LazyConstantVariable.is_constant_nones !!!ur" type | Nonec|r!t|S|}tjs*|t ur!t|Stjs*|tur!t|S| dS)aCheck if we need to realize to determine the VariableTracker type. Returns None if we can determine the type without realization (and installs TYPE_MATCH guard). Returns the realized type if realization was needed. With specialize_int=False or specialize_float=False, ints/floats may become either ConstantVariable or SymNodeVariable, so we must realize to know. For bool/str, we always know it will be ConstantVariable. N) rTr>r1r\rspecialize_intintspecialize_floatfloatr)r value_types r _maybe_realize_for_typez,LazyConstantVariable._maybe_realize_for_types      ( '' '^^%% $ (s):): '' '& (:+>+> '' ' !!!tr"cv|j|jSddlm}|}||n||_|jS)zReturn the VariableTracker type to use for builtin handler dispatch. This allows builtins like isinstance() and type() to find the correct handler without triggering full realization of the lazy constant. Nr r)rrrr)rr realized_types r roz2LazyConstantVariable.get_handler_type_for_dispatchsY   )% %......4466 *6MM.realize_and_forwards,-wt||~~t,,d=f===r")rr9rrrFrrr) functoolswrapsrlr )r`rs` r _create_realize_and_forwardrsJ_W_d3344>>>>>54> r"rctjD]E\}}|tjvr2t |r#t t|t |FdSrW)r rrr9callablesetattrr)r`rs r _populatersm&/5577VV e *3 3 3 V+T3Nt3T3TUUUVVr")r`rarrr2) __future__rrrrtypingrrr)rutilsrbaser r r collections.abcr typing_extensionsrr(rrrrr9r?rrrr7r"r rs""""""%%%%%%%%******FFFFFFFFFF(((((((&&&&&&<<<<<<''''''*!*!*!*!*!*!*!*!Zg"g"g"g"g"/5Hg"g"g"g"Tz1z1z1z1z1.z1z1z1z        $    VVVV r"