[Th4SL%SSKrSSKrSSKrSSKrSSKrSSKrSSKJrJrJrJ r J r J r SSK r SSK Jr SSKJrJr SSKJr \ (aSSKJr /SQr\"S S 9"S S \ 55r0r\\\\R64\S 'Sr\"5\\ R<'"SS5r\ R@\ RB\ RD\RF\ RHRJ\RL\ RN\"5\("S5\ RR\RT"S5S. r+\,"\5Hr-\."\\-5\+\-'M SSS\4Sjr/S\ R`RbS\R64Sjr20r3\\4\5\54\R64\S'S\ R`RbS\R64Sjr6\"S S 9S\S\4SS\\5S44S j5r7\"S S 9S1S!\S"\84S#jj5r9\"S S 9S$5r:\"S S 9S%\S&\4S'j5r;\"S S 9S2S\S\4\S(4S\ \\5\4S)\ \4\S*\ \\5\4S+\8S\ \4S,jj5r<\"S S 9S3S-\ RzR|S\5S\4\S\ \\5\4S+\8S\ \4 S.jj5r?S/\R6S\4\S(4S\\5\4S+\8S\ \4 S0jr@g)4N)AnyCallablecast NamedTupleOptional TYPE_CHECKING)boolean_dispatched) OpOverloadOpOverloadPacket) 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)rz4 Simple named tuple for wrapping args/kwargs pairs. .argskwargsN) __name__ __module__ __qualname____firstlineno____doc__tupler__annotations__dictstr__static_attributes__rQ/var/www/auris/envauris/lib/python3.13/site-packages/torch/fx/operator_schemas.pyrrs% S/ cNr&r_manual_overridesc/nSnUR[R"U55 S[4SjnUR[R"U55 U$)NcgNr)selfs r'nonzero!_nonzero_schemas..nonzero/ r&as_tuplecgr+r)r,r0s r'r-r.4r/r&)appendinspect signaturebool) signaturesr-s r'_nonzero_schemasr7,sTJ g''01 4 g''01 r&c\rSrSrSrSrg)_FakeGlobalNamespace?c0US:Xa[$[S5e)Ntorchz!Expected a torch namespace lookup)r< RuntimeError)r,names r' __getattr__ _FakeGlobalNamespace.__getattr__@s 7?L>??r&rN)rrrrr?r%rr&r'r9r9?s@r&r9t) TensorDeviceLayoutnumberFuture AnyEnumTypeQScheme __torch__NoneTypeStoragerAts_typeztorch._C.JitTypereturnc6[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)rLs r' _torchscript_type_to_python_typerRWs &&(: ;;r& ts_schemac zSSKJn /nURGH)n[UR5nUR 5(a UR O URnURS:wa UROSnUR(a URO URnUS:XaXqR:XdeURn[U5HTupU RUR:XdeU"U RURU RU R S9X('MV UR#U"XgXTS95 GM, UR$V s/sHn [U R5PM n n ['U 5S:XaSn O ['U 5S:XaU Sn O [)U 5n [R*"X,S9$s sn f) Nr) Parameterr,inputfrom)r>kinddefault annotationr )return_annotation)r3rU argumentsrRtypehas_default_value default_valueemptyr> kwarg_only KEYWORD_ONLYPOSITIONAL_OR_KEYWORDPOSITIONAL_ONLY enumeraterXrYrZr2returnslenr! Signature) rSrU parametersargarg_typerYr>rXidxpret return_types return_types r'%_torchscript_schema_to_signature_implrq`s""$J""3CHH='*'<'<'>'>###IOO 88v-sxx7~~  " "00 6>::: ::,,D#J/vv!@!@@@@"+"22II || # 0  4G Q ;#B?H>O>O>Os(2>O <A \ a "1o L)   Z GGsF8_SCHEMA_TO_SIGNATURE_CACHEcURUR4n[RU5nUbU$[ U5nU[U'U$r+)r> overload_namerrgetrq)rS cache_key cache_valress r' _torchscript_schema_to_signaturerysN 7 77I*..y9I / :C,/y) Jr&targetr)r.rrc8[USS9up4U(avU(an/n[X45H*upgUR"U0UD6 URXg45 M, Sn[ U5S:Xag[ U5S:XaUSupU"U 5 gggg![a Mpf=f)NT)return_schemascDUR(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_mutabler=)schemas r'throw_if_mutable5check_for_mutable_operation..throw_if_mutables/  "7x@()!r&rr )rzipbindr2 TypeErrorrg) rzrrr6schemasmatched_schemascandidate_signaturerr_schema_to_checks r'rrs5VDQJg ,/z+C '  #(($9&9&&(;'DE,D   1 $   !Q &!0!3 A _ - ?z  s$B  BBopr|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(rur<jit _builtins _find_builtin_C_jit_get_schemas_for_operatorry)rr|roverloadoverrideaten_fnrr6s r'rrs "j!!::, B( ) )ACPX72(00P$((, '5Hd# ?4 ?))%%33B7 ?#1< ;t ;((88AIPQv26:JQ$2J B BQRs D0Dc[U[[45(a[U[5(aSnOSn[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`. c[U$r+)listxs r'ret_type"create_type_hint..ret_types 7Nr&c[US4$)N.)r!rs r'rrs C=(r&rz@We were not able to successfully create type hint from the type ) rrr!rgr issubclass Exceptionwarningswarn)rr base_typerAs r'rrs a$ ' '!T""# )1v{}$!Ia++ -- !I#C=( I& &- (8 H   Nqc R  H  sAB=B B#CCsignature_type argument_typec^^[USU5nUTLagU[RLa'UT:wa!URn[ U4SjU55$[USS5[ LaURSmT[ La T[ Lag[R"T5(d[R"SUS35 g[TSS5[ La[TRST5$U4SjnU"T5$U[ LaT[RLagU[RLaT[ [ 1;ag[R"T5(a'[R"U5(a [TU5$g) N __origin__Tc3<># UHn[UT5v M g7fr+)r).0crs r' type_matches..'sI=a<=11=srz.Does not support nested parametric types, got z. Please file a bug.Fc>[USS5[LagURnURS:Xag[U4SjU55$)NrF)rTc3X># UHo[L=(d [UT5v M! g7fr+)Ellipsisr)rr sig_el_types r'r=type_matches..is_homogeneous_tuple..>s"XiX D*Q *DDis'*)rr!__args__all)rA containedrs r'is_homogeneous_tuple*type_matches..is_homogeneous_tuple8s@q,-U: IzzU"XiXX Xr&)rtypingUnionranyrintr3isclassrrrr<dtypenumbersNumberfloat)rrsig_origin_type sig_containedrrs ` @r'rrsKnlNKO&&,,&>]+J&// I=III~|T2d:$--a0  C K3$6{++ MM@@PPde  =, 5 =m44Q7E E Y$M22%++!='Mc5\,I}%%'//.*I*I-88 r&. arg_types kwarg_typesnormalize_to_only_use_kwargscXUc0nSn[U[R5(d[U[[45(dUnU[ ;an[U[ 5(ae[ UnUSUSp[R"U 5R[R"U 5R:wagU n[U5(de[R"[R"U55n [XX%5nU$[U5(de[U5n /n U (GaYU H'nUR"U0UD6 U RU5 M) [#U 5S:XaU$[#U 5S:Xa[U SXU5nU$UcUbU(aUO[%[&[(S5nU(aUO0nU HnSnUR"U0UD6nUR*R-5H4unnURUnU=(a [/UR0U5nM6 U(dMs[UUUU5n U$ U$S R3S U 55n[5S [6R8"U5S U35eU$![ a GMgf=f![ a SnN~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. Nif_trueif_falserr rTF 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: )rtypesBuiltinFunctionTyper r r r$r3r4ricallableunwrap&_args_kwargs_to_normalized_args_kwargsrrr2rrgrr!rr\itemsrrZjoinr=r<typename)rzrrrrrnew_args_and_kwargstarget_for_analysis dispatchedrrsigtorch_op_schemasrr sig_matches bound_typesarg_namerkparamschema_printoutss r'rrOs>~ fe77 8 86,j9::$ ' ' "&#.. ..+F3J *9 5z*7MX!!'*55$$X.99:") +,,,,/B CDD v B {5f= (8#',,d=f=#**+>?(8?#q(Z Y_%*&L#A&6R'#T M(K,C-6 DsR>&;Q:RSOO_N`b e!4 )0*/K0s%3#JA$J JJ J)(J)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_submoduleAttributeErrorr=hasattr __class__rrr<nnr3r4rforwardr) rrzrrrsubmode classnamerrs r'rrs6##F+ v,,$$-- 588Y -1A1A A##GNN6>>$BCC~"H6# ' &  26(;  !  sB55 C?CCrcd^ [RR[RR1m [ U 4SjUR R 555(a*[UR R55/SQ:wagUR"U0UD6nUR5 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+)rX)rrmsupported_parameter_typess r'r9_args_kwargs_to_normalized_args_kwargs..s Trs  KK 23) e,Z->@4$w'8'8"99:?  $4#5%-- @@llllllnnii99}}%'T ##    VA#FA.q <.@