קgcQzUddlZddlZddlZddlZddlZddlZddlZddlmZmZm Z m Z m Z m Z m Z mZmZddlmZddlmZddlmZmZerddlmZgdZed 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) AnyCallableDictListOptionalTuple NamedTuplecast TYPE_CHECKING)boolean_dispatched) compatibility)OpOverloadPacket OpOverload)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__rr__annotations__rstrU/var/www/html/ai-engine/env/lib/python3.11/site-packages/torch/fx/operator_schemas.pyrrsF S/ cNr$r_manual_overridescg}d}|tj|dtfd}|tj||S)NcdSNr#)selfs r%nonzeroz!_nonzero_schemas..nonzero! r$as_tuplecdSr)r#)r*r-s r%r+z!_nonzero_schemas..nonzero%r,r$)appendinspect signaturebool) signaturesr+s r%_nonzero_schemasr4suJ   g'00111 D    g'00111 r$ceZdZdZdS)_FakeGlobalNamespacec:|dkrtStd)Ntorchz!Expected a torch namespace lookup)r8 RuntimeError)r*names r% __getattr__z _FakeGlobalNamespace.__getattr__.s 7??L>???r$N)rrrr;r#r$r%r6r6-s(@@@@@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_typerM<s &(: ; ;;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..\s#\\\34SX>>\\\r$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_implrpDs!!!!!!#%J"aa3CH=='*'<'<'>'>S###IO 8v--sxx7),\y%%Y=\ 6>>9:::::,D#J// E EQv!@@@@@"+)i>WabajwxxD#E#E#E 3))D'V^___````\\)J[\\\L <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_signaturerxhsM 77I*..y99I / : :C,/y) Jr$targetr)r.rrclt|d\}}|r|rg}t||D]A\}} |j|i||||f+#t$r }Yd}~:d}~wwxYwd} 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?  9"$8v$8$8$8999 9 9r$rr )rzipbindr/ TypeErrorrf) ryrrr3schemasmatched_schemascandidate_signaturer~er_schema_to_checks r%rrss04VDQQQJg ,/z7+C+C   '  (#($9&999&&(;V'DEEEE     9 9 9   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$) isinstancerrr 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_types 7Nr$c t|dfS)N.)rrs r%rz"create_type_hint..ret_types C=(r$rz@We were not able to successfully create type hint from the type N) rlistrgrfr issubclass Exceptionwarningswarn)rr base_typer<rs r%rrs4^ a$ ' ' '!T"" )####)))1vv{{x}}$!I ) )a++) 1--) !II#8C==(((8I&& &% '& ^^^ \YZ\\]]]]]]]]^ Hs%AB+AB+ B++ C5CCsignature_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..s-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..s6XXX D*Q *D*DXXXXXXr$)rrgr__args__all)r< containedrs r%is_homogeneous_tuplez*type_matches..is_homogeneous_tuples_q,--eU^CCu IzU""tXXXXiXXXXX Xr$)rtypingUnionranyrintrr0isclassrrrr8dtypenumbersNumberfloat)rrsig_origin_type sig_containedrrs ` @r%rrsnlNKKO&&t&,&&>]+J+J&/ IIII=IIIIIIc""}';';t~|T22tTlBB$-a0 {++  Meeee g g g5 =, 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_kwargscF|i}d}t|tjst|ttfs|}|t vrlt|t rJt |}|d|d} } tj| j tj| j krdS| }t|sJtjtj |} t| |||}nt|sJt|} g} | r}| D]<} |j|i|| |&#t $r }Yd}~5d}~wwxYwt#| dkrn)t#| dkrt| d|||}n|||r|nt%t&t(d}|r|ni}| D]}d} |j|i|}|jD])\}}|j |}|ot/|j|}*n#t $r }d}Yd}~nd}~wwxYw|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_falserr r#TF c34K|]}t|VdSr))r"rs r%rz%normalize_function..is(0[0[V0[0[0[0[0[0[r$z Tried to normalize arguments to zy but the schema match was ambiguous! Please provide argument types to the normalize_arguments() call. Available schemas: )rtypesBuiltinFunctionTyperrr r"r0r1ricallableunwrap&_args_kwargs_to_normalized_args_kwargsrrr/rrfr rrr\itemsrrUjoinr9r8typename)ryrrrrrnew_args_and_kwargstarget_for_analysis dispatchedrrsigtorch_op_schemasrrr sig_matches bound_typesarg_namerkparamschema_printoutss r%rrs6~ fe7 8 8@r6,j9::@r% ' ' ' "&#.. . . .+F3J *9 5z*7MXG ))48I(8S8S8^^^t") +,,,,,/B C CDDDS$PVXtuu5f== ) r(8  #,',d=f===#**+>???? HHHH?##q((_%%**&L_]^M_aegmMi'k'k##(K,C-6 P DsRf>f g )000*/KKKKKK0&"2XYlnrtzYu3w3w/!E"(,yy0[0[?0[0[0['['[$&(q%.Y_J`J`(q(q^n(q(qrrr s+)"E  E E AH** I4H;;Irootc ||}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) rryrrrsubmodr classnamerrs r%rrps.8##F++ 8880&0001167 88v,,'$- 58Y - -1A A A#GN6>$B$BCCC~"HdTZIe#g#g & & 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%rrs.0 /1B1O!Q T T T TCNrs  ^^^^^^^^^^^^^^^^^^^^^^222222))))))33333333 E E Ee,,,Z-,?AD4(9#::;@@@   $4#3#5#5%- @@@@@@@@ "'%,SXS_!(EI#.. 00 V//A#GFA..q