+ j]aR7t<0t^RIt^RIt^RIt^RIt^RIt^RIt^RIHt^RIH t H t H t H t H t Ht^RIt^RIHt^RIHtHt^RIHt^RIHt]'d^RIHt.R8Ot]!R R 7!R R ] 44t/t]^kR Rlt]!4]]P>&!RR4t R]PBR]PDR]PFR]PHR]PJPLR]PNR]PPR] !4R])!R4R]PTR]PV!R4R] / t,]-!]4Ft.]/!]].4],].&K RRlt0RR lt1/t2]^kR!R"lt3]!R R 7R#R$l4t4] R%R&l4t5] R9R'R(ll4t5]!R R 7R:R)R*ll4t5]!R R 7R+R,l4t6]!R R 7R-R.l4t7]!R R 7R;R/R0ll4t8]!R R 7R;R1R2ll4t9]!R R 7R.__annotate__0s  ell t rcR#Nr )r1s&rnonzero!_nonzero_schemas..nonzero0 rcHV^8dQhR\PR\RR/#)rr1as_tupler+N)r2r3bool)rs"rrr45s%  ell  $ rcR#r6r )r1r;s&$rr7r85r9r)appendr- signature) signaturesr7s r_nonzero_schemasrA-sMJ g''01 g''01 rc2a]tRt^@toV3RlRltRtVtR#)_FakeGlobalNamespacec:<V^8dQhRS[RS[P/#)rnamer+)rtypes ModuleType)rrs"rr!_FakeGlobalNamespace.__annotate__As%@@@(8(8@rc2VR8Xd\#\R4h)r2z!Expected a torch namespace lookup)r2 RuntimeError)r1rEs&&r __getattr__ _FakeGlobalNamespace.__getattr__As 7?L>??rr N)r!r"r#r$rKr'r(r)s@rrCrC@s@@rrCr3DeviceLayoutnumberFuture AnyEnumTypeQScheme __torch__NoneTypeStoragetPyObjectc(V^8dQhRRR\/#)rts_typeztorch._C.JitTyper+r)rs"rrrYs<<.@returnslenr__class_getitem__r.) rbrg parametersargarg_typerkrErjidxpret return_types return_types & r%_torchscript_schema_to_signature_implrbs""$J""3CHH='*'<'<'>'>###IOO 88v-sxx7~~~  " "00 6>666$'KD6%RSS,,D$J/66Y<<<(CAFF86RSRXRXQYZ#,"22II || #  0  4G Q G#N?H>O>O>Os(2>O <A \ a "1o --eL.AB   Z GGs HclV^8dQhR\PPR\P/#rarc)rs"rrrs,  xx&&   rcVPVP3p\PV4pVeV#\ V4pV\V&V#r6)rE overload_name_SCHEMA_TO_SIGNATURE_CACHEgetr)rb cache_key cache_valress& r _torchscript_schema_to_signaturersN 7 77I*..y9I / :C,/y) JrcV^8dQhR\R\3,R\R,R\\R3,RR/#) rtarget.rrrr+N)r.)rrrrr)rs"rrrsG&& S#X &  & j !& &rcZ\VRR7wr4V'dV'dx.p\W44F'wrg\V.VO5/VBVPWg34K) RRlp\ V4^8XdR#\ V4^8XdV^,wrV!V 4R#R#R#R# \dK|i;i)T)return_schemascPV^8dQhR\PPRR/#)rschemar+N)r2rdre)rs"rr1check_for_mutable_operation..__annotate__s$  UXX%<%<  rcHVP'd\RV R24hR#)z!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 supportedN) is_mutablerJ)rs&rthrow_if_mutable5check_for_mutable_operation..throw_if_mutables2   "7x@()!rN)get_signature_for_torch_opzipr r> TypeErrorrz) rrrr@schemasmatched_schemascandidate_signaturerr_schema_to_checks &&& rcheck_for_mutable_operationrs 5VDQJgSU ,/z+C '  .@@@&&(;'DE,D   1 $   !Q &!0!3 A _ - ?z  s!B B*)B*c  V^8dQhR\R\3,R\R,R\\\ P ,R,\\PP,R,3,/#)rop.rTr+N) rrrrr,r-r.r2rdre)rs"rrrsdVVcV,3DMV 4!! "T )40G0G+H4+O OPVrcR#r6r rrs&&rrrs SVrcV^8dQhR\R\3,R\R,R\\P ,R,/#)rr.rFr+N)rrrr,r-r.)rs"rrrsA))c),3EN) '  t#)rcR#r6r rs&&rrrs&)rc JV^8dQhR\R\3,R\R\\P ,\ \\P ,R,\\PP,R,3,,R,/#)rr.rr+N) rrr<r,r-r.rr2rdre)rs"rrrs~%C%Cc%C,0%C    D"" #d *D1H1H,ID,P PQR  %Crc0\V\4'dVP.pM\V\4'd*VP 4Uu.uFq3PNK ppM\ P V4pV'dV'dVR3#R#\PPPV4pVf V'dR#R#\PPV4pVUu.uFp\V4NK ppV'dWr3#T#uupiuupi)aW 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 op_overloads_manual_overridesrr2jit _builtins _find_builtinrd_jit_get_schemas_for_operatorr)rrrroverrideaten_fnrr@s&& rrrs,"j!!::, B( ) )46OO4EF4E##4EF$((, '5Hd# ?4 ?))%%33B7 ?#1< ;t ;((88AIPQv26:JQ$2J B BGRs D+Dc0V^8dQhR\R\/#rxr+)object)rs"rrr s) ) ) 6) rc\V\\34'd\V\4'dRRlpMRRlp\V4^8Xd V!\4#V^,pVF7p\ W24'dK\ W#4'dTpK+V!\4u# V!V4#V# \ d\P!RT 24T#i;i)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`. c0V^8dQhR\R\/#rrZ)rs"rr&create_type_hint..__annotate__s####rc\V,#r6)r,rs&rret_type"create_type_hint..ret_types 7Nrc0V^8dQhR\R\/#rrZ)rs"rrr"s))))rc \VR3,#.)rrs&rrr"s C=(rz@We were not able to successfully create type hint from the type ) rr,rrzr issubclass Exceptionwarningswarn)rr base_typerVs& rcreate_type_hintr s a$ ' '!T""# )1v{}$!Ia++ -- !I#C=( I& &- (8 H   Nqc R  H  sAB.AB.! B..$CCc<V^8dQhR\R\R\/#)rsignature_type argument_typer+)rr<)rs"rrr9s!///S/T/rcaa\VRV4pVSJdR#V\PJdXVS8wdQ\P!V4p\;QJdV3RlV4F 'gK R# R#!V3RlV44#\VRR4\ Jd\P!V4^,oS\ Jd S\ JdR#\P!S4'g\P!RV R24R#\SRR4\ Jd(\\P!S4^,S4#RV3RllpV!S4#V\ JdS\PJdR#V\PJdS\ \ 09dR#\P!S4'd)\P!V4'd \SV4#R#) __origin__Tc3<<"TFp\VS4xK R#5ir6) type_matches).0crs& r type_matches..CsI=a<=11=sFNz.Does not support nested parametric types, got z. Please file a bug.c0V^8dQhR\R\/#)rrVr+)rr<)rs"rr"type_matches..__annotate__Ts Y YF Yt Yrc<\P!V4\JdR#\P!V4pVR8XdR#\;QJdV3RlV4F 'dK R# R#!V3RlV44#)FTc3Z<"TF q\J;'g \VS4xK" R#5ir6)Ellipsisr)rr sig_el_types& rr=type_matches..is_homogeneous_tuple..Zs%XiX DD*Q *DDis++)r )typing get_originrget_argsall)rV containedrs& ris_homogeneous_tuple*type_matches..is_homogeneous_tupleTs[  #50*IE!3XiX33 X3 X3XiXX Xr)getattrrUnionranyr,intr-isclassrrrr2dtypenumbersNumberfloat)rrsig_origin_type sig_containedrrs&f @rrr8srnlNKO&&,,&>]+J7 sI=IssIsIsI=III~|T2d:oon5a8  C K3$6{++ MM@@PPde  =, 5 =foomP@!V4 R V 24hV# \(dEKvi;i \(dR pLi;i)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 TF c38"TFp\V4xK R#5ir6)r)rrs& rr%normalize_function..s12AF /sz Tried to normalize arguments to zy but the schema match was ambiguous! Please provide argument types to the normalize_arguments() call. Available schemas: r )!rrFBuiltinFunctionTyper r hasattrrr rrvr-r?r|callablerounwrap&_args_kwargs_to_normalized_args_kwargsrr r>rrzrrrrnitemsrrljoinrJr2typename)rrrrrrnew_args_and_kwargstarget_for_analysis dispatchedrrsigtorch_op_schemasrr sig_matches bound_typesarg_namer~paramschema_printoutss&&&&&& rrrs|>~ vu88 9 9F%5z$BCC FE " "  fe77 8 86,j9::$ ' ' &#&&$%IJJ+F3J *9 5z*7MX!!'*55$$X.99:") +,, ?(8?#q(Z Y_%*&L#A&6R'#T M(K,C-6 DsR>&;Q:RSOO_N`b e!4 )0*/K0s+ L:5A M M : M  M  MMc V^8dQhR\PPR\R\\ ,R\ \\ 3,R,R\R\R,/#)rrootrrrNrr+) r2nnModulerrrrr<r)rs"rrrsb++ ((//+ + *+ cNT ! + #' + d +rcVPV4p\TPR4'dTPP p\ \PTR4TP8XdI\P!\P!TP44pTf/p\YY44p T #R# \dp\RT R24ThRp?ii;i)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_submoduleAttributeErrorrJr __class__r!rr2rr-r?rforwardr) rrrrrsubmode classnamerrs &&&&& rnormalize_modulers6##F+ v,,$$-- 588Y -1A1A A##GNN6>>$BCC~"H6# ' &  26(;  !  sB99 CCCc V^8dQhR\PR\\R3,R\\ \3,R\ R\R,/#)rrr.rrr+N)r-r.rrrrr<r)rs"rrr>sU1717   17 S/17 cN17#' 17 d 17rca \PP\PP0o \;QJd7V 3RlVP P 44F 'gK RM, RM(!V 3RlVP P 444'd-\VP P44.RO8wdR#\V.VO5/VBpVP4/p.p\VP 4FVwrxV'g5V\V48d%VPVPV,4KAVPV,WX&KX \\!V4V4#)aU 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@<"TFqPS9xK R#5ir6)rj)rrsupported_parameter_typess& rr9_args_kwargs_to_normalized_args_kwargs..\s Trnrr) rrrr bound_args new_kwargsnew_argsir rs &&&& @rrr>s6 //&&! s TCNNr<s:  $JJ 23+) e,Z-HJI  $4#5%-- @@ ell ell ell gnn eii499 u}}%'T  u##   VA#FA.q <6HrHJI e,&-&R V V  ) ) e,%C-%CPe,) -) Xe,/-/de,-.e,H-HVe,+-+\17r