9j]UddlZddlZddlZddlZddlZddlZddlmZddlmZm Z m Z m Z m Z m Z ddlZddlmZddlmZmZddlmZddlmZe rdd lmZgd Zed Gd de ZiZeedefeej>fe d<deej>fdZ!e!eejD<GddZ#ejHejJejLejNejPjRejTejVe#e,dejZej\ded Z/e0eD]Z1e2ee1e/e1<dddefdZ3dejhjjdej>fdZ6iZ7ee8e9e9fej>fe d<dejhjjdej>fdZ:ed dedefde8d d!ee9d"fddfd#Z;e d$edefd%e d&de8eej>dzeejhjjdzffd'Zdzfd(Z<ed  d9d$edefd%e=deej>e8eej>dzeejhjjdzfzdzfd)Z<ed d*e>de>fd+Z?ed d,ed-ede=fd.Z@ed  d:dedefde8edfd!ee9efdzd/e8edzd0ee9efdzd1e=defd2ZAed  d:dedefde8edfd!ee9efdzd/e8edzd0ee9efdzd1e=dedzfd3ZBed  d;d4ejjde9de8ed!ee9efdzd1e=dedzf d5ZEd6ej>de8edfd!ee9efd1e=dedzf d7ZFy)<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_compatiblec:eZdZUdZeedfed<eeefed<y)rz< Simple named tuple for wrapping args/kwargs pairs. .argskwargsN) __name__ __module__ __qualname____doc__tupler__annotations__dictstrY/media/conek/DATA/Code/OCR/venv/lib/python3.12/site-packages/torch/fx/operator_schemas.pyrr s% S/ cNr%r._manual_overridesreturncg}dtjddfd}|jtj|dtjdt ddfd}|jtj||S)Nselfr(cyNr$)r*s r&nonzeroz!_nonzero_schemas..nonzero0 r%as_tuplecyr,r$)r*r/s r&r-z!_nonzero_schemas..nonzero5r.r%)torchTensorappendinspect signaturebool) signaturesr-s r&_nonzero_schemasr8-sxJ ell t g''01 ell  $ g''01 r%c0eZdZdedej fdZy)_FakeGlobalNamespacenamer(c.|dk(rtStd)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:@s@@(8(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]R}t|j}|j r |j n |j}|jdk7r |jnd}|jr |jn |j}|dk(r||jk7rtd||j}t|D]z\}} | j|jk7r%td| jd| j|| j|j| j | j" ||<||j%||||| U|j&D cgc]} t| j} } t)| dk(rd} nt)| d k(r| d} n t+| } tj,|| Scc} w) Nr) Parameterr*inputfromz$Expected POSITIONAL_OR_KEYWORD, got z)Expected POSITIONAL_OR_KEYWORD for param z, got )r;kinddefault annotationr)return_annotation)r4rT argumentsrQtypehas_default_value default_valueemptyr; kwarg_only KEYWORD_ONLYPOSITIONAL_OR_KEYWORDAssertionErrorPOSITIONAL_ONLY enumeraterWrXrYr3returnslenr Signature) rRrT parametersargarg_typerXr;rWidxpret return_types return_types r&%_torchscript_schema_to_signature_implrqbs""$J""% 3CHH='*'<'<'>###IOO 88v-sxx7~~  " "00 6>y666$'KD6%RSS,,D$J/ Q66Y<<<(CAFF86RSRXRXQYZ#,"22II || # 3   4dG Q G% N?H>O>O7:(2L <A \ a "1o L)   Z; GGs9G_SCHEMA_TO_SIGNATURE_CACHEc|j|jf}tj|}||St |}|t|<|Sr,)r; overload_namerrgetrq)rR cache_key cache_valress r& _torchscript_schema_to_signaturerysN 7 77I*..y9I / :C,/y) Jr%targetr)r.rrc\t|d\}}|r|rg}t||D](\}} t|g|i||j||f*dt j jddfd}t|dk(ryt|dk(r|d\} } || yyyy#t$rYwxYw)NT)return_schemasschemar(c:|jrtd|dy)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=)r}s r&throw_if_mutablez5check_for_mutable_operation..throw_if_mutables/  "7x@()!r%rr) rzipr r3 TypeErrorr1_CFunctionSchemarg) rzrrr7schemasmatched_schemascandidate_signaturer}r_schema_to_checks r&rrs 5VDQJgSU ,/z7+C  '  .@@@&&(;V'DE  UXX%<%<    1 $   !Q &!0!3 A _ - ?z  s"B B+*B+opr|Tcyr,r$rr|s r&rrs SVr%cyr,r$rs r&rrs&)r%ct|tr|jg}nt|tr2|j Dcgc]}t ||j}}not j|}|r|r|dfSdStjjj|}||rdSdStjj|}|Dcgc] }t|}}|r||fS|Scc}wcc}w)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 N)NN) isinstancer _schemar overloadsgetattrr'rur1jit _builtins _find_builtinr_jit_get_schemas_for_operatorry)rr|rroverrideaten_fnr}r7s r&rrs,"j!::, B( )ACPX72x(00PP$((, '5Hd# ?4 ?))%%33B7 ?#1< ;t ;((88AIPQv26:QJQ$2J B BQRs C0C5xc t|ttfrt|trdtdtfd}ndtdtfd}t |dk(r |tS|d}|D]+}t ||rt ||r|}|tcS||S |S#t $rtjd|Y|SwxYw)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(ct|Sr,)listrs r&ret_typez"create_type_hint..ret_types 7Nr%ct|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 rrg issubclass Exceptionwarningswarn)rr base_typerAs r&rr s a$ '!T"### )))1v{}$!I )a+ 1- !I#C=(  )I& &- (8 H   Nqc R  H  sA B##3B#B##!CCsignature_type argument_typect|d|}|ury|tjur%|k7r |j}t fd|DSt|ddt ur|jdt ur t urytjstjd|dytddt urtjdSdtd tffd }|S|t urtjury|t j"urt t$hvrytjr!tj|r t|Sy) N __origin__Tc36K|]}t|ywr,)r).0crs r& ztype_matches..CsIa<=1Isrz.Does not support nested parametric types, got z. Please file a bug.FrAr(ctj|turytj|}|dk(ryt fd|DS)NF)r$Tc3JK|]}|tuxs t|ywr,)Ellipsisr)rr sig_el_types r&rz=type_matches..is_homogeneous_tuple..Zs$XX D*Q *DDXs #)typing get_originr get_argsall)rA containedrs r&is_homogeneous_tuplez*type_matches..is_homogeneous_tupleTsC  #50*IE!XiXX Xr%)rrUnion__args__anyrintr4isclassrrrobjectr6r1dtypenumbersNumberfloat)rrsig_origin_type sig_containedrrs ` @r&rr8sRnlNKO&&,,&>]+J&// I=III~|T2d:$--a0  C K3$6{+ MM@@PPde  =, 5 =m44Q7E E YF Yt Y$M22%++!='Mc5\,I}%'//.*I-88 r% arg_types kwarg_typesnormalize_to_only_use_kwargscRt||||||}|td|d|d||S)zb Wrapper around normalize_function that never returns None, but loudly errors instead zFailed to normalize function z with args z and kwargs )rr=)rzrrrrrrxs r&_normalize_function_or_errorrksO fi6R C {+F8;tfLQWPX Y   r%c|i}d}t|tjs.t|ttfst |dr |j }t|tjst|ttfs|}|tvrpt|tr tdt|}|d|d} } tj| jtj| jk7ry| }t|stdt|tjtj|} t!| |||}|St|stdt|t#|} g} | r5| D]#} t%|g|i|| j'|%t+| dk(r |St+| d k(rt!| d|||}|S|||r|nt-t.t0d }|r|ni}| D]s}d } t%|g|i|}|j2j5D].\}}|j|}|xrt7|j8|}0 |sdt!||||}|S|Sd j;d| D}t=dt?j@|d||S#t($rYAwxYw#t($rd }YrwxYw)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 c32K|]}t|ywr,)r#)rr}s r&rz%normalize_function..s1(.F 1sz 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#rcr4r5ricallabler\unwrap&_args_kwargs_to_normalized_args_kwargsrr r3rrgrr rr[itemsrrYjoinr=r1typename)rzrrrrrnew_args_and_kwargstarget_for_analysis dispatchedrrsigtorch_op_schemasrr sig_matches bound_typesarg_namerkparamschema_printoutss r&rrsp>~ vu88 9F%5z$BC FE "  fe77 86,j9:$ ' ' &#&$%IJJ+F3J *9 5z*7MXG!!'*55$$X.99:") +, ? ?#q(Z Y_%*&L#A&f6R'#T M(K,C-6 DsR>&;Q:RSOO_N`b e!4 )0*/K0s% J< AK < K K  KKrootc |j|}t|jdr|jj }t tj|d|jk(rFtjtj|j}|i}t||||} | Sy#t$r}td|d|d}~wwxYw)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) rrzrrrsubmode classnamerrs r&rrs6##F+ v,$$-- 588Y -1A1A A##GNN6>>$BCC~"HT6#?# ' &  26(;  !  sB.. C 7CC rcB tjjtjjh t fd|j j Dr)t|j jgdk7ryt|g|i|}|ji}g}t|j D]F\}}|s-|t|kr|j|j|5|j|||<Htt!||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|]}|jvywr,)rW)rrmsupported_parameter_typess r&rz9_args_kwargs_to_normalized_args_kwargs..\s Tq1662 2 Ts)rUrVto generatorN)r4rTrbrarrivaluesrkeysr apply_defaultsrergr3r[rr ) rrrr bound_args new_kwargsnew_argsirrs @r&rr>s6 //&&! TCNNrs  $JJ 23+) e,Z-HJ4c*D1B1B,CCDI $w001  $4#5%-- @@llllllnnii99}}%'T ##    V/A#FA.q/<.@