DŽgcQVUddlZddlZddlZddlZddlZddlZddlZddlmZmZm Z m Z m Z m Z m Z mZmZddlmZddlmZddlmZmZerddlmZgdZed Gd d e ZiZe ee ej8fed <dZeeej><GddZ ejBejDejFejHejJjLejNejPe e)dejTejVdd Z,e-eD]Z.e/ee.e,e.<dddefdZ0dejbjddej8fdZ3iZ4e e e5e5fej8fed<dejbjddej8fdZ6ed dede dde e5dffd Z7ed d1d!ed"e8fd#Z9ed d$Z:ed d%ed&efd'Z;ed  d2dede ede e e5efd(e e ed)e e e5efd*e8de efd+Z<ed  d3d,ejzj|de5de ede e e5efd*e8de ef d-Z?d.ej8de ed/fde e5efd*e8de ef d0Z@y)4N) AnyCallableDictListOptionalTuple NamedTuplecast TYPE_CHECKING)boolean_dispatched) compatibility)OpOverloadPacket OpOverload)Argument)ArgsKwargsPaircheck_for_mutable_operationget_signature_for_torch_opcreate_type_hint type_matchesnormalize_functionnormalize_moduleF)is_backward_compatiblec:eZdZUdZeedfed<eeefed<y)rz< Simple named tuple for wrapping args/kwargs pairs. .argskwargsN) __name__ __module__ __qualname____doc__rr__annotations__rstra/home/mcse/projects/flask_80/flask-venv/lib/python3.12/site-packages/torch/fx/operator_schemas.pyrrs% S/ cNr$r_manual_overridescg}d}|jtj|dtfd}|jtj||S)NcyNr#)selfs r%nonzeroz!_nonzero_schemas..nonzero! r$as_tuplecyr)r#)r*r-s r%r+z!_nonzero_schemas..nonzero%r,r$)appendinspect signaturebool) signaturesr+s r%_nonzero_schemasr4sPJ g''01 D g''01 r$ceZdZdZy)_FakeGlobalNamespacec.|dk(rtStd)Ntorchz!Expected a torch namespace lookup)r8 RuntimeError)r*names r% __getattr__z _FakeGlobalNamespace.__getattr__.s 7?L>??r$N)rrrr;r#r$r%r6r6-s@r$r6t) TensorDeviceLayoutnumberFuture AnyEnumTypeQScheme __torch__NoneTypeStorager<ts_typeztorch._C.JitTypereturnc6t|jtS)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)rGs r% _torchscript_type_to_python_typerM<s &&(: ;;r$ ts_schemac hddlm}g}|jD]#}t|j}|j r |j n |j}|jdk7r |jnd}|jr |jn |j}|dk(r||jk(sJ|j}t|D]W\}} | j|jk(sJ|| j|j| j| j ||<Y|j#|||||&|j$D cgc]} t| j} } t'| dk(rd} nt'| dk(r| d} n t)| } tj*|| Scc} w) Nr) Parameterr*inputfrom)r:kinddefault annotationr )return_annotation)r0rP argumentsrMtypehas_default_value default_valueemptyr: kwarg_only KEYWORD_ONLYPOSITIONAL_OR_KEYWORDPOSITIONAL_ONLY enumeraterSrTrUr/returnslentuple Signature) rNrP parametersargarg_typerTr:rSidxpret return_types return_types r%%_torchscript_schema_to_signature_implrmDs!#%J""a3CHH='*'<'<'>###IOO 88v-sxx7),y%%Y=\=\ 6>9::: ::,,D#J/ EQvv!@!@@@@"+i>W>WabajajwxxDxD#E 3 E )D'V^_`)a*KTJ[J[\34SXX>\L\ <A \ a "1o L)   Z; GG]s F/_SCHEMA_TO_SIGNATURE_CACHEc|j|jf}tj|}||St |}|t|<|Sr))r: overload_namerngetrm)rN cache_key cache_valress r% _torchscript_schema_to_signatureruhsL 7 77I*..y9I / :C,/y) Jr$targetr)r.rrc6t|d\}}|rq|rng}t||D]+\}} |j|i||j||f-d} t |dk(ryt |dk(r|d\} } | | yyyy#t$r }Yd}~pd}~wwxYw)NT)return_schemasc:|jrtd|dy)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_mutabler9)schemas r%throw_if_mutablez5check_for_mutable_operation..throw_if_mutables/  "%FvhO7$899!r$rr )rzipbindr/ TypeErrorrb) rvrrr3schemasmatched_schemascandidate_signaturer{er|_schema_to_checks r%rrss4VDQJg ,/z7+C  '  (#(($9&9&&(;V'DE  9  1 $   !Q &!0!3 A _ - ;z  s%B BBoprxct|tr|jg}nt|tr2|j Dcgc]}t ||j}}not j|}|r|r|dfSdStjjj|}||rdSdStjj|}|Dcgc] }t|}}|r||fS|Scc}wcc}w)a 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&rqr8jit _builtins _find_builtin_C_jit_get_schemas_for_operatorru)rrxroverloadoverrideaten_fnr{r3s r%rrs "j!::, B( )ACPX72x(00PP$((, '5Hd# ?4 ?))%%33B7 ?#1< ;t ;((88AIPQv26:QJQ$2J B BQRs C0C5cp t|ttfrnt|trd}nd}t|dk(r |tS|d}|D]+}t ||rt ||r|}|tcS||S |S#t $r#}tjd|Yd}~|Sd}~wwxYw)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`. ct|Sr))rxs r%ret_typez"create_type_hint..ret_types 7Nr$ct|dfS)N.)rrs r%rz"create_type_hint..ret_types C=(r$rz@We were not able to successfully create type hint from the type N) rlistrcrbr issubclass Exceptionwarningswarn)rr base_typer<rs r%rrs^ a$ '!T"#)1v{}$!I )a+ 1- !I#C=(  )I& &% (, H ^ XYZX[\]] H^s$AB 3B =B B5B00B5signature_type argument_typect|d|}|ury|tjur%|k7r |j}t fd|DS|t t ur t uryt|ddtt hvr}|jdtjstjd|dytddtt hvrtjdSfd}|S|t urtjury|tj urt t"hvrytjr!tj|r t|Sy) N __origin__Tc36K|]}t|ywr))r).0crs r% ztype_matches..sIa<=1Isrz.Does not support nested parametric types, got z. Please file a bug.Fct|ddtthvry|j}|jdk(ryt fd|DS)NrF)r#Tc3JK|]}|tuxs t|ywr))Ellipsisr)rr sig_el_types r%rz=type_matches..is_homogeneous_tuple..s$XX D*Q *DDXs #)rrcr__args__all)r< containedrs r%is_homogeneous_tuplez*type_matches..is_homogeneous_tuplesDq,-eU^C IzzU"XiXX Xr$)rtypingUnionranyrintrr0isclassrrrr8dtypenumbersNumberfloat)rrsig_origin_type sig_containedrrs ` @r%rrsKnlNKO&&,,&>]+J&// I=IIIc"}';~|T2tTlB$--a0 {+ MM@@PPde g =, 5$ Em44Q7E E Y$M22%++!='Mc5\,I}%'//.*I-88 r$ arg_types kwarg_typesnormalize_to_only_use_kwargsc|i}d}t|tjst|ttfs|}|t vrgt|t rJt |}|d|d} } tj| jtj| jk7ry| }t|sJtjtj|} t| |||}|St|sJt|} g} | r;| D]&} |j|i|| j|(t#| dk(r |St#| dk(rt| d|||}|S|||r|nt%t&t(d}|r|ni}| D]v}d} |j|i|}|j*j-D].\}}|j|}|xrt/|j0|}0 |sgt||||}|S|Sd j3d | D}t5d t7j8|d ||S#t $r }Yd}~Jd}~wwxYw#t $r }d}Yd}~|d}~wwxYw) 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 r#TF c32K|]}t|ywr))r")rr{s r%rz%normalize_function..is0[V0[sz Tried to normalize arguments to zy but the schema match was ambiguous! Please provide argument types to the normalize_arguments() call. Available schemas: )rtypesBuiltinFunctionTyperrr r"r0r1recallableunwrap&_args_kwargs_to_normalized_args_kwargsrr~r/rrbr rrrWitemsrrUjoinr9r8typename)rvrrrrrnew_args_and_kwargstarget_for_analysis dispatchedrrsigtorch_op_schemasrrr sig_matches bound_typesarg_namergparamschema_printoutss r%rrs6~ fe77 86,j9:$ ' ' "&#. ..+F3J *9 5z*7MXG  )448I8I(8S8^8^^") +,,,/B CDDS$PVXtu` ]5f= (8 #,',,d=f=#**+>? ?#q(< ;_%*&L_]^M_aegmMi'k#6 1(K,C-6 DsRf g '2XYlnrtzYu3w/! + "*  (,yy0[?0['[$&)I%..Y_J`Iab^^n]o(qrr G!* )0*/K0s+#IAI II I3'I..I3rootc |j|}t|jdr|jj }t tj|d|jk(rFtjtj|j}|i}t||||} | Sy#t$r}td|d|d}~wwxYw)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_submoduleAttributeErrorr9hasattr __class__rrr8nnr0r1rforwardr) rrvrrrsubmodr classnamerrs r%rrps.8##F+v,$$-- 588Y -1A1A A##GNN6>>$BCC~"HdTZIe#g & &  8A&J/0167 88sB.. C 7CC r.cH tjjtjjh t fd|j j Dr)t|j jgdk7ry|j|i|}|ji}g}t|j D]F\}}|s-|t|kr|j|j|5|j|||<Htt!||S)a 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:K|]}|jvywr))rS)rrisupported_parameter_typess r%rz9_args_kwargs_to_normalized_args_kwargs..s Tq1662 2 Ts)rQrRto generatorN)r0rPr^r]rrevaluesrkeysr~apply_defaultsr`rbr/rWrrc) rrrr bound_args new_kwargsnew_argsirrs @r%rrs0 //1B1B1O1O!Q TCNNrs  ^^^2)3 Ee,Z-?AD4(9(9#::;@ $4#5%-- @@ "'%,,SXS_S_!(EII>#. 0 V/A#FA.q/