o eiZ@srUddlZddlZddlZddlZddlZddlZddlmZddlmZm Z m Z m Z m Z ddl Z ddlmZddlmZmZddlmZe rMddlmZgd Zed d Gd d d e ZiZeeeejfed<ddZeee j<GdddZ e j!e j"e j#ej$e j%j&ej'e j(e e)de j*e+ded Z,e-eD] Z.e/ee.e,e.<qdddefddZ0de j1j2dejfddZ3iZ4ee5e6e6fejfed<de j1j2dejfddZ7ed d d ed!e5d"d#ee6d$ffd%d&Z8ed d d?d'ed(e9fd)d*Z:ed d d+d,Z;ed d d-ed.efd/d0Zed d   dAd9e j?j@d e6d!e5ed#e ee6efd4e9de ef d:d;ZAdZBdS)BN)Callable)Anycast 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@s2eZdZUdZeedfed<eeefed<dS)rz< Simple named tuple for wrapping args/kwargs pairs. .argskwargsN) __name__ __module__ __qualname____doc__tupler__annotations__dictstrr r c/var/www/addictedbytheproject.nl/epg/venv/lib/python3.10/site-packages/torch/fx/operator_schemas.pyr s r_manual_overridescCs>g}dd}|t|dtfdd}|t||S)NcSdSNr )selfr r r!nonzero0z!_nonzero_schemas..nonzeroas_tuplecSr#r$r )r%r(r r r!r&5r')appendinspect signaturebool) signaturesr&r r r!_nonzero_schemas-s r.c@seZdZddZdS)_FakeGlobalNamespacecCs|dkrtStd)Ntorchz!Expected a torch namespace lookup)r0 RuntimeError)r%namer r r! __getattr__Asz _FakeGlobalNamespace.__getattr__N)rrrr3r r r r!r/@s r/t) TensorDeviceLayoutnumberFuture AnyEnumTypeQScheme __torch__NoneTypeStorager4PyObjectts_typeztorch._C.JitTypereturncCs 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) )evalannotation_str_type_eval_globals)r@r r r! _torchscript_type_to_python_typeYs rE ts_schemac Cs<ddlm}g}|jD]k}t|j}|r|jn|j}|jdkr$|jnd}|j r,|j n|j }|dkrk||j kr?t d||j }t|D]$\}} | j|j kr\t d| jd| j|| j|j | j| jd ||<qF||||||d q d d |jD} t| dkrd} nt| d kr| d} nt| } tj|| d S)Nr) Parameterr%inputfromz$Expected POSITIONAL_OR_KEYWORD, got z)Expected POSITIONAL_OR_KEYWORD for param z, got )r2kinddefault annotationcSsg|]}t|jqSr )rEtype).0retr r r! s z9_torchscript_schema_to_signature_impl..r )return_annotation)r*rG argumentsrErMhas_default_value default_valueemptyr2 kwarg_only KEYWORD_ONLYPOSITIONAL_OR_KEYWORDAssertionErrorPOSITIONAL_ONLY enumeraterJrKrLr)returnslenr Signature) rFrG parametersargarg_typerKr2rJidxp return_types return_typer r r!%_torchscript_schema_to_signature_implbsJ         rf_SCHEMA_TO_SIGNATURE_CACHEcCs6|j|jf}t|}|dur|St|}|t|<|Sr$)r2 overload_namerggetrf)rF cache_key cache_valresr r r! _torchscript_schema_to_signatures  rmtargetr)r .rr c Cst|dd\}}|rS|rUg}t||D]\}}z|j|i||||fWqty1Yqwdd}t|dkr>dSt|dkrP|d\} } || dS dSdSdS)NT)return_schemascSs|jr td|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) is_mutabler1)schemar r r!throw_if_mutables  z5check_for_mutable_operation..throw_if_mutablerr )rzipbindr) TypeErrorr]) rnrrr-schemasmatched_schemascandidate_signaturerqrr_schema_to_checkr r r!rs$     roprocsttr jg}n7ttrfddD}n&t}|r*|r(|dfSdStjj }|dur;|r9dSdStj |}dd|D}|rN||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)rNoverloadr{r r!rPsz.get_signature_for_torch_op..N)NNcSsg|]}t|qSr )rmrNrqr r r!rPs) isinstancer r}r overloadsr"rir0jit _builtins _find_builtin_C_jit_get_schemas_for_operator)r{rorvoverrideaten_fnr-r rr!rs      rcCszEt|ttfrCt|trdd}ndd}t|dkr!|tWS|d}|D]}t||r/q't||r7|}q'|tWS||WSW|StyWtd|Y|Sw)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$)listxr r r!ret_type sz"create_type_hint..ret_typecSs t|dfS)N.)rrr r r!rs rz@We were not able to successfully create type hint from the type ) rrrr]r issubclass Exceptionwarningswarn)rr base_typer4r r r!rs.         rsignature_type argument_typecst|d|}|ur dS|tjur#|kr#|j}tfdd|DSt|ddturd|jdtur:tur:dStsJt d|ddStddturZt jdSfd d }|S|turot j urodS|tjur|tthvr|dStrt|rt |SdS) N __origin__Tc3s|]}t|VqdSr$)rrNc)rr r! /ztype_matches..rz.Does not support nested parametric types, got z. Please file a bug.Fcs>t|ddtur dS|j}|jdkrdStfdd|DS)NrF)r Tc3s"|] }|tup t|VqdSr$)Ellipsisrr sig_el_typer r!rFs z=type_matches..is_homogeneous_tuple..)r|r__args__all)r4 containedrr r!is_homogeneous_tuple@s  z*type_matches..is_homogeneous_tuple)r|typingUnionranyrintr*isclassrrrr0dtypenumbersNumberfloat)rrsig_origin_type sig_containedrr )rrr!r$s4       r. arg_types kwarg_typesnormalize_to_only_use_kwargscCs8t||||||}|durtd|d|d||S)zb Wrapper around normalize_function that never returns None, but loudly errors instead NzFailed to normalize function z with args z and kwargs )rr1)rnrrrrrrlr r r!_normalize_function_or_errorWs rc Csp|duri}d}t|tjst|ttfst|dr|j}t|tjstt|ttfst|}|tvrVt|tr9t dt|}|d|d} } t | j t | j krTdS| }t |sct dt|t t |} t| |||}|St |st dt|t|} g} | r6| D]}z|j|i|| |WqtyYqwt| dkr |St| d krt| d|||}|S|dus|dur|r|ntttd }|r|ni}| D]?}d }z!|j|i|}|jD]\}}|j |}|ot|j|}qWn tyd }Ynw|rt||||}|Sq|Sd dd| D}tdt |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_opz"target should not be a string hereif_trueif_falsez*target_for_analysis must be callable, got ztarget must be callable, got rr r TF css|]}t|VqdSr$)rrr r r!rs z%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: )!rtypesBuiltinFunctionTyper r hasattrrrrrYr*r+r_callablerMunwrap&_args_kwargs_to_normalized_args_kwargsrrtr)rur]rrrrRitemsrrLjoinr1r0typename)rnrrrrrnew_args_and_kwargstarget_for_analysis dispatchedrrsigtorch_op_schemasrwrx sig_matches bound_typesarg_nameraparamschema_printoutsr r r!ros        B  -  *    rrootc Csz||}Wnty}z td|d|d}~wwt|jdrI|jj}ttj|d|jkrIt t |j }|dur@i}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) get_submoduleAttributeErrorr1r __class__rr|r0nnr*r+rforwardr) rrnrrrsubmode classnamerrr r r!rs*  rrc stjjtjjhtfdd|jDr#t|jgdkr#dS|j |i|}| i}g}t |jD]\}}|sM|t |krM| |j|q8|j|||<q8tt||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$)rJ)rNrcsupported_parameter_typesr r!rHrz9_args_kwargs_to_normalized_args_kwargs..)rHrIto generatorN)r*rGrXrWrr_valuesrkeysrtapply_defaultsr[r]r)rRrr) rrrr bound_args new_kwargsnew_argsirr rr!r*sr)F)NNNF)NF)Cenumr*rrrrcollections.abcrrrrrrr0torch._jit_internalr torch._opsr r _compatibilityr noder __all__rr"rrr^rr.r&r/r5devicelayoutrrr9EnumqschemerMUntypedStorageTypeVarrDdirkr|rErFunctionSchemarfrgrrrmrr,rrrrrrModulerrr r r r!s           9   '" ,2        .