&Vji^UtUddlZddlZddlZddlZddlZddlZddlmZmZmZm Z m Z m Z ddl Z ddl mZddlmZmZddlmZe rddlmZgdZed Gd d e ZiZeeeejfed <dZeee j<GddZe j e j!e j"ej#e j$j%ej&e j'ee(de j)ej*dd Z+e,eD]Z-e.ee-e+e-<dddefdZ/de j0j1dejfdZ2iZ3ee4e5e5fejfed<de j0j1dejfdZ6ed dede4ddee5dffd Z7ed d1d!ed"e8fd#Z9ed d$Z:ed d%ed&efd'Z;ed  d2dede4ed(fde ee5efd)e e4ed*e ee5efd+e8de efd,Z<ed  d3d-e j=j>de5de4ede ee5efd+e8de ef d.Z?d/ejde4ed(fdee5efd+e8de ef d0Z@dS)4N)AnyCallablecast NamedTupleOptional 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__tupler__annotations__dictstrS/root/voice-cloning/.venv/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..nonzero4r+r#)appendinspect signaturebool) signaturesr*s r$_nonzero_schemasr3,syJ   g'00111 4    g'00111 r#ceZdZdZdS)_FakeGlobalNamespacec:|dkrtStd)Ntorchz!Expected a torch namespace lookup)r7 RuntimeError)r)names r$ __getattr__z _FakeGlobalNamespace.__getattr__@s 7??L>???r#N)rrrr:r"r#r$r5r5?s(@@@@@r#r5t) 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)rFs r$ _torchscript_type_to_python_typerLWs &(: ; ;;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)r9kinddefault annotationc6g|]}t|jSr")rLtype).0rets r$ z9_torchscript_schema_to_signature_impl..s07:(22r#r )return_annotation)r/rO argumentsrLrVhas_default_value default_valueemptyr9 kwarg_only KEYWORD_ONLYPOSITIONAL_OR_KEYWORDPOSITIONAL_ONLY enumeraterRrSrTr.returnslenr Signature) rMrO parametersargarg_typerSr9rRidxp return_types return_types r$%_torchscript_schema_to_signature_implrn`s"!!!!!"$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()r9 overload_namerogetrn)rM cache_key cache_valress r$ _torchscript_schema_to_signaturervsO 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_mutabler8)schemas r$throw_if_mutablez5check_for_mutable_operation..throw_if_mutables?  "))))  r#rr )rzipbindr. TypeErrorre) rwrrr2schemasmatched_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#oprycttr 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)rWoverloadrs r$rYz.get_signature_for_torch_op..s&PPPX72x((0PPPr#N)NNc,g|]}t|Sr")rvrWr|s r$rYz.get_signature_for_torch_op..s!QQQv26::QQQr#) isinstancer rr overloadsr%rrr7jit _builtins _find_builtin_C_jit_get_schemas_for_operator)rryroverrideaten_fnr2s` 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 ) rrrrer 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_typect|d|}|urdS|tjur(|kr"|j}t fd|DSt|ddt ur|jdt ur t urdStjstj d|ddStddt urtjdSfd}|S|t urtj urdS|tjurt t hvrdStjr$tj|rt|SdS) N __origin__Tc38K|]}t|VdSr()r)rWcrs r$ ztype_matches..'s-IIa<=11IIIIIIr#rz.Does not support nested parametric types, got z. Please file a bug.Fct|ddturdS|j}|jdkrdStfd|DS)NrF)r"Tc3JK|]}|tupt|VdSr()Ellipsisr)rWr sig_el_types r$rz=type_matches..is_homogeneous_tuple..>s6XXX D*Q *D*DXXXXXXr#)rr__args__all)r; containedrs r$is_homogeneous_tuplez*type_matches..is_homogeneous_tuple8s[q,--U::u IzU""tXXXXiXXXXX Xr#)rtypingUnionranyrintr/isclassrrrr7dtypenumbersNumberfloat)rrsig_origin_type sig_containedrrs ` @r$rrsnlNKKO&&t&,&&>]+J+J&/ IIII=IIIIII~|T22d::$-a0  C  K3$6$64{++  Meeee   5 =, 5 5 = =m4Q7EE 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|tjs3t|ttfst |dr|j}t|tjst|ttfs|}|tvrlt|trJt|}|d|d} } tj | j tj | j krdS| }t|sJtj tj |} 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 |}|ot3|j|}*n#t$$rd }YnwxYw|rt||||}nnFd d | D}t9d t;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_opif_trueif_falserr r"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: )rtypesBuiltinFunctionTyper r hasattrrr r!r/r0rgcallableunwrap&_args_kwargs_to_normalized_args_kwargsrrr.rrerrrr[itemsrrTjoinr8r7typename)rwrrrrrnew_args_and_kwargstarget_for_analysis dispatchedrrsigtorch_op_schemasrr sig_matches bound_typesarg_nameriparamschema_printoutss r$rrOs>~ vu8 9 9 F%5z$BCC  FE " "  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%6"F F&%F&AI00 I?>I?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_submoduleAttributeErrorr8r __class__rrr7nnr/r0rforwardr) rrwrrrsubmode classnamerrs r$rrs6##F++  !6 ! ! !    v,, '$- 58Y - -1A A A#GN6>$B$BCCC~"HT6#?## ' & 4s ;6;rcL 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()rR)rWrksupported_parameter_typess r$rz9_args_kwargs_to_normalized_args_kwargs..#s+ T Tq162 2 T T T T T Tr#)rPrQto generatorN)r/rOrar`rrgvaluesrkeysrapply_defaultsrcrer.r[rr) rrrr bound_args new_kwargsnew_argsirrs @r$rrs06 /&! T T T TCNrs  KKKKKKKKKKKKKKKK 22222233333333))))))   e,,,Z-,>@4$w'8"99:???    $4#3#5#5%- @@@@@@@@lllni9}%%''T #      V//A#GFA..q<.@