Vh4SPUddlZddlZddlZddlZddlZddlZddlmZmZmZm Z m Z m Z ddl Z ddl mZddlmZmZddlmZe rddlmZgdZed Gd d e ZiZeeeej6fed <dZeee j<<GddZe j@e jBe jDejFe jHjJejLe jNee(de jRejTdd Z+e,eD]Z-e.ee-e+e-<dddefdZ/de j`jbdej6fdZ2iZ3ee4e5e5fej6fed<de j`jbdej6fdZ6ed dede4ddee5dffd Z7ed d1d!ed"e8fd#Z9ed d$Z:ed d%ed&efd'Z;ed  d2dede4ed(fde ee5efd)e e4ed*e ee5efd+e8de efd,Z<ed  d3d-e jzj|de5de4ede ee5efd+e8de ef d.Z?d/ej6de4ed(fdee5efd+e8de ef d0Z@y)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_compatiblec:eZdZUdZeedfed<eeefed<y)rz< Simple named tuple for wrapping args/kwargs pairs. .argskwargsN) __name__ __module__ __qualname____doc__tupler__annotations__dictstrI/home/dcms/DCMS/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..nonzero4r+r#)appendinspect signaturebool) signaturesr*s r$_nonzero_schemasr3,sTJ g''01 4 g''01 r#ceZdZdZy)_FakeGlobalNamespacec.|dk(rtStd)Ntorchz!Expected a torch namespace lookup)r7 RuntimeError)r)names r$ __getattr__z _FakeGlobalNamespace.__getattr__@s 7?L>??r#N)rrrr:r"r#r$r5r5?s@r#r5t) 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)rFs r$ _torchscript_type_to_python_typerLWs &&(: ;;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)r9kinddefault annotationr )return_annotation)r/rO argumentsrLtypehas_default_value default_valueemptyr9 kwarg_only KEYWORD_ONLYPOSITIONAL_OR_KEYWORDPOSITIONAL_ONLY enumeraterRrSrTr.returnslenr Signature) rMrO parametersargarg_typerSr9rRidxpret return_types return_types r$%_torchscript_schema_to_signature_implrk`s""$J"" 3CHH='*'<'<'>###IOO 88v-sxx7~~  " "00 6>9::: ::,,D#J/ Qvv!@!@@@@"+"22II || # 3   4dG Q ; B?H>O>O7:(2L <A \ a "1o L)   Z; GGs F/_SCHEMA_TO_SIGNATURE_CACHEc|j|jf}tj|}||St |}|t|<|Sr()r9 overload_namerlgetrk)rM cache_key cache_valress r$ _torchscript_schema_to_signaturerssN 7 77I*..y9I / :C,/y) Jr#targetr)r.rrc(t|d\}}|rq|rng}t||D]+\}} |j|i||j||f-d}t |dk(ryt |dk(r|d\} } || yyyy#t$rYmwxYw)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_mutabler8)schemas r$throw_if_mutablez5check_for_mutable_operation..throw_if_mutables/  "7x@()!r#rr )rzipbindr. TypeErrorra) rtrrr2schemasmatched_schemascandidate_signatureryrz_schema_to_checks r$rrs5VDQJg ,/z7+C  '  (#(($9&9&&(;V'DE    1 $   !Q &!0!3 A _ - ?z  s%B BBoprvct|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%ror7jit _builtins _find_builtin_C_jit_get_schemas_for_operatorrs)rrvr~overloadoverrideaten_fnryr2s r$rrs "j!::, B( )ACPX72x(00PP$((, '5Hd# ?4 ?))%%33B7 ?#1< ;t ;((88AIPQv26:QJQ$2J B BQRs C0C5cb t|ttfrnt|trd}nd}t|dk(r |tS|d}|D]+}t ||rt ||r|}|tcS||S |S#t $rtjd|Y|SwxYw)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()listxs 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 ) rrrrar issubclass Exceptionwarningswarn)rr base_typer;s r$rrs a$ '!T"# )1v{}$!I )a+ 1- !I#C=(  )I& &- (8 H   Nqc R  H  sAB 3B =B !B.-B.signature_type argument_typect|d|}|ury|tjur%|k7r |j}t fd|DSt|ddt ur|jdt ur t urytjstjd|dytddt urtjdSfd}|S|t urtjury|tjurt 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|ddtury|j}|jdk(rytfd|DS)NrF)r"Tc3JK|]}|tuxs t|ywr()Ellipsisr)rr sig_el_types r$rz=type_matches..is_homogeneous_tuple..>s$XX D*Q *DDXs #)rr__args__all)r; containedrs r$is_homogeneous_tuplez*type_matches..is_homogeneous_tuple8s@q,-U: IzzU"XiXX Xr#)rtypingUnionranyrintr/isclassrrrr7dtypenumbersNumberfloat)rrsig_origin_type sig_containedrrs ` @r$rrsBnlNKO&&,,&>]+J&// I=III~|T2d:$--a0  C K3$6{+ MM@@PPde  =, 5 =m44Q7E 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 $rYGwxYw#t $rd}YrwxYw) 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!)rrys r$rz%normalize_function..s1(.F 1sz 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!r/r0rccallableunwrap&_args_kwargs_to_normalized_args_kwargsrr|r.r}rarrrrVitemsrrTjoinr8r7typename)rtrrrrrnew_args_and_kwargstarget_for_analysis dispatchedrrsigtorch_op_schemasrr sig_matches bound_typesarg_namereparamschema_printoutss r$rrOs >~ fe77 86,j9:$ ' ' "&#. ..+F3J *9 5z*7MXG!!'*55$$X.99:") +,,,/B CDD v; B {5f= (8 #,',,d=f=#**+>? ?#q(Z Y_%*&L#A&f6R'#T M(K,C-6 DsR>&;Q:RSOO_N`b e!4 )0*/K0s%#IAI II I%$I%rootc |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_submoduleAttributeErrorr8hasattr __class__rrr7nnr/r0rforwardr) rrtrrrsubmode classnamerrs r$rrs6##F+ v,$$-- 588Y -1A1A A##GNN6>>$BCC~"HT6#?# ' &  26(;  !  sB.. C 7CC rcH 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()rR)rrgsupported_parameter_typess r$rz9_args_kwargs_to_normalized_args_kwargs..s Tq1662 2 Ts)rPrQto generatorN)r/rOr]r\rrcvaluesrkeysr|apply_defaultsr_rar.rVrr) rrrr bound_args new_kwargsnew_argsirrs @r$rrs6 //&&! TCNNrs  KK 23) e,Z->@4$w'8'8"99:?  $4#5%-- @@llllllnnii99}}%'T ##    V/A#FA.q/<.@