Ei %SrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSK r SSK r SSK r SSK r SSK r SSKrSSKrSSK JrJrJrJrJrJrJrJrJrJrJrJrJr SSKJr SSKrSSK rSSK!J"s J#r$ SSK%J&r& SSK'J&r(J)r* SSK+J,r,J-r-J.r. SSK/J)r) "S S \5r0\"S 5r1\"S 5r2\ Rfr4\5\6\5S 4-\7S'\5\7S'SSK8r8\8Rrr9\Rx"5r=S\7S'Sr>S\?4Sjr@"SS5rA\A"5rB\C"SS5HrD\B\E"5S\D3'M S\?4SjrFSpS\G4SjjrH"SS5rI\I"5rJS\0S\\G/\44SjrKSqS \LS\\G/\44S!jjrMS"rNS\\G/\44S#jrOS\?4S$jrPS\Q\G4S%jrRS&rSS'rTS(\5S\\G/\44S)jrUS*rV"S+S,5rWS-\\1\24S\\1\244S.jrXS-\\1\24S\\1\244S/jrY"S0S1\R5r[SrS2jr\S-\\1\24S\\1\244S3jr]S-\\1\24S\\1\244S4jr^S5r_S\?4S6jr`S\?4S7jraS\?4S8jrbS\?4S9jrcS:rdS;reSsS<jrf0qg\h\G\Q\4\7S='S>riS?rjS@rkSArlSBrmSsSCjrnS\6\G\L44SDjro0qp\h\G\h\G\Q\44\7SE'0rq\h\6\G\G4\L4\7SF'SGrrSHrsS\?4SIjrtS\?4SJjruS\?4SKjrvSLrwSMrxS\?4SNjryS\?4SOjrz\RRR5(aSSPK~Jr SSQK Jr S\?4SRjrS\?4SSjrOS\?4STjrSUrStSV\GRGR GR S-4SWjjrSX\GSY\Q\GSZ\6\S 44S[jr\GRS\5rSsS]jrS\?4S^jrSsS_jr\hS`\QSa\6Sb\ R$Sc\ R.Sd\ R0Se\ R4Sf0rSsSgjrSsShjrS\?4SijrS\?4Sjjr"SkSl\GR&5rSmrS\GS-4Snjr\ GR.So:ay\]"\GR0GR25 \]"\GR0GR45 \]"\GR0GR65 \]"\GR0GR85 gg!\:a SSK;r;\;Rrr9GNf=f)uz The weak_script annotation needs to be here instead of inside torch/jit/ so it can be used in other places in torch/ (namely torch.nn) without running into circular dependency problems N) AnyCallableDictFinal ForwardRefget_args get_originListOptionalProtocolTupleTypeVarUnion) ParamSpec)_Await)rFuture) fake_rangeget_source_lines_and_file parse_def)rc&\rSrSrS\S\4SjrSrg) HasGetattr5keyreturncgN)selfrs P/home/mande/repo/quber/.venv/lib/python3.13/site-packages/torch/_jit_internal.py __getattr__HasGetattr.__getattr__6sCrN__name__ __module__ __qualname____firstlineno__strrr __static_attributes__rr"rrr5s/s/s/r"r_P_R.BuiltinUnionTypeLockTypez8weakref.WeakKeyDictionary[Callable, dict[str, Callable]]boolean_dispatched__torch_jit_dataclassrc[US5=(aG URS;=(a1 [U5[L=(d [ U[ [55$)Nr%>typingtyping_extensions)hasattrr%r r isinstancetypeanns ris_finalr8RsF\" G NN= = G _ % ECe)Er"c\rSrSrSrSrg)BroadcastingListCls[cgrr)rtypess r __getitem__BroadcastingListCls.__getitem__\sr"rN)r$r%r&r'r>r)rr"rr:r:[sr"r:BroadcastingListcg)a Function that returns True when in compilation and False otherwise. This is useful especially with the @unused decorator to leave code in your model that is not yet TorchScript compatible. .. testcode:: import torch @torch.jit.unused def unsupported_linear_op(x): return x def linear(x): if torch.jit.is_scripting(): return torch.linear(x) else: return unsupported_linear_op(x) Frrr"r is_scriptingrDgs& r"c[US5(a UR$[U[RR 5(a UR $[USS5(a URnO7[U[R5(a URnO [S5eUS:XaSnURnUS:Xa UR $Uc[SUS35e[R"U5(a$UR!S S 5nUR!S S 5nU(aUS :XaS nOSU-nSU;a[SUSUS35eUS-U-$)N_jit_override_qualnamer$z)Could not get name of python class objectz_lambdaztorch._classesz(Could not get qualified name for class 'z': __module__ can't be None.<_>__main__ __torch__z __torch__..z': 'z' is not a valid identifier)r3rFr4torch_CScriptFunctionqualified_namegetattrr$enumEnumname RuntimeErrorr%package_mangling is_mangledreplace)obj mangle_namerU module_names r_qualified_namer]~sfs,--)))#uxx..//!!!sJ%%|| C # #xxFGG z..K&&!!!6tf=( (  "";//!))#s3 !))#s3  * $%K'4K d{6tf=v0 2   t ##r"c&\rSrSrSrSrSrSrg) SourceLoaderc0Ulgrcontentrs r__init__SourceLoader.__init__s  r"c X RU'grrb)rfnsources rcacheSourceLoader.caches! Rr"c8URRU5$r)rcget)rrhs r get_sourceSourceLoader.get_sources||##r"rbN)r$r%r&r'rerjrnr)rr"rr_r_s"$r"r_ lookup_basec^^^^S[S[S[4U4SjjmS[S[S[[[44UU4SjjmS[S[S[4U4SjjmUU4Sj$) aG Creates a resolution callback that will look up qualified names in an environment, starting with `lookup_base` for the base of any qualified names, then proceeding down the lookup chain with the resolved object. You should not use this directly, it should only be used from the other createResolutionCallbackFrom* functions. rQmodulercp>SU;a%URSSS9up#[X5nT"X45$[X5$)NrM)maxsplit)splitrR)rQrrbaseremaining_pieces module_valuelookupInModules rrz7createResolutionCallbackFromEnv..lookupInModulesD . %3%9%9#%9%J "D"60L!"2A A62 2r"exprc*>SnU[U5:a&XS;aUS- nU[U5:a XS;aMUSUS:XaSU4$T"USUR5U5nUc[SUSU35eU[U5:XdXS:waX24$XS:wa[SUS X<35e/nXS :wa3SnUS- nT"XSU5upeURU5 X%- nXS :waM3[U5S:aU[ U5US-4$X4SUS-4$) Nr),[]rtz()rzUnresolvable type rzexpected '[' at position z, got r)lenstripAssertionErrorappendtuple) r|rrirwpartspart_lenpartrzparseNestedExprs rr8createResolutionCallbackFromEnv..parseNestedExprsO #d)m > FA#d)m > 8t q5Ld2Ahnn.7 < #5d2AhZ!@A A D >TW^7N 7c> #ND LL  MA gn u:>e %q1u, ,a>1q5( (r"ct>T"X5up#U[U5:wa [S5eU$![a gf=f)Nz;whole expression was not parsed, falling back to c++ parser)rr Exception)r|rrvalue len_parsedrs r parseExpr2createResolutionCallbackFromEnv..parseExprsQ  / = ESY&$QL    s %) 77c>T"UT5$rr)r|rprs r1createResolutionCallbackFromEnv..s $ 4r")r(rrint)rprzrrs`@@@rcreateResolutionCallbackFromEnvrsf3s3C3C3)c)3)5c?))<SS" 54r" frames_upc$^^[R"5nSnX S-:a,Uc[SU35eURnUS- nX S-:aM,Uc [S5eURmUR m"UU4SjS5n[ U"55$)a Creates a function which, given a string variable name, returns the value of the variable in the scope of the caller of the function which called createResolutionCallbackFromFrame (by default). This is used to enable access in-scope Python variables inside TorchScript fragments. frames_up is number of additional frames to go up on the stack. The default value is 0, which correspond to the frame of the caller of createResolutionCallbackFromFrame. Also for example, if frames_up is set to 1, then the frame of the caller's caller of createResolutionCallbackFromFrame will be taken. For example, the following program prints 2:: def bar(): cb = createResolutionCallbackFromFrame(1) print(cb("foo")) def baz(): foo = 2 bar() baz() rrtzframe is None at iteration z(frame is None after traversing frames_upc0>\rSrSrS\S\4UU4SjjrSrg).createResolutionCallbackFromFrame..envi@rrcx>UT;aTU$UT;aTU$U[[5;a[[U5$gr)dirbuiltinsrR)rr f_globalsf_localss rr :createResolutionCallbackFromFrame..env.__getattr__AsDh}$ ! ~%H %x--&r"rNr#)rrsrenvr@s .3 .3 . .r"r)inspect currentframerf_backrrr)rframerrrrs @@r!createResolutionCallbackFromFramers:  "E A !m  = #>qc!BC C  Q !m   }GHH~~HI.. +35 11r"c0nURUR5 [URR5H up#UR UR X'M" U$)z; Get a dictionary of closed over variables from a function )update __globals__ enumerate__code__ co_freevars __closure__ cell_contents)rhcapturesindex captured_names r get_closurerLsTH OOBNN# )"++*A*A B"$.."7"E"E!C Or"cT^[U5m"U4SjS5n[U"55$)zs Create a resolutionCallback by introspecting the function instead of looking up the stack for the enclosing scope c.>\rSrSrS\S\4U4SjjrSrg);createResolutionCallbackFromClosure..closure_lookupirrc>UT;aTU$[[U5(a[[U5$[[U5(a[[U5$gr)r3r1rRr)rrclosures rr GcreateResolutionCallbackFromClosure..closure_lookup.__getattr__sKg~s|#%%vs++3''x--r"rNr#)rsrclosure_lookuprs 3 3  r"r)rr)rhrrs @r#createResolutionCallbackFromClosurers( "oG   +>+; <'> > #9//5 #"""; (//#&'A 166{az!&&)S__EEYrd*;<== q A vv{{36.. s~~ .d   %  77  #5A5K  2#,!3199 =8D!33!2!2!8!88 3,c2 2! $@8I45 A +B4/GH  s)H+#-I I 5I + I 5II rc ^URVs/sH4n[R"[X55(dM)[X5PM6 nnUVs/sHGn[R"U5(aM [ US5(dM3UR S:wdMEUPMI nn0mUH7nTR[U55 TR[U55 M9 S[S[4U4SjjnU$s snfs snf)z This looks at all the methods defined in a class and pulls their closed-over variables into a dictionary and uses that to resolve variables. r __annotate__rrc<>UT;aTU$[[US5$r)rRr)rrs rlookup_in_class@createResolutionCallbackForClassMethods..lookup_in_classZs# (?C= 8S$/ /r") rrrrR isbuiltinr3r$rrrr(r)rrUrrhrrs @r'createResolutionCallbackForClassMethodsr=sLL  D   WS/ 0    B  $  B &  KK> )  H B(.r230S0S0 9  s"(C6C6C;4C;C;C;cz^^^^^UUUUU4SjnTRc!TRbTRnUTlOVTRc!TRbTRnUTlO(TRcTRcSnO [S5eXlUbXWlUbXglTTTTTS.[U'U$)z Dispatches to either of 2 script functions based on a boolean argument. In TorchScript, the boolean argument must be constant so that the correct function to use can be determined at compile time. cv>TnTU;aUTnOT[U5:aUTnU(aT"U0UD6$T"U0UD6$r)r)rkwargs dispatch_flag arg_indexrdefaultif_falseif_trues rrhboolean_dispatch..fnrsR v "8,M T " OM D+F+ +T,V, ,r"Nz&only one function can have a docstring)r r rr r)__doc__rVr%r$r.) rr r r r r\ func_namerhdocs ````` rboolean_dispatchrcs - -8#3#3#?    !goo&Aoo    !goo&=CDDJ#   r Ir"c0\rSrSrSrSrSrSrSrSr Sr S r g ) FunctionModifiersizb Used to denote the behavior of a function in TorchScript. See export() and ignore() for details. z:unused (ignored and replaced with raising of an exception)z>ignore (leave as a call to Python, cannot be torch.jit.save'd)z7export (compile this function even if nothing calls it)z>default (compile if called from a exported function / forward)zNif this method is not scripted, copy the python method onto the scripted modelzB_drop (function is fully ignored, declaration can be unscriptable)rN) r$r%r&r'rUNUSEDIGNOREEXPORTDEFAULTCOPY_TO_SCRIPT_WRAPPER_DROPr)rr"rrrs. JF MF FFNGX QEr"rrhc0[RUlU$)a This decorator indicates that a method on an ``nn.Module`` is used as an entry point into a :class:`ScriptModule` and should be compiled. .. deprecated:: 2.5 Please use :func:`torch.compile` instead. ``forward`` implicitly is assumed to be an entry point, so it does not need this decorator. Functions and methods called from ``forward`` are compiled as they are seen by the compiler, so they do not need this decorator either. Example (using ``@torch.jit.export`` on a method): .. testcode:: import torch import torch.nn as nn class MyModule(nn.Module): def implicitly_compiled_method(self, x): return x + 99 # `forward` is implicitly decorated with `@torch.jit.export`, # so adding it here would have no effect def forward(self, x): return x + 10 @torch.jit.export def another_forward(self, x): # When the compiler sees this call, it will compile # `implicitly_compiled_method` return self.implicitly_compiled_method(x) def unused_method(self, x): return x - 20 # `m` will contain compiled methods: # `forward` # `another_forward` # `implicitly_compiled_method` # `unused_method` will not be compiled since it was not called from # any compiled methods and wasn't decorated with `@torch.jit.export` m = torch.jit.script(MyModule()) )rr_torchscript_modifierrhs rexportrsZ 177B Ir"c[U[5(a_Un[URS[R 5 UR (a%[UR S[R 5 U$[R UlU$)a This decorator indicates to the compiler that a function or method should be ignored and replaced with the raising of an exception. This allows you to leave code in your model that is not yet TorchScript compatible and still export your model. Example (using ``@torch.jit.unused`` on a method):: import torch import torch.nn as nn class MyModule(nn.Module): def __init__(self, use_memory_efficient): super().__init__() self.use_memory_efficient = use_memory_efficient @torch.jit.unused def memory_efficient(self, x): import pdb pdb.set_trace() return x + 10 def forward(self, x): # Use not-yet-scriptable memory efficient mode if self.use_memory_efficient: return self.memory_efficient(x) else: return x + 10 m = torch.jit.script(MyModule(use_memory_efficient=False)) m.save("m.pt") m = torch.jit.script(MyModule(use_memory_efficient=True)) # exception raised m(torch.rand(100)) r)r4propertysetattrfgetrrfsetr)rhprops runusedr%spP"h II.0A0H0H  99  24E4L4L  077B Ir"c4\rSrSrSrS\S\S\SS4SjrS rg) _IgnoreContextManageric grr)rrs rre_IgnoreContextManager.__init__ r"exc_type exc_value tracebackrNcgrr)rr+r,r-s r__exit___IgnoreContextManager.__exit__r*r"r)r$r%r&r'rerr/r)rr"rr'r's(      r"r'c Z^[T5(aTn[RUlU$[ T[ 5(d[ ST35eURSS5nU(a[R"SS[S9 UmO!T(a[R"SS[S9 U4SjnU$) a This decorator indicates to the compiler that a function or method should be ignored and left as a Python function. This allows you to leave code in your model that is not yet TorchScript compatible. If called from TorchScript, ignored functions will dispatch the call to the Python interpreter. Models with ignored functions cannot be exported; use :func:`@torch.jit.unused ` instead. .. deprecated:: 2.5 Please use :func:`torch.compile` instead. Example (using ``@torch.jit.ignore`` on a method):: import torch import torch.nn as nn class MyModule(nn.Module): @torch.jit.ignore def debugger(self, x): import pdb pdb.set_trace() def forward(self, x): x += 10 # The compiler would normally try to compile `debugger`, # but since it is `@ignore`d, it will be left as a call # to Python self.debugger(x) return x m = torch.jit.script(MyModule()) # Error! The call `debugger` cannot be saved since it calls into Python m.save("m.pt") Example (using ``@torch.jit.ignore(drop=True)`` on a method): .. testcode:: import torch import torch.nn as nn class MyModule(nn.Module): @torch.jit.ignore(drop=True) def training_method(self, x): import pdb pdb.set_trace() def forward(self, x): if self.training: self.training_method(x) return x m = torch.jit.script(MyModule()) # This is OK since `training_method` is not saved, the call is replaced # with a `raise`. m.save("m.pt") .. testcleanup:: import os os.remove('m.pt') zCArgument to @torch.jit.ignore must be a bool or a function but got drop_on_exportNzignore(drop_on_export=True) has been deprecated. TorchScript will now drop the function call on compilation. Use torch.jit.unused now. {}r@) stacklevelcategoryzzignore(True) has been deprecated. TorchScript will now drop the function call on compilation. Use torch.jit.unused now. {}cn>T(a[RUlU$[RUlU$r)rrrr)rhdrops r decoratorignore..decorators0 '8'?'?B $ (9'?'?B $ r") callablerrrr4boolrVpopwarningswarn FutureWarning)r6rrhr2r7s` rignorer?sH~~#4#;#;  dD ! !QRVQW X  ZZ 0$7N  @"     @"   r"c0[RUlU$r)rrrrs r_droprAs066B Ir"c0[RUlU$r)rrrrs r_copy_to_script_wrapperrCs0GGB Ir"c[U5HPn[X5(dM[X5n[U5(dM2[ U5[ R LdMP g g)NTF)rr3rRr9get_torchscript_modifierrr)modrUitems rmodule_has_exportsrHsJC 3  3%D~~+D15F5M5MM  r"cv[U5nUcgU[RL=(d U[RL$NF)rErrr)rhrs r should_droprKs7 #B 'D | $++ + Nt7H7N7N/NNr"c[U5nU[RL=(d+ U[RL=(d U[RL$r)rErrrrrhrFs rrrsH "2 &C  ''' * #** * * #)) )r"c<[U5nU[RL$r)rErrrMs r _is_drop_fnrOs "2 &C #)) ))r"cH[[R"XSS9[5$)N)r )r4rgetattr_static staticmethodrrhs r is_static_fnrTs g,,SdC\ RRr"cB[R"X5R$r)rrQ__func__rSs r get_static_fnrWs  ! !# * 3 33r"c[U5(dg[US5(a URn[US[R 5$)NrVr)r9r3rVrRrrrs rrErEs; B<<r: [[ 2.0A0I0I JJr"c.[U5nUcgX!lgr)rEr)orignewrs rcopy_torchscript_modifierr\s #D )D | $r"_overloaded_fnsaP Example usage of overload function: @torch.jit._overload def my_function(x: type0) -> type0: # decl 1 pass @torch.jit._overload def my_function(x: type1) -> type1: # decl 2 pass def my_function(x): # implementation if isinstance(x, type0): return x elif isinstance(x, type1): return x c [U5up#nSUS[U5SUSUS3 SRU5-S-[-$)NzImplementation for the z "zk" is missing. Please make sure a definition is provided and defined after all overload declarations. File "z", line z:  )rr]r_OVERLOAD_EXAMPLE)rrZ sourcelines file_linenofilenames r,get_overload_no_implementation_error_messageresh)B3)G&Kh !$r/#*>)?@ (;-s 4 ''+        r"c[U5nURR SR nSnSn[ U5S:wd U"US5(dZU"US5(dIS nUS RURRS 5SS 5- nUS [-- n[U5egg![a [R"SUS3SS9 gf=f) Nz=Unable to retrieve source for @torch.jit._overload function: rMr@r3rc6[U[R5$r)r4rPassxs ris_pass%_check_overload_body..is_passs!SXX&&r"c[U[R5=(aG [UR[R5=(a URR[ L$r)r4rExprrrEllipsisrjs r is_ellipsis)_check_overload_body..is_ellipsissA q#(( # *177CLL1 * ) r"rtzHOnly `pass` statement or `...` can be the body of overload declaration: r`z$ <- Expecting `pass` or `...` here! ) rrr<r=rrrrrirvrarV)func parsed_defrrlrqmsgs r_check_overload_bodyrws t_  >>  q ! & &D'  4yA~gd1g..+d1g2F2F W  tyy**006r:;; 69JJJ3 3G.+   KD6QR S  s B00#CCc[U5 [U5n[RU5nUc /nU[U'UR U5 U$r)rwr]r]rmr)rt qual_namefn_overload_lists r _overloadr{sN%I&**95%5 "D! Kr"c,[RU5$r)r]rmrys r_get_fn_overloadsr~"s   y ))r"c[U gr)r]r}s r_clear_fn_overloadsr&s  "r"c[R"5n[S5H nUc[SU35eURnM" Uc [S5eUR R nUR RnX44$)Nr@z#current_frame is None at iteration z-current_frame is None after traversing frames)rrrangerrf_codeco_nameco_firstlineno)method current_framer class_nameline_nos rget_class_name_linenor*s((*M1X   #Fqc!JK K%,,  LMM%%--J""11G  r"_overloaded_methods_overloaded_method_class_filenoc2[U5 [U5n[RU5nUc 0nU[U'[ U5up4URU5nUc/nXRU'U[ X4'O[ X4nXd:wa [ S5eURU5 U$)NzmCannot currently overload the same method name in two different classes with the same name in the same module)rwr]rrmrrrVr)rtryclass_name_maprrmethod_overloadsexisting_linenos r_overload_methodrKs%I(,,Y7N)7I&/5J%))*5%5z"CJ'(?@99:QR  %A  D! Kr"c`[US5(dg[U5n[RU5nUcgURURS5nUcg[ U5Sn[ U5SnU[ [ U5S5-nXV:aXW::d[S[U5-5eU$)Nr$rtrzKOverloads are not usable when a module is redeclared within the same file: ) r3r]rrmr$rrrr()r mod_classryr overloadsmethod_line_nomod_class_filenomod_end_filenos r_get_overloaded_methodsrfs 6: & &'I(,,Y7N""9#5#5t%,Ei,PQR,S(TTN  .>3S Y&k    r"cU[RLa [S5 [US5(dg[ U5nUR S;=(a U[ L$)Nr r%Frr1)r1r 'raise_error_container_parameter_missingr3r r%rr7 ann_origins ris_tupler}sK fll/8 3 % %CJ >>3 3 K e8KKr"cU[RLa [S5 [US5(dg[ U5nUR S;=(a U[ L$)Nr r%Fr)r1r rr3r r%rrs ris_listrI fkk/7 3 % %CJ >>3 3 J d8JJr"cU[RLa [S5 [US5(dg[ U5nUR S;=(a U[ L$)Nrr%Fr)r1rrr3r r%dictrs ris_dictrrr"cU[La [S5 [U[5=(d: [ US5=(a' UR S:H=(a [ U5[L$)Nrr%r1)rrr4r,r3r%r r6s ris_unionrsR e|/8 c+ , \" ' NNh & ' _ %r"cU[La [S5 SnSnU"U5=(d [U5=(a U"U5$)Nr cv[US5=(a' URS:H=(a [U5[L$)Nr%r1)r3r%r r r6s ris_optional_as_optional,is_optional..is_optional_as_optionals3 C & .(* .CH, r"cv[U5n[U5S:H=(a SU;=(d [S5U;$)Nr@)rrr5)r7ann_argss ris_union_as_optional)is_optional..is_union_as_optionals2C=8}!Rtx'7'Q4:;QRr")r rr)r7rrs r is_optionalrs> h/ ; S #3 ' XHSM,W>RSV>WXr"cLU[La [S5e[U5[L$)Nz_Attempted to use Future without a contained type. Please add a contained type, e.g. Future[int])rrVr r6s r is_futurers, f}   c?f $$r"c8U[Lag[U5[L$)NT)rr r6s ris_awaitrs f} c?f $$r")PyRRef)RRefcLU[La [S5e[U5[L$)Nz[Attempted to use RRef without a contained type. Please add a contained type, e.g. RRef[int])rrVr r6s ris_rrefrs, $;  #$&&r"c"[U[5$r)r4rrZs ris_rref_instancers#v&&r"cgrJrrs rrrsr"cN[U5(dg[RU5$r)r9r.rmrs r_try_get_dispatched_fnrs B<<  ! !" %%r"locc Uc [5n[U[5(a[US5(d[ SU35e[US5(a;UR Vs/sH#nX0R ;dMUR UPM% nnO/n[R"U5n[U5S:Xa1[US5(a [R"UR5n/nUR HnX5;aXSn[U[5(aFUbCU"UR5nUc,[SUSURSUR!535eUn["R$R&R)XqU5n UR+U 5 MUR+["R,R.R155 M [3U5RUR Xd4$s snf) N_fieldsz7expected namedtuple (tuple subclass with _fields), got _field_defaultsr__base__zUnknown type annotation: 'z' in NamedTuple zh. Likely due to partial support for ForwardRef parameters in NamedTuples, see #95858. Issue occurred at )rrrr3rrrrget_annotationsrrr4r__forward_arg__ ValueErrorr$ highlightrNjit annotations ann_to_typerrO TensorType getInferredr5) rZrrcbfielddefaultsobj_annotationsr field_typercb_typethe_types r_get_named_tuple_propertiesrs  {l c5 ! !i)@)@EcU K  s%&& $+++ 'C   &$   --c2O ?q WS*%=%=!11 LL  K  #(/JH*j11coz99:#$4ZL@PQTQ]Q]P^_..1mmo->@ & yy,,88#NH   x (   uxx22>>@ Agh 9  s{{K AAI s !G58G5 unqual_name field_namesrc6[R"XUS9nU"U6$)N)r) collections namedtuple)trrr TupleTypes r_create_named_tupler@s &&{(SI a=r"c#4# [RR5n[RRSS5 Sv [RRUSUS5 g![RRUSUS5 f=f7fNrrt)rNrO_jit_get_emit_hooks_jit_set_emit_hooks)hookss r_disable_emit_hooksrJsk HH ( ( *E HH  t,9  $$U1XuQx8$$U1XuQx8s?BA-'B-(BBcSSjnSSjng)Nc[RR5Ul[RR SS5 gr)rNrOrrrrds r __enter__0_disable_emit_hooks_decorator..__enter__Vs*XX113  $$T40r"cx[RRURSURS5 gr)rNrOrr)rrs rr//_disable_emit_hooks_decorator..__exit__Zs& $$TZZ]DJJqMBr"rNr)_DecoratorContextManagerrr/s r_disable_emit_hooks_decoratorrTs 1Cr"cZ[R"U5(dg[U[5$rJ)risclassrrrs r _is_exceptionr^s! ??3   c9 %%r"cvURS5(a[SUSUS35e[SUSUS35e)NictzAttempted to use z: without contained types. Please add contained type, e.g. z [int, int]z= without a contained type. Please add a contained type, e.g. z[int])endswithrV) target_types rrrds`E"" }-@m: '   K=)= -u  r"rrrrr r r cT[RU5=n(a [U5 ggr)_RAW_TYPE_NAME_MAPPINGrmr)rrUs rcheck_args_existr}s%%))+66t6/57r"cTU/:Xd U0:XdUS:Xa[R"SSS9 gg)NrzThe inner type of a container is lost when calling torch.jit.isinstance in eager mode. For example, List[int] would become list and therefore falsely return True for List[float] or List[str].r@rg)r<r=rs rcheck_empty_containersrs0 byC2I     "+r"c[U5n[U5 UcgU[LdU[RLaq[ U5 [ U[5(dg[U5Sn[U5nUH0nU(a[XS5(d gM[ XS5(aM0 g gU[RLd U[La[ U5 [ U[5(dg[U5Sn[U5SnUR5HOup[ X5(d g[U5n U (a[X5(d gM=[ X5(aMO g gU[RLd U[La[ U5 [ U[5(dg[U5n [U5[U 5:wag[X 5H=up\[U 5n U (a[X\5(d gM+[ X\5(aM= g gU[ Ld[#U[$5(aIUcg[U5nUH4n[U5nU(a [X5s $[ X5(dM4 g g)NFrTrt)r rrr1r rr4rcontainer_checkerrrrr rrziprrr,)rZr origin_typearg_type arg_originelkey_typeval_typerval val_origin arg_typesel_type el_origin inner_typesrt_origins rrrs[)K[!   v{{ :s##t$$K(+) B(66 7--   #{d':s##t$$K(+K(+ HCc,,#H-J(77 8..$  $ u(<s##u%%[) s8s9~ %s.KB"7+I(55 6,, /  "" ;{+ A!!}H(00C##  r"c2[U[RR5(a<[U[5(d [ S5eUHn[ X5(dM g g[U5nU(a [X5$[U5 [X5$)NzPThe second argument to `torch.jit.isinstance` must be a type or a tuple of typesTF) r4rabc ContainerrrV _isinstancer rr)rZrt_typers rr r s+{8899+u--&  "F3''"[)K 22[! c ''r"cP^\rSrSrS\\R 4U4SjjrSrSr U=r $)_TensorExtractoritensorsc2>[TU]"U0UD6 Xlgr)superrer)rrrr __class__s rre_TensorExtractor.__init__s $)&) r"c[U[R5(aURR U5 g[U[ 5(ag[U[ 5(d[U5(ag[U[5(ag[U[RR5(ag[U[R5(agg)Nr_) r4rNTensorrrr-CFuturerCAwaitcudaEvent threadingThread)rrZs r persistent_id_TensorExtractor.persistent_ids c5<< ( ( LL   $ c8 $ $ c7 # #'7'<'< c6 " " c5::++ , , c9++ , ,r")r) r$r%r&r'rrNrrerr) __classcell__)rs@rr r s"tELL'9r"r ch/n[[R"5SUS9nURU5 U$)z This function is exclusively called from C++. See ``torch/csrc/jit/python/python_ivalue.h``. It extracts the tensors contained in the given object, through pickling. )protocolr)r ioBytesIOdump)rZr extractors r_extract_tensorsr% s.#%G GLI NN3 Nr"c[U[RR5(a#[ UR R 55$[U[RR5(a UR$gr) r4rNr ScriptModuler(_c_typerPrQrs r _get_model_idr*sT#uyy--..366<<>"" C11 2 2!!!r")rs )T)r)Fr)NN)rrrr contextlibrSrr!picklesysrrr=r1r<weakrefrrrrrrr r r r r rrr2rrNtorch.distributed.rpctorch.package._manglingpackage _manglingrW torch._awaitsrtorch._Crrrtorch._sourcesrrr torch.futuresrr*r+ UnionTyper,r5r__annotations___threadr- ImportError _dummy_threadWeakKeyDictionaryr.FAKE_FILENAME_PREFIXr:r8r:BroadcastingList1rrglobalsrDr(r]r_rrrrrrrrrrrrrrrr%AbstractContextManagerr'r?rArCrHrKrrOrTrWrEr\r]rrarerwr{r~rrrrrrrrrrrrr distributedrpc is_availabletorch._C._distributed_rpcrrrrrrO_jit_tree_views SourceRangerrcontextmanagerrrrrrrrrr Picklerr r%r* version_inforT__new__ __format____repr____str__rr"rrOs     ( 22 8KK 00t_ T],1OO$tSy)); &H N /T() q!A(9GI $% d.C$cC$L$$ A5A5#PS@TA5H3232XseSj=Q32l t=xs /C=,d*tCy>,Tn##(C5#::N#L4n Q Q .xB.HRV$4.b6xB6HRV$46t J== l^hr2v8BF#3 R 0Xb"f5E OtO*t* STS4K%.0c4>)*/$  B *# U38_ 4=?T#tCh$7889>?AeCHos&:!;@6. LT L KD K KD KY$%d%%T%  %%''0*''''  &8< QB  ! ! - - 4QBhcCHo  99C&$&  && 7 KK KK OOZ LL'6  @4@F(T(2v~~< #*w $))   $))   $))   $))   A/&%%H&s Q22R  R