3j]%SSKrSSKrSSKrSSKrSSKrSSKrSSKJr SSKJrJ r J r J r J r J r SSKrSSKJr SSKJrJr SSKJr SSKJr \ (aSS KJr /S Qr\"S S 9"S S\ 55r0r\\S\4\\R>4\ S'S\\R>4Sjr!\!"5\\RD'"SS5r#\RH\RJ\RL\RN\RPRR\RT\RV\#"5\,"S5\RZ\R\"S5\S. r/\0"\5Hr1\2"\\15\/\1'M SSS\4Sjr3S\RhRjS\R>4Sjr60r7\\8\9\94\R>4\ S'S\RhRjS\R>4Sjr:\"S S 9S\S\4S\8S S!\\9S"4SS4S#j5r;\ S$\S\4S%\ S&S\8\\R>S-\\RhRjS-44S'j5r<\ S8S$\S\4S%\ S S\\R>S-4S(jj5r<\"S S 9S9S$\S\4S%\=S\\R>\8\\R>S-\\RhRjS-4-S-4S)jj5r<\"S S 9S*\>S\>4S+j5r?\"S S 9S,\S-\S\=4S.j5r@\"S S 9S:S\S\4S\8\S4S!\\9\4S-S/\8\S-S0\\9\4S-S1\=S\4S2jj5rA\"S S 9S:S\S\4S\8\S4S!\\9\4S-S/\8\S-S0\\9\4S-S1\=S\S-4S3jj5rB\"S S 9S;S4\RRS\9S\8\S!\\9\4S-S1\=S\S-4 S5jj5rES6\R>S\8\S4S!\\9\4S1\=S\S-4 S7jrFg)<N)Callable)AnycastLiteral NamedTupleoverload TYPE_CHECKING)boolean_dispatched) OpOverloadOpOverloadPacket) _fast_bind) compatibility)Argument)ArgsKwargsPaircheck_for_mutable_operationget_signature_for_torch_opcreate_type_hint type_matchesnormalize_functionnormalize_moduleF)is_backward_compatiblecB\rSrSr%Sr\\S4\S'\\ \4\S'Sr g)r z4 Simple named tuple for wrapping args/kwargs pairs. .argskwargsN) __name__ __module__ __qualname____firstlineno____doc__tupler__annotations__dictstr__static_attributes__rS/home/wildlama/miniconda3/lib/python3.13/site-packages/torch/fx/operator_schemas.pyrr s% S/ cNr(r._manual_overridesreturnc/nS[RSS4SjnUR[R"U55 S[RS[ SS4SjnUR[R"U55 U$)Nselfr+cgNr)r-s r)nonzero!_nonzero_schemas..nonzero0 r(as_tuplecgr/r)r-r3s r)r0r15r2r()torchTensorappendinspect signaturebool) signaturesr0s r)_nonzero_schemasr<-sxJ ell t g''01 ell  $ g''01 r(c:\rSrSrS\S\R 4SjrSrg)_FakeGlobalNamespace@namer+c0US:Xa[$[S5e)Nr5z!Expected a torch namespace lookup)r5 RuntimeError)r-r@s r) __getattr__ _FakeGlobalNamespace.__getattr__As 7?L>??r(rN) rrr r!r&types ModuleTyperCr'rr(r)r>r>@s@@(8(8@r(r>t) r6DeviceLayoutnumberFuture AnyEnumTypeQScheme __torch__NoneTypeStoragerGPyObjectts_typeztorch._C.JitTypec6[UR[5$)z Convert a TorchScript type to a Python type (including subtypes) via eval'ing the annotation_str. _type_eval_globals sets up expressions like "List" and "Future" to map to actual types (typing.List and jit.Future) )evalannotation_str_type_eval_globals)rRs r) _torchscript_type_to_python_typerWYs &&(: ;;r( ts_schemac SSKJn /nURGHXn[UR5nUR 5(a UR O URnURS:wa UROSnUR(a URO URnUS:XaXqR:wa[SU35eURn[U5HwupU RUR:wa%[SU RSU R35eU"U RURU R U R"S 9X('My UR%U"XgXTS 95 GM[ UR&V s/sHn [U R5PM n n [)U 5S:XaSn O [)U 5S :XaU Sn O [+U 5n [R,"X,S 9$s sn f) Nr) Parameterr-inputfromz$Expected POSITIONAL_OR_KEYWORD, got z)Expected POSITIONAL_OR_KEYWORD for param z, got )r@kinddefault annotationr)return_annotation)r8rZ argumentsrWtypehas_default_value default_valueemptyr@ kwarg_only KEYWORD_ONLYPOSITIONAL_OR_KEYWORDAssertionErrorPOSITIONAL_ONLY enumerater]r^r_r7returnslenr# Signature) rXrZ parametersargarg_typer^r@r]idxpret return_types return_types r)%_torchscript_schema_to_signature_implrwbs""$J""3CHH='*'<'<'>'>###IOO 88v-sxx7~~  " "00 6>666$'KD6%RSS,,D$J/66Y<<<(CAFF86RSRXRXQYZ#,"22II || #  0  4G Q G#N?H>O>O>Os(2>O <A \ a "1o L)   Z GGsG'_SCHEMA_TO_SIGNATURE_CACHEcURUR4n[RU5nUbU$[ U5nU[U'U$r/)r@ overload_namerxgetrw)rX cache_key cache_valress r) _torchscript_schema_to_signaturersN 7 77I*..y9I / :C,/y) Jr(targetr)r.rrcn[USS9up4U(aU(a/n[X45H'upg[U/UQ70UD6 URXg45 M) S[ R RSS4Sjn[U5S:Xag[U5S:XaUSupU"U 5 gggg![a Mf=f)NT)return_schemasschemar+cDUR(a[SUS35eg)Nz!Tried to trace mutable operation z|. FX only supports functional code, so operations that mutate operands in-place (e.g. via `out` arguments) are not supported) is_mutablerB)rs r)throw_if_mutable5check_for_mutable_operation..throw_if_mutables/  "7x@()!r(rr) rzipr r7 TypeErrorr5_CFunctionSchemarm) rrrr;schemasmatched_schemascandidate_signaturerr_schema_to_checks r)rrs 5VDQJgSU ,/z+C '  .@@@&&(;'DE,D UXX%<%<    1 $   !Q &!0!3 A _ - ?z  s!B&& B43B4oprTcgr/rrrs r)rrs SVr(cgr/rrs r)rrs&)r(c:[U[5(aUR/nO[U[5(a4UR 5Vs/sHn[ X5RPM nnO[ RU5nU(a U(aUS4$S$[RRRU5nUc U(aS$S$[RRU5nUVs/sHn[U5PM nnU(aXr4$U$s snfs snf)aX Given an operator on the `torch` namespace, return a list of `inspect.Signature` objects corresponding to the overloads of that op.. May return `None` if a signature could not be retrieved. Args: op (Callable): An operator on the `torch` namespace to look up a signature for Returns: Optional[List[inspect.Signature]]: A list of signatures for the overloads of this operator, or None if the operator signatures could not be retrieved. If return_schemas=True, returns a tuple containing the optional Python signatures and the optional TorchScript Function signature N)NN) isinstancer _schemar overloadsgetattrr*r{r5jit _builtins _find_builtinr_jit_get_schemas_for_operatorr)rrrroverrideaten_fnrr;s r)rrs,"j!!::, B( ) )ACPX72(00P$((, '5Hd# ?4 ?))%%33B7 ?#1< ;t ;((88AIPQv26:JQ$2J B BQRs D0Dxc[U[[45(a[U[5(aS[S[4SjnOS[S[4Sjn[ U5S:Xa U"[5$USnUH5n[ X25(aM[ X#5(aUnM)U"[5s $ U"U5$U$![ a [R"SU35 U$f=f)a Produces a type hint for the given argument. The :func:`create_type_hint` looks for a type hint compatible with the input argument `x`. If `x` is a `list` or `tuple`, it looks for an object in the list whose type is a superclass of the rest, and uses that as `base_type` for the `List` or `Tuple` to be returned. If no such object is found, it defaults to `List[Any]`. If `x` is neither a `list` nor a `tuple`, it returns `x`. rr+c[U$r/)listrs r)ret_type"create_type_hint..ret_types 7Nr(c[US4$)N.)r#rs r)rr"s C=(r(rz@We were not able to successfully create type hint from the type ) rrr#rrm issubclass Exceptionwarningswarn)rr base_typerGs r)rr s a$ ' '!T""### )))1v{}$!Ia++ -- !I#C=( I& &- (8 H   Nqc R  H  sA-B;0=B;. B;;#C"!C"signature_type argument_typec^^[USU5nUTLagU[RLa'UT:wa!URn[ U4SjU55$[USS5[ LaURSmT[ La T[ Lag[R"T5(d[R"SUS35 g[TSS5[ La[TRST5$S[S [4U4S jjnU"T5$U[ LaT[RLagU[ R"LaT[ [$1;ag[R"T5(a'[R"U5(a [TU5$g) N __origin__Tc3<># UHn[UT5v M g7fr/)r).0crs r) type_matches..CsI=a<=11=srz.Does not support nested parametric types, got z. Please file a bug.FrGr+c>[R"U5[Lag[R"U5nUS:Xag[ U4SjU55$)NF)rTc3X># UHo[L=(d [UT5v M! g7fr/)Ellipsisr)rr sig_el_types r)r=type_matches..is_homogeneous_tuple..Zs"XiX D*Q *DDis'*)typing get_originr#get_argsall)rG containedrs r)is_homogeneous_tuple*type_matches..is_homogeneous_tupleTsC  #50*IE!XiXX Xr()rrUnion__args__anyrintr8isclassrrrobjectr:r5dtypenumbersNumberfloat)rrsig_origin_type sig_containedrrs ` @r)rr8s[nlNKO&&,,&>]+J&// I=III~|T2d:$--a0  C K3$6{++ MM@@PPde  =, 5 =m44Q7E E YF Yt Y$M22%++!='Mc5\,I}%%'//.*I*I-88 r( arg_types kwarg_typesnormalize_to_only_use_kwargscN[XX#XE5nUc[SUSUSU35eU$)zV Wrapper around normalize_function that never returns None, but loudly errors instead zFailed to normalize function z with args z and kwargs )rrB)rrrrrrr~s r)_normalize_function_or_errorrksH f C {+F8;tfLQWPX Y   r(c`Uc0nSn[U[R5(d8[U[[45(d[ US5(a UR n[U[R5(d[U[[45(dUnU[;aw[U[5(a [S5e[UnUSUSp[R"U 5R[R"U 5R:wagU n[U5(d[S[U535e[R"[R"U55n [!XX%5nU$[U5(d[S[U535e[#U5n /n U (GaSU H$n[%U/UQ70UD6 U R'U5 M& [+U 5S:XaU$[+U 5S :Xa[!U SXU5nU$UcUbU(aUO[-[.[0S 5nU(aUO0nU HnS n[%U/UQ70UD6nUR2R55H4unnURUnU=(a [7UR8U5nM6 U(dMp[!UUUU5n U$ U$S R;SU 55n[=S[>R@"U5SU35eU$![(a GMaf=f![(a S nN~f=f)a Returns normalized arguments to PyTorch functions. This means that `args/kwargs` will be matched up to the functional's signature and return exclusively kwargs in positional order if `normalize_to_only_use_kwargs` is True. Also populates default values. Does not support positional-only parameters or varargs parameters (*args, **kwargs). Does not support modules. May require `arg_types` and `kwarg_types` in order to disambiguate overloads. Args: target (Callable): Function that we are normalizing args (Tuple[Any]): Tuple of args to the function kwargs (Optional[Dict[str, Any]]): Dict of kwargs to the function arg_types (Optional[Tuple[Any]]): Tuple of arg types for the args kwarg_types (Optional[Dict[str, Any]]): Dict of arg types for the kwargs normalize_to_only_use_kwargs (bool): Whether to normalize to only use kwargs. Returns: Returns normalized_args_and_kwargs, or `None` if not successful. N_opz"target should not be a string hereif_trueif_falsez*target_for_analysis must be callable, got ztarget must be callable, got rrrTF c38# UHn[U5v M g7fr/)r&)rrs r)r%normalize_function..s12AF /sz Tried to normalize arguments to zy but the schema match was ambiguous! Please provide argument types to the normalize_arguments() call. Available schemas: )!rrEBuiltinFunctionTyper r hasattrrr r&rir8r9rocallablerbunwrap&_args_kwargs_to_normalized_args_kwargsrr r7rrmrr#rraitemsrr_joinrBr5typename)rrrrrrnew_args_and_kwargstarget_for_analysis dispatchedrrsigtorch_op_schemasrr sig_matches bound_typesarg_namerqparamschema_printoutss r)rrst>~ vu88 9 9F%5z$BCC FE " "  fe77 8 86,j9::$ ' ' &#&&$%IJJ+F3J *9 5z*7MX!!'*55$$X.99:") +,, ?(8?#q(Z Y_%*&L#A&6R'#T M(K,C-6 DsR>&;Q:RSOO_N`b e!4 )0*/K0s%= L  A!L LL L-,L-rootcURU5n[URS5(aURR n[ [RUS5UR:XaG[R"[R"UR55nUc0n[XX45n U $g![an[SUS35UeSnAff=f)a Returns normalized arguments to PyTorch modules. This means that `args/kwargs` will be matched up to the functional's signature and return exclusively kwargs in positional order if `normalize_to_only_use_kwargs` is True. Also populates default values. Does not support positional-only parameters or varargs parameters (*args, **kwargs). Args: root (nn.Module): root module upon which we query modules target (Callable): Function that we are normalizing args (Tuple[Any]): Tuple of args to the function kwargs (Optional[Dict[str, Any]]): Dict of kwargs to the function normalize_to_only_use_kwargs (bool): Whether to normalize to only use kwargs. Returns: Returns normalized_args_and_kwargs, or `None` if not successful. z$Tried to normalize node with target z# but root did not have that target!Nr) get_submoduleAttributeErrorrBr __class__rrr5nnr8r9rforwardr) rrrrrsubmode classnamerrs r)rrs6##F+ v,,$$-- 588Y -1A1A A##GNN6>>$BCC~"H6# ' &  26(;  !  sB55 C?CCrc^^ [RR[RR1m [ U 4SjUR R 555(a*[UR R55/SQ:wag[U/UQ70UD6nUR5 0n/n[UR 5HLupxU(d/U[U5:a URURU5 M;URUXX'MN [[!U5U5$)aU Given a call target, args, and kwargs, return the arguments normalized into an ArgsKwargsPair, or None if the type signature is not supported by this normalization. Args: sig (inspect.Signature): Signature object for the target args (Tuple): Arguments that appear at the callsite for `target` kwargs (Dict): Keyword arguments that appear at the callsite for `target` normalize_to_only_use_kwargs (bool): Whether to normalize to only use kwargs. Returns: Optional[ArgsKwargsPair]: Normalized args and kwargs for `target`, or `None` if this target is not supported. c3@># UHoRT;v M g7fr/)r])rrssupported_parameter_typess r)r9_args_kwargs_to_normalized_args_kwargs..\s Ts6 //&&! TCNNr6devicelayoutrrrKEnumqschemerbUntypedStorageTypeVarrVdirkrrWrrrwrxr#r&rrrr:rrrrrrModulerrrr(r)rs  $JJ 23+) e,Z-HJ4c*D1B1B,CCDI $w001  $4#5%-- @@llllllnnii99}}%'T ##    VA#FA.q <.@