a,j]UddlZddlZddlZddlZddlZddlZddlmZddlmZm Z m Z m Z m Z m Z ddlZddlmZddlmZmZddlmZddlmZe rdd lmZgd Zed Gd de ZiZeedefeejfe d<deejfdZ!e!eej"<GddZ#ej$ej%ej&ej'ej(j)ej*ej+e#e,dej-ej.ded Z/e0eD]Z1e2ee1e/e1<dddefdZ3dej4j5dejfdZ6iZ7ee8e9e9fejfe d<dej4j5dejfdZ:ed dedefde8d d!ee9d"fddfd#Z;e d$edefd%e d&de8eejdzeej4j5dzffd'Zde>fd+Z?ed d,ed-ede=fd.Z@ed  d:dedefde8edfd!ee9efdzd/e8edzd0ee9efdzd1e=defd2ZAed  d:dedefde8edfd!ee9efdzd/e8edzd0ee9efdzd1e=dedzfd3ZBed  d;d4ejCjDde9de8ed!ee9efdzd1e=dedzf d5ZEd6ejde8edfd!ee9efd1e=dedzf d7ZFdS)<N)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_compatiblecHeZdZUdZeedfed<eeefed<dS)rz< Simple named tuple for wrapping args/kwargs pairs. .argskwargsN) __name__ __module__ __qualname____doc__tupler__annotations__dictstrY/var/www/html/banglarbhumi/venv/lib/python3.11/site-packages/torch/fx/operator_schemas.pyrr sF S/ cNr%r._manual_overridesreturncg}dtjddfd}|tj|dtjdt ddfd}|tj||S)Nselfr(cdSNr$)r*s r&nonzeroz!_nonzero_schemas..nonzero0 r%as_tuplecdSr,r$)r*r/s r&r-z!_nonzero_schemas..nonzero5r.r%)torchTensorappendinspect signaturebool) signaturesr-s r&_nonzero_schemasr8-sJ el t    g'00111 el  $    g'00111 r%c(eZdZdedejfdZdS)_FakeGlobalNamespacenamer(c:|dkrtStd)Nr1z!Expected a torch namespace lookup)r1 RuntimeError)r*r;s r& __getattr__z _FakeGlobalNamespace.__getattr__As 7??L>???r%N)rrrr#types ModuleTyper>r$r%r&r:r:@sA@@(8@@@@@@r%r:t) r2DeviceLayoutnumberFuture AnyEnumTypeQScheme __torch__NoneTypeStoragerAPyObjectts_typeztorch._C.JitTypec6t|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)rLs r& _torchscript_type_to_python_typerQYs &(: ; ;;r% ts_schemac $ddlm}g}|jD]}t|j}|r|jn|j}|jdkr|jnd}|j r|j n|j }|dkr||j krtd||j }t|D]Z\}} | j|j krtd| jd| j|| j|j | j| j ||<[|||||| d |jD} t)| dkrd} n+t)| d kr | d} nt+| } tj|| S) Nr) Parameterr*inputfromz$Expected POSITIONAL_OR_KEYWORD, got z)Expected POSITIONAL_OR_KEYWORD for param z, got )r;kinddefault annotationc6g|]}t|jSr$)rQtype).0rets r& z9_torchscript_schema_to_signature_impl..s07:(22r%r)return_annotation)r4rT argumentsrQr[has_default_value default_valueemptyr; kwarg_only KEYWORD_ONLYPOSITIONAL_OR_KEYWORDAssertionErrorPOSITIONAL_ONLY enumeraterWrXrYr3returnslenr Signature) rRrT parametersargarg_typerXr;rWidxp return_types return_types r&%_torchscript_schema_to_signature_implrtbs "!!!!!"$J"% % 3CH=='*'<'<'>'>S###IO 8v--sxx7~ 1I " "0 6>>y666$%RD%R%RSSS,D$J//  Q6Y<<<(ZAFZZRSRXZZ#,)"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_namerugetrt)rR cache_key cache_valress r& _torchscript_schema_to_signaturer|sO 77I*..y99I / : :C,/y) Jr%targetr)r.rrct|d\}}|r|rg}t||D]=\}} t|g|Ri||||f.#t$rY:wxYwdt jjddfd}t|dkrdSt|dkr|d\} } || dSdSdSdS)NT)return_schemasschemar(c:|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_mutabler=)rs r&throw_if_mutablez5check_for_mutable_operation..throw_if_mutables?  "))))  r%rr) rzipr r3 TypeErrorr1_CFunctionSchemark) r}rrr7schemasmatched_schemascandidate_signaturerr_schema_to_checks r&rrsF 5VDQQQJgSU ,/z7+C+C   '  .@@@@@@@&&(;V'DEEEE     UX%<        1 $ $ D  ! !Q & &!0!3 A  _ - - - - - D?s'A A&%A&oprTcdSr,r$rrs r&rrs SVRUr%cdSr,r$rs r&rrs &)Sr%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)r\rrs r&r^z.get_signature_for_torch_op..s&PPPX72x((0PPPr%N)NNc,g|]}t|Sr$)r|r\rs r&r^z.get_signature_for_torch_op..s!QQQv26::QQQr%) isinstancer rr overloadsr'rxr1jit _builtins _find_builtinr_jit_get_schemas_for_operator)rrroverrideaten_fnr7s` r&rrs,"j!! B:, B( ) ) BPPPPPPP$((,,  @'5?Hd##4 ?)%33B77 ?#1;<.ret_types 7Nr%c t|dfS)N.)r rs r&rz"create_type_hint..ret_type"s C=(r%rz@We were not able to successfully create type hint from the type ) rrr rrk issubclass Exceptionwarningswarn)rr base_typerAs r&rr sS a$ ' ' '!T"" )####### ))))))1vv{{x}}$!I ) )a++) 1--) !II#8C==(((8I&& &- '.     Rq R R      HsA8C ;AC = C !C-,C-signature_type argument_typect|d|}|urdS|tjur(|kr"|j}t fd|DSt|ddt ur|jdt ur t urdStjstj d|ddStddt urtjdSdtd tffd }|S|t urtjurdS|t jurt t$hvrdStjr$tj|rt|SdS) N __origin__Tc38K|]}t|VdSr,)r)r\crs r& ztype_matches..Cs-IIa<=11IIIIIIr%rz.Does not support nested parametric types, got z. Please file a bug.FrAr(ctj|turdStj|}|dkrdSt fd|DS)NF)r$Tc3JK|]}|tupt|VdSr,)Ellipsisr)r\r sig_el_types r&rz=type_matches..is_homogeneous_tuple..Zs6XXX D*Q *D*DXXXXXXr%)typing get_originr get_argsall)rA containedrs r&is_homogeneous_tuplez*type_matches..is_homogeneous_tupleTs` ##500u**IE!!tXXXXiXXXXX Xr%)rrUnion__args__anyrintr4isclassrrrobjectr6r1dtypenumbersNumberfloat)rrsig_origin_type sig_containedrrs ` @r&rr8snlNKKO&&t&,&&>]+J+J&/ IIII=IIIIII~|T22d::$-a0  C  K3$6$64{++  Meeee   5 =, 5 5 = =m4Q7EE E YF Yt Y Y Y Y Y Y$#M222%+!=!=t''Mc5\,I,It}%%9'/.*I*I9-888 5r% arg_types kwarg_typesnormalize_to_only_use_kwargscbt||||||}|td|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 )rr=)r}rrrrrr{s r&_normalize_function_or_errorrks] fi6R  C { YF Y Yt Y YQW Y Y    r%c`|i}d}t|tjs3t|ttfst |dr|j}t|tjst|ttfs|}|tvryt|trtdt|}|d|d} } tj | j tj | j krdS| }t|stdt|tj tj|} t!| |||}nt|stdt|t#|} g} | ru| D]8} t%|g|Ri|| |)#t($rY5wxYwt+| dkrn%t+| d krt!| d|||}n|||r|nt-t.t0d }|r|ni}| D]}d } t%|g|Ri|}|jD])\}}|j |}|ot7|j|}*n#t($rd }YnwxYw|rt!||||}nnFd d| D}t=dt?j |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 rrr$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: )!rr?BuiltinFunctionTyper r hasattrrr r#rgr4r5rmcallabler[unwrap&_args_kwargs_to_normalized_args_kwargsrr r3rrkrr rr`itemsrrYjoinr=r1typename)r}rrrrrnew_args_and_kwargstarget_for_analysis dispatchedrrsigtorch_op_schemasrr sig_matches bound_typesarg_nameroparamschema_printoutss r&rrs=>~ vu8 9 9 F%5z$BCC  FE " "  fe7 8 8Y6,j9::Y% ' ' ' &#&& K$%IJJJ+F3J *9 5z*7MXG!'**5$X..9::t") +,,  XTBU=V=VXX /B C CDDD v;   Q !Of!O!OPP P5f==35 8 (8  #2DTDDDVDDD#**+>???? H?##q((_%%**&L#A&f6R''##(K,C-6 P DsR&;Q;QbbO_bb s%>%G$$ G10G1*AJ>> K  K rootc ||}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_submoduleAttributeErrorr=r __class__rrr1nnr4r5rforwardr) rr}rrrsubmode classnamerrs r&rrs6##F++  !6 ! ! !    v,, '$- 58Y - -1A A A#GN6>$B$BCCC~"HT6#?## ' & 4s ;6;rcR tjjtjjh t fd|jDr.t|jgdkrdSt|g|Ri|}| 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,)rW)r\rqsupported_parameter_typess r&rz9_args_kwargs_to_normalized_args_kwargs..\s+ T Tq162 2 T T T T T Tr%)rUrVto generatorN)r4rTrfrerrmvaluesrkeysr apply_defaultsrirkr3r`rr ) rrrr bound_args new_kwargsnew_argsirrs @r&rr>s76 /&! T T T TCNr s  $$$$$$JJJJJJJJJJJJJJJJ 22222233333333++++++))))))   e,,,Z-,HJ4c*D1B,CCDIII $w01     $4#3#5#5%- @@@@@@@@lllni9}%%''T #      V//A#GFA..q<.@