a h^U @sUddlZddlZddlZddlZddlZddlZddlmZmZmZm Z m Z m Z ddl Z ddl mZddlmZmZddlmZe rddlmZgdZed d Gd d d e ZiZeeeejfed <ddZeee j<GdddZe j e j!e j"ej#e j$j%ej&e j'ee(de j)e*dd Z+e,eD]Z-e.ee-e+e-<q2dedddZ/e j0j1ejdddZ2iZ3ee4e5e5fejfed<e j0j1ejdddZ6ed d ee4dee5dfd d!d"Z7ed d d5ee8d#d$d%Z9ed d d&d'Z:ed d eed(d)d*Z;ed d d6ee4ed+fe ee5efe e4ee ee5efe8e ed,d-d.Ze5e4ee ee5efe8e ed/d0d1Z?eje4ed+fee5efe8e ed2d3d4Z@dS)8N)AnyCallablecast NamedTupleOptional TYPE_CHECKING)boolean_dispatched) OpOverloadOpOverloadPacket) compatibility)Argument)ArgsKwargsPaircheck_for_mutable_operationget_signature_for_torch_opcreate_type_hint type_matchesnormalize_functionnormalize_moduleF)Zis_backward_compatiblec@s2eZdZUdZeedfed<eeefed<dS)rz< Simple named tuple for wrapping args/kwargs pairs. .argskwargsN) __name__ __module__ __qualname____doc__tupler__annotations__dictstrrrG/var/www/auris/lib/python3.9/site-packages/torch/fx/operator_schemas.pyrs r_manual_overridescCs>g}dd}|t|tddd}|t||S)NcSsdSNr)selfrrr nonzero/sz!_nonzero_schemas..nonzero)as_tuplecSsdSr"r)r#r%rrr r$4s)appendinspect signaturebool) signaturesr$rrr _nonzero_schemas,s r+c@seZdZddZdS)_FakeGlobalNamespacecCs|dkr tStddS)Ntorchz!Expected a torch namespace lookup)r- RuntimeError)r#namerrr __getattr__@sz _FakeGlobalNamespace.__getattr__N)rrrr0rrrr r,?sr,t) TensorZDeviceZLayoutnumberFutureZ AnyEnumTypeZQSchemeZ __torch__ZNoneTypeZStorager1ztorch._C.JitType)ts_typereturncCs t|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) )evalZannotation_str_type_eval_globals)r5rrr _torchscript_type_to_python_typeWsr9) ts_schemar6c Cs ddlm}g}|jD]}t|j}|r2|jn|j}|jdkrH|jnd}|j rX|j n|j }|dkr||j kstJ|j }t |D]4\}} | j|j ksJ|| j|j | j| jd||<q||||||dqdd|jD} t| dkrd} n t| d kr | d} nt| } tj|| d S) Nr) Parameterr#inputfrom)r/kinddefault annotationcSsg|]}t|jqSr)r9type).0retrrr sz9_torchscript_schema_to_signature_impl..r )return_annotation)r'r; argumentsr9rAZhas_default_value default_valueemptyr/Z kwarg_only KEYWORD_ONLYPOSITIONAL_OR_KEYWORDPOSITIONAL_ONLY enumerater>r?r@r&returnslenr Signature) r:r; parametersargarg_typer?r/r>idxpZ return_types return_typerrr %_torchscript_schema_to_signature_impl`sB      rV_SCHEMA_TO_SIGNATURE_CACHEcCs6|j|jf}t|}|dur"|St|}|t|<|Sr")r/Z overload_namerWgetrV)r: cache_keyZ cache_valresrrr _torchscript_schema_to_signatures  r[)r .r )targetrrc Cst|dd\}}|r|rg}t||D]B\}}z"|j|i||||fWq&tyfYq&Yq&0q&dd}t|dkrn"t|dkr|d\} } || ndS)NT)return_schemascSs|jrtd|ddS)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)Z is_mutabler.)schemarrr throw_if_mutables z5check_for_mutable_operation..throw_if_mutablerr )rzipbindr& TypeErrorrN) r\rrr*schemasmatched_schemascandidate_signaturer^r__Zschema_to_checkrrr rs       r)opr]csttrjg}nnttr6fddD}nLt}|rT|rP|dfSdStjj }|durv|rrdSdStj |}dd|D}|r||fS|S)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 csg|]}t|jqSr)getattr_schema)rBoverloadrgrr rDz.get_signature_for_torch_op..N)NNcSsg|] }t|qSr)r[rBr^rrr rDrl) isinstancer rir Z overloadsr!rXr-jitZ _builtinsZ _find_builtin_CZ_jit_get_schemas_for_operator)rgr]rcoverrideZaten_fnr*rrkr rs      rcCszt|ttfrt|tr$dd}ndd}t|dkrB|tWS|d}|D]0}t||r`qNqNt||rp|}qN|tWSqN||WSWn"tytd|Yn0|S)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`. cSst|Sr")listxrrr ret_typesz"create_type_hint..ret_typecSs t|dfS)N.)rrsrrr rusrz@We were not able to successfully create type hint from the type ) rnrrrrNr issubclass Exceptionwarningswarn)rtruZ base_typer1rrr rs(         r)signature_type argument_typecst|d|}|urdS|tjurF|krF|j}tfdd|DSt|ddtur|jdturtturtdStst d|ddStddturt jdSfd d }|S|turވt j urdS|tjurtthvrdStrt|rt |SdS) N __origin__Tc3s|]}t|VqdSr")rrBc)r{rr 'rlztype_matches..rz.Does not support nested parametric types, got z. Please file a bug.Fcs>t|ddturdS|j}|jdkr(dStfdd|DS)Nr|F)rTc3s |]}|tupt|VqdSr")Ellipsisrvr} sig_el_typerr r>rlz=type_matches..is_homogeneous_tuple..)rhr__args__all)r1Z containedrrr is_homogeneous_tuple8s  z*type_matches..is_homogeneous_tuple)rhtypingUnionranyrrintr'isclassrxryrvr-ZdtypenumbersNumberfloat)rzr{Zsig_origin_typeZ sig_containedrr)r{rr rs4      r.)r\rr arg_types kwarg_typesnormalize_to_only_use_kwargsr6c Csb|dur i}d}t|tjs:t|ttfs:t|dr:|j}t|tjst|ttfs|}|tvrt|trnJt|}|d|d} } t | j t | j krdS| }t |sJt t |} t| |||}nt |sJt|} g} | r^| D]<}z|j|i|| |Wqty2YqYq0qt| dkrHnt| dkrjt| d|||}n|dus~|dur0|r|n tttd}|r|ni}| D]}d}zF|j|i|}|jD]&\}}|j |}|ot|j|}qWntyd }Yn0|rt||||}q^qn.d d d | D}td t|d||S)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_opif_trueif_falserr rTF css|]}t|VqdSr")rrmrrr rsz%normalize_function..z Tried to normalize arguments to zy but the schema match was ambiguous! Please provide argument types to the normalize_arguments() call. Available schemas: )rntypesBuiltinFunctionTyper r hasattrrrrr'r(rPcallableunwrap&_args_kwargs_to_normalized_args_kwargsrrar&rbrNrrrrFitemsrr@joinr.r-typename)r\rrrrrnew_args_and_kwargsZtarget_for_analysisZ dispatchedrrsigZtorch_op_schemasrdreZ sig_matchesZ bound_typesZarg_namerRparamZschema_printoutsrrr rOs                r)rootr\rrrr6c Csz||}Wn6tyD}ztd|d|WYd}~n d}~00t|jdr|jj}ttj|d|jkrt t |j }|duri}t ||||} | SdS)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)Z get_submoduleAttributeErrorr.r __class__rrhr-nnr'r(rZforwardr) rr\rrrZsubmode classnamerrrrr rs&  r)rrrrr6c stjjtjjhtfdd|jDrFt|jgdkrFdS|j |i|}| i}g}t |jD]8\}}|s|t |kr| |j|qp|j|||<qptt||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. c3s|]}|jvVqdSr")r>)rBrTZsupported_parameter_typesrr r#rlz9_args_kwargs_to_normalized_args_kwargs..)r<r=to generatorN)r'r;rJrIrrPvaluesrrkeysraapply_defaultsrLrNr&rFrr) rrrrZ bound_argsZ new_kwargsnew_argsirrrr rsr)F)NNNF)NF)Aenumr'rrrrxrrrrrrr-Ztorch._jit_internalrZ torch._opsr r Z_compatibilityr noder __all__rr!rrrrOrr+r$r,r2ZdeviceZlayoutrror4EnumZqschemerAZUntypedStorageTypeVarr8dirkrhr9rpZFunctionSchemarVrWrrr[rr)rrrrrModulerrrrrr s           3 '" ,2  /