o h@M@sUddlZddlZddlZddlZddlZddlZddlZddlmZmZm Z m Z m Z m Z m Z mZmZddlmZddlmZddlmZmZerOddlmZgdZed d Gd d d e ZiZe ee ejfed <ddZeeej<GdddZ ej!ej"ej#ej$ej%j&ej'ej(e e)de*dd Z+e,eD] Z-e.ee-e+e-<qdddefddZ/dej0j1dejfddZ2ed d dede dde e3d ffd!d"Z4ed d d9d#ed$e5fd%d&Z6ed d d'd(Z7ed d d)ed*efd+d,Z8ed d    d:dede ede e e3efd-e e ed.e e e3efd/e5de efd0d1Z9ed d   d;d2ej:j;de3de ede e e3efd/e5de ef d3d4Zg}dd}|t|dtfdd}|t||S)NcSdSNr!)selfr!r!r"nonzero z!_nonzero_schemas..nonzeroas_tuplecSr$r%r!)r&r)r!r!r"r'$r()appendinspect signaturebool) signaturesr'r!r!r"_nonzero_schemass r/c@seZdZddZdS)_FakeGlobalNamespacecCs|dkrtStd)Ntorchz!Expected a torch namespace lookup)r1 RuntimeError)r&namer!r!r" __getattr__-sz _FakeGlobalNamespace.__getattr__N)rrrr4r!r!r!r"r0,s r0t) TensorDeviceLayoutnumberFuture AnyEnumTypeQScheme __torch__NoneTyper5ts_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_type:s rD ts_schemac Csddlm}g}|jD]\}t|j}|r|jn|j}|jdkr$|jnd}|j r,|j n|j }|dkr\||j ks:J|j }t |D]\}} | j|j ksMJ|| j|j | j| jd||<qA||||||dq dd|jD} t| dkryd} nt| d kr| d} nt| } tj|| d S) Nr) Parameterr&inputfrom)r3kinddefault annotationcSsg|]}t|jqSr!)rDtype).0retr!r!r" Zsz4_torchscript_schema_to_signature..r )return_annotation)r+rF argumentsrDrLhas_default_value default_valueemptyr3 kwarg_only KEYWORD_ONLYPOSITIONAL_OR_KEYWORDPOSITIONAL_ONLY enumeraterIrJrKr*returnslentuple Signature) rErF parametersargarg_typerJr3rIidxp return_types return_typer!r!r" _torchscript_schema_to_signatureBs*      retargetr)r.rrc Cst|dd\}}|r\|r^g}t||D]'\}}z|j|i||||fWqty:}zWYd}~qd}~wwdd} t|dkrGdSt|dkrY|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_mutabler2)schemar!r!r"throw_if_mutableusz5check_for_mutable_operation..throw_if_mutablerr )rzipbindr* TypeErrorr[) rfrrr.schemasmatched_schemascandidate_signaturerierj_schema_to_checkr!r!r"rds(    roprgcsttr 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)rMoverloadrtr!r"rOsz.get_signature_for_torch_op..N)NNcSsg|]}t|qSr!)rerMrir!r!r"rOs) isinstancerrvr overloadsr#getr1jit _builtins _find_builtin_C_jit_get_schemas_for_operator)rtrgrnoverrideaten_fnr.r!rxr"rs      rc CszEt|ttfrCt|trdd}ndd}t|dkr!|tWS|d}|D]}t||r/q't||r7|}q'|tWS||WSW|Sty`}ztd|WYd}~|Sd}~ww)NcSst|Sr%)rxr!r!r"ret_typesz"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 ) rzlistr\r[r issubclass Exceptionwarningswarn)rr base_typer5rqr!r!r"rs.        rsignature_type argument_typecs&t|d|}|ur dS|tjur#|kr#|j}tfdd|DS|ttur/tur/dSt|ddtthvrj|jdt sNt d|ddStddtthvr`t jdSfd d }|S|turut jurudS|tjurtthvrdSt rt |rt |SdS) N __origin__Tc3s|]}t|VqdSr%)rrMc)rr!r" ztype_matches..rz.Does not support nested parametric types, got z. Please file a bug.FcsBt|ddtthvr dS|j}|jdkrdStfdd|DS)NrF)r!Tc3s"|] }|tup t|VqdSr%)Ellipsisrr sig_el_typer!r"rs z=type_matches..is_homogeneous_tuple..)rur\r__args__all)r5 containedrr!r"is_homogeneous_tuples  z*type_matches..is_homogeneous_tuple)rutypingUnionranyrintrr+isclassrrrr1dtypenumbersNumberfloat)rrsig_origin_type sig_containedrr!)rrr"rs4       r arg_types kwarg_typesnormalize_to_only_use_kwargsc CsH|duri}d}t|tjsVt|ttfsV|}|tvr?t|tr"Jt|}|d|d} } t| j t| j kr=dS| }t |sEJtt |} t | |||}|St |s\Jt |} g} | r"| D]#}z|j|i|| |Wqgty}zWYd}~qgd}~wwt| dkr |St| dkrt | d|||}|S|dus|dur |r|ntttd}|r|ni}| D]G}d}z!|j|i|}|jD]\}}|j |}|ot|j|}qWnty}zd}WYd}~nd}~ww|rt ||||}|Sq|Sd 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. Nif_trueif_falserr r!TF css|]}t|VqdSr%)r ryr!r!r"rQsz%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: )rztypesBuiltinFunctionTyperrr r r+r,r^callableunwrap&_args_kwargs_to_normalized_args_kwargsrrlr*rmr[r rrrQitemsrrKjoinr2r1typename)rfrrrrrnew_args_and_kwargstarget_for_analysis dispatchedrrsigtorch_op_schemasrorprq sig_matches bound_typesarg_namer`paramschema_printoutsr!r!r"rs   0        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_submoduleAttributeErrorr2hasattr __class__rrur1nnr+r,rforwardr) rrfrrrsubmodrq classnamerrr!r!r"rXs& rr.c 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%)rI)rMrbsupported_parameter_typesr!r"rrz9_args_kwargs_to_normalized_args_kwargs..)rGrHto generatorN)r+rFrWrVrr^valuesrkeysrlapply_defaultsrYr[r*rQrr\) rrrr bound_args new_kwargsnew_argsirr!rr"rs r)F)NNNF)NF)>r1r+rrrenumrrrrrrrrr r torch._jit_internalr _compatibilityr torch._opsrrnoder__all__rr#r]rr/r'r0r6devicelayoutrr}r:EnumqschemerLTypeVarrCdirkrurDrFunctionSchemarer rr-rrrrrModulerrr!r!r!r"s ,        "$#! /  a &