o j9:j]@srUddlZddlZddlZddlZddlZddlZddlmZddlmZm Z m Z m Z m Z m Z ddlZddlmZddlmZmZddlmZddlmZe rUdd lmZgd Zed d Gd dde ZiZeedefeejfe d<deejfddZ!e!eej"<GdddZ#ej$ej%ej&ej'ej(j)ej*ej+e#e,dej-e.ded Z/e0eD] Z1e2ee1e/e1<qdddefddZ3dej4j5dejfddZ6iZ7ee8e9e9fejfe d<dej4j5dejfd d!Z:ed d d"edefd#e8d$d%ee9d&fddfd'd(Z;e d)edefd*e d+de8eejdBeej4j5dBffd,d-Zde>fd1d2Z?ed d d3ed4ede=fd5d6Z@ed d     dFd"edefd#e8edfd%ee9efdBd7e8edBd8ee9efdBd9e=defd:d;ZAed d     dFd"edefd#e8edfd%ee9efdBd7e8edBd8ee9efdBd9e=dedBfdejCjDd"e9d#e8ed%ee9efdBd9e=dedBf d?d@ZEdAejd#e8edfd%ee9efd9e=dedBf dBdCZFdS)HN)Callable)AnycastLiteral NamedTupleoverload TYPE_CHECKING)boolean_dispatched) OpOverloadOpOverloadPacket) _fast_bind) 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"`/home/nk/hobo-godmode/plappi-mvp/.venv/lib/python3.10/site-packages/torch/fx/operator_schemas.pyr s r._manual_overridesreturncCsTg}dtjddfdd}|t|dtjdtddfdd}|t||S)Nselfr%cSdSNr")r&r"r"r#nonzero0z!_nonzero_schemas..nonzeroas_tuplecSr'r(r")r&r+r"r"r#r)5r*)torchTensorappendinspect signaturebool) signaturesr)r"r"r#_nonzero_schemas-s r3c@s eZdZdedejfddZdS)_FakeGlobalNamespacenamer%cCs|dkrtStd)Nr,z!Expected a torch namespace lookup)r, RuntimeError)r&r5r"r"r# __getattr__Asz _FakeGlobalNamespace.__getattr__N)rrrr!types ModuleTyper7r"r"r"r#r4@sr4t) r-DeviceLayoutnumberFuture AnyEnumTypeQScheme __torch__NoneTypeStorager:PyObjectts_typeztorch._C.JitTypecCs 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)rEr"r"r# _torchscript_type_to_python_typeYs rI 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 )r5kinddefault annotationcSsg|]}t|jqSr")rItype).0retr"r"r# s z9_torchscript_schema_to_signature_impl..r )return_annotation)r/rK argumentsrIrQhas_default_value default_valueemptyr5 kwarg_only KEYWORD_ONLYPOSITIONAL_OR_KEYWORDAssertionErrorPOSITIONAL_ONLY enumeraterNrOrPr.returnslenr Signature) rJrK parametersargarg_typerOr5rNidxp return_types return_typer"r"r#%_torchscript_schema_to_signature_implbsJ         rj_SCHEMA_TO_SIGNATURE_CACHEcCs6|j|jf}t|}|dur|St|}|t|<|Sr()r5 overload_namerkgetrj)rJ cache_key cache_valresr"r"r# _torchscript_schema_to_signatures  rqtargetr)r.rrc Cst|dd\}}|r]|r_g}t||D]!\}}zt|g|Ri||||fWqty4Yqwdtjjddfdd}t|dkrHdSt|dkrZ|d\} } || dS dSdSdS) NT)return_schemasschemar%cSs|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_mutabler6)rtr"r"r#throw_if_mutables  z5check_for_mutable_operation..throw_if_mutablerr ) rzipr r. TypeErrorr,_CFunctionSchemara) rrrrr2schemasmatched_schemascandidate_signaturertrv_schema_to_checkr"r"r#rs$     roprsTcCr'r(r"rrsr"r"r#rrcCr'r(r"rr"r"r#rrcsttr 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)rRrrr"r#rTsz.get_signature_for_torch_op..N)NNcSsg|]}t|qSr")rqrRrtr"r"r#rTs) isinstancer rr overloadsr$rmr,jit _builtins _find_builtinry_jit_get_schemas_for_operator)rrsr{overrideaten_fnr2r"rr#rs      xcCszOt|ttfrMt|trdtdtfdd}n dtdtfdd}t|dkr+|tWS|d}|D]}t||r9q1t||rA|}q1|tWS||WSW|Styatd|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`. rr%cSst|Sr()listrr"r"r#ret_typesz"create_type_hint..ret_typecSs t|dfS)N.)rrr"r"r#r"s rz@We were not able to successfully create type hint from the type ) rrrrra issubclass Exceptionwarningswarn)rr base_typer:r"r"r#r s.        rsignature_type argument_typecs$t|d|}|ur dS|tjur#|kr#|j}tfdd|DSt|ddturi|jdtur:tur:dStsJt d|ddStddturZt jdSd t d t ffd d }|S|turttjurtdS|tjurtthvrdStrt|rt |SdS) N __origin__Tc3s|]}t|VqdSr()rrRc)rr"r# Cztype_matches..rz.Does not support nested parametric types, got z. Please file a bug.Fr:r%cs>t|tur dSt|}|dkrdStfdd|DS)NF)r"Tc3s"|] }|tup t|VqdSr()Ellipsisrr sig_el_typer"r#rZs z=type_matches..is_homogeneous_tuple..)typing get_originrget_argsall)r: containedrr"r#is_homogeneous_tupleTs  z*type_matches..is_homogeneous_tuple)rrUnion__args__anyrintr/isclassrrrobjectr1r,dtypenumbersNumberfloat)rrsig_origin_type sig_containedrr")rrr#r8s4      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 )rr6)rrrrrrrrpr"r"r#_normalize_function_or_errorks rc Cs~|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} | r=| D]}zt|g|Ri|| |WqtyYqwt| dkr |St| d krt| d|||}|S|dus|dur&|r|ntttd }|r|ni}| D]C}d }z%t|g|Ri|}|jD]\}}|j |}|ot|j|}qWn tyd }Ynw|r#t||||}|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()r!rr"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: )!rr8BuiltinFunctionTyper r hasattrrr r!r]r/r0rccallablerQunwrap&_args_kwargs_to_normalized_args_kwargsrr r.rxrarrrrVitemsrrPjoinr6r,typename)rrrrrrrnew_args_and_kwargstarget_for_analysis dispatchedrrsigtorch_op_schemasr|r} sig_matches bound_typesarg_namereparamschema_printoutsr"r"r#rs        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_submoduleAttributeErrorr6r __class__rrr,nnr/r0rforwardr) rrrrrrsubmode classnamerrr"r"r#rs*  rrc stjjtjjhtfdd|jDr#t|jgdkr#dSt |g|Ri|}| i}g}t |jD]\}}|sP|t |krP| |j|q;|j|||<q;tt||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()rN)rRrgsupported_parameter_typesr"r#r\rz9_args_kwargs_to_normalized_args_kwargs..)rLrMto generatorN)r/rKr\r[rrcvaluesrkeysr apply_defaultsr_rar.rVrr) rrrr bound_args new_kwargsnew_argsirr"rr#r>sr).)F)NNNF)NF)Genumr/rr8rrcollections.abcrrrrrrrr,torch._jit_internalr torch._opsr r torch.utils._inspectr _compatibilityrnoder__all__rr$r rrbrr3r)r4r-devicelayoutrrr>EnumqschemerQUntypedStorageTypeVarrHdirkrrIryrzrjrkrr!rqrrr1rrrrrrModulerrr"r"r"r#sB        "     9    )         (,2          .