jU|UddlZddlZddlZddlZddlZddlZddlmZmZmZm Z m Z m Z m Z m Z mZddlZddlmZddlmZmZddlmZerddlmZgdZed Gd d e ZiZe ee ejfed <dZeeej<GddZ ej!ej"ej#ej$ej%j&ej'ej(e e)dej*ej+dd Z,e-eD]Z.e/ee.e,e.<dddefdZ0dej1j2dejfdZ3iZ4e e e5e5fejfed<dej1j2dejfdZ6ed dede dde e5dffd Z7ed d1d!ed"e8fd#Z9ed d$Z:ed d%ed&efd'Z;ed  d2dede ede e e5efd(e e ed)e e e5efd*e8de efd+Z<ed  d3d,ej=j>de5de ede e e5efd*e8de ef d-Z?d.ejde ed/fde e5efd*e8de ef d0Z@dS)4N) AnyCallablecastDictList NamedTupleOptionalTuple TYPE_CHECKING)boolean_dispatched) OpOverloadOpOverloadPacket) compatibility)Argument)ArgsKwargsPaircheck_for_mutable_operationget_signature_for_torch_opcreate_type_hint type_matchesnormalize_functionnormalize_moduleF)is_backward_compatiblecHeZdZUdZeedfed<eeefed<dS)rz< Simple named tuple for wrapping args/kwargs pairs. .argskwargsN) __name__ __module__ __qualname____doc__r r__annotations__rstrJC:\Projects\Historical\venv\Lib\site-packages\torch/fx/operator_schemas.pyrr)sF S/ cNr$r_manual_overridescg}d}|tj|dtfd}|tj||S)NcdSNr#)selfs r%nonzeroz!_nonzero_schemas..nonzero9 r$as_tuplecdSr)r#)r*r-s r%r+z!_nonzero_schemas..nonzero>r,r$)appendinspect signaturebool) signaturesr+s r%_nonzero_schemasr46syJ   g'00111 4    g'00111 r$ceZdZdZdS)_FakeGlobalNamespacec:|dkrtStd)Ntorchz!Expected a torch namespace lookup)r8 RuntimeError)r*names r% __getattr__z _FakeGlobalNamespace.__getattr__Js 7??L>???r$N)rrrr;r#r$r%r6r6Is(@@@@@r$r6t) 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)rGs r% _torchscript_type_to_python_typerMas &(: ; ;;r$ ts_schemac ddlm}g}|jD]}t|j}|r|jn|j}|jdkr|jnd}|j r|j n|j }|dkra||j ksJ|j }t|D]=\}} | j|j ksJ|| j|j | j| j||<>||||||d|jD} t'| dkrd} n+t'| dkr | d} nt)| } tj|| S) Nr) Parameterr*inputfrom)r:kinddefault annotationc6g|]}t|jSr#)rMtype).0rets r% z9_torchscript_schema_to_signature_impl..s07:(22r$r)return_annotation)r0rP argumentsrMrWhas_default_value default_valueemptyr: kwarg_only KEYWORD_ONLYPOSITIONAL_OR_KEYWORDPOSITIONAL_ONLY enumeraterSrTrUr/returnslentuple Signature) rNrP parametersargarg_typerTr:rSidxp return_types return_types r%%_torchscript_schema_to_signature_implrpjs"!!!!!"$J"  3CH=='*'<'<'>'>S###IO 8v--sxx7~ 1I " "0 6>>9:::::,D#J//  Qv!@@@@@"+)"2I | ### 3  I4dG Q Q Q    >G>OL <A \  a  "1o L))  Z; G G GGr$_SCHEMA_TO_SIGNATURE_CACHEc|j|jf}t|}||St |}|t|<|Sr))r: overload_namerqgetrp)rN cache_key cache_valress r% _torchscript_schema_to_signaturerxsO 77I*..y99I / : :C,/y) Jr$targetr)r.rrc^t|d\}}|r|rg}t||D]:\}} |j|i||||f+#t$rY7wxYwd}t |dkrdSt |dkr|d\} } || dSdSdSdS)NT)return_schemasc:|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) is_mutabler9)schemas r%throw_if_mutablez5check_for_mutable_operation..throw_if_mutables?  "))))  r$rr)rzipbindr/ TypeErrorrf) ryrrr3schemasmatched_schemascandidate_signaturer~r_schema_to_checks r%rrs(5VDQQQJg ,/z7+C+C   '  (#($9&999&&(;V'DEEEE          1 $ $ D  ! !Q & &!0!3 A  _ - - - - - D?s$A A#"A#opr{cttr jg}nttr!fdD}not }|r|r|dfndStjj }||rdndStj |}d|D}|r||fn|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 c:g|]}t|jSr#)getattr_schema)rXoverloadrs r%rZz.get_signature_for_torch_op..s&PPPX72x((0PPPr$N)NNc,g|]}t|Sr#)rxrXr~s r%rZz.get_signature_for_torch_op..s!QQQv26::QQQr$) isinstancer rr overloadsr&rtr8jit _builtins _find_builtin_C_jit_get_schemas_for_operator)rr{roverrideaten_fnr3s` r%rrs "j!! B:, B( ) ) BPPPPPPP$((,,  @'5?Hd##4 ?)%33B77 ?#1;<.ret_type s 7Nr$c t|dfS)N.)r rs r%rz"create_type_hint..ret_types C=(r$rz@We were not able to successfully create type hint from the type ) rlistrgrfr issubclass Exceptionwarningswarn)rr base_typer<s r%rrs- a$ ' ' '!T"" )#### )))1vv{{x}}$!I ) )a++) 1--) !II#8C==(((8I&& &- '.     Rq R R      HsAB+AB+ B++!CCsignature_type argument_typec t|d|}|urdS|tjur(|kr"|j}t fd|DS|t t ur t urdSt|ddtt hvr|jdtj stj d|ddStddtt hvrtjdSfd}|S|t urtjurdS|tjurt t"hvrdStj r$tj |rt|SdS) N __origin__Tc38K|]}t|VdSr))r)rXcrs r% ztype_matches..1s-IIa<=11IIIIIIr$rz.Does not support nested parametric types, got z. Please file a bug.Fct|ddtthvrdS|j}|jdkrdSt fd|DS)NrF)r#Tc3JK|]}|tupt|VdSr))Ellipsisr)rXr sig_el_types r%rz=type_matches..is_homogeneous_tuple..Gs6XXX D*Q *D*DXXXXXXr$)rrgr __args__all)r< containedrs r%is_homogeneous_tuplez*type_matches..is_homogeneous_tupleAs_q,--eU^CCu IzU""tXXXXiXXXXX Xr$)rtypingUnionranyrintrr0isclassrrrr8dtypenumbersNumberfloat)rrsig_origin_type sig_containedrrs ` @r%rr&snlNKKO&&t&,&&>]+J+J&/ IIII=IIIIIIc""}';';t~|T22tTlBB$-a0 {++  Meeee   5 =, 5 5$ E Em4Q7EE E Y Y Y Y Y$#M222%+!=!=t''Mc5\,I,It}%%9'/.*I*I9-888 5r$ arg_types kwarg_typesnormalize_to_only_use_kwargsc*|i}d}t|tjst|ttfs|}|t vrlt|t rJt |}|d|d} } tj| j tj| j krdS| }t|sJtjtj |} t| |||}nt|sJt|} g} | ro| D]5} |j|i|| |&#t $rY2wxYwt#| dkrn"t#| dkrt| d|||}n|||r|nt%t&t(d}|r|ni}| D]~}d} |j|i|}|jD])\}}|j |}|ot/|j|}*n#t $rd}YnwxYw|rt||||}nnFd d | D}t5d t7j|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_falserrr#TF c34K|]}t|VdSr))r"rs r%rz%normalize_function..s911(.F 111111r$z Tried to normalize arguments to zy but the schema match was ambiguous! Please provide argument types to the normalize_arguments() call. Available schemas: )rtypesBuiltinFunctionTyperr r r"r0r1ricallableunwrap&_args_kwargs_to_normalized_args_kwargsrrr/rrfrr rr\itemsrrUjoinr9r8typename)ryrrrrrnew_args_and_kwargstarget_for_analysis dispatchedrrsigtorch_op_schemasrr sig_matches bound_typesarg_namerkparamschema_printoutss r%rrXs>~ fe7 8 8T6,j9::T% ' ' ' "&#.. . ..+F3J *9 5z*7MXG!'**5$X..9::t") +,,,,,/B C CDDD v;  5f== 8 (8  #,',d=f===#**+>???? H?##q((_%%**&L#A&f6R''##(K,C-6 P DsR&;Q;QbbO_bb s%)"E  EEAH## H21H2rootc ||}n&#t$r}td|d|d}~wwxYwt|jdrs|jj}t tj|d|jkrCtj tj |j }|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_submoduleAttributeErrorr9hasattr __class__rrr8nnr0r1rforwardr) rryrrrsubmode classnamerrs r%rrs6##F++  !6 ! ! !    v,, '$- 58Y - -1A A A#GN6>$B$BCCC~"HT6#?## ' & 4s ;6;r.cL tjjtjjh t fd|jDr.t|jgdkrdS|j |i|}| i}g}t|jD]K\}}|s4|t|kr!| |j|;|j|||<Ltt!||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|] }|jvVdSr))rS)rXrmsupported_parameter_typess r%rz9_args_kwargs_to_normalized_args_kwargs.. s+ T Tq162 2 T T T T T Tr$)rQrRto generatorN)r0rPrbrarrivaluesrkeysrapply_defaultsrdrfr/r\rrg) rrrr bound_args new_kwargsnew_argsirrs @r%rrs06 /&! T T T TCNrs                         22222233333333))))))   e,,,Z-,>@4$w'8"99:???    $4#3#5#5%- @@@@@@@@lllni9}%%''T #      V//A#GFA..q<.@