EiY JSSKrSSKrSSKrSSKJrJrJr SSKJrJ r J r J r J r SSK r SSKJs Jr SSKrSSK JrJr SSKJr \R."SS55r"SS 5rS \S \4S jrS \S \\\44SjrS \S \4SjrS\S \ 4Sjr!SS.S\S\ S \ 4Sjjr"S\S \ 4Sjr#S\S \ 4Sjr$S\4Sjr%Sr&S\RNS\\S4S\(\\4S \\\RR\44Sjr*S r+S\S \ 4S!jr,S \ 4S"jr-S#r.S\RN4S$jr/S\RN4S%jr0S\RNS \ 4S&jr1S\RNS \ \S44S'jr2S>S\\S\(\\4S(\S \\ Rf4S)jjr4S*4S+jr5S,4S-jr6"S.S/5r7S0\ RfS \ Rf4S1jr8S\ RrR,S \ 4S2jr:S\RNS \\;\\;\44S3jr<\RzR|\RzR~\RzR\RzR/rB\ S4S5.S6\S7\ S4S \Rz4S8jj5rC\ S6\S7\ SS \ \Rz4S9j5rCS4S5.S:jrC\ R\ R\ R\ R\ R\ R\ R\ R\ R\ R\ R1 rOSSS4S;.S\S\ \\S4S\ \(\\4S<\ S \ 4 S=jjrPg)?N)CallableIterableIterator)AnyLiteralOptionaloverloadUnion)_C_utils_internal) OpOverloadc4\rSrSr%Sr\\S'\\S'SrSr g)Kernelz$Models a (function, source location)funcsourcec&UR"U0UD6$N)r)selfargskwargss Q/home/mande/repo/quber/.venv/lib/python3.13/site-packages/torch/_library/utils.py__call__Kernel.__call__syy$)&))N) __name__ __module__ __qualname____firstlineno____doc__r__annotations__strr__static_attributes__rrrrrs. N K*rrc0\rSrSrSrS\4SjrSSjrSrg) RegistrationHandlez2Does something when someone calls .destroy() on it on_destroycXlgr _on_destroy)rr(s r__init__RegistrationHandle.__init__s%rNc$UR5 grr*)rs rdestroyRegistrationHandle.destroy s rr*)returnN) rrrr r!rr,r/r$rrrr&r&s<&8&rr& stacklevelr1c[R"[R"U55nURSUR 3nU$)zGet a string that represents the caller. Example: "/path/to/foo.py:42" Use stacklevel=1 to get the caller's source Use stacklevel=2 to get the caller's caller's source etc. :)inspect getframeinfosys _getframefilenamelineno)r2framers r get_sourcer<$s;  z!: ;Eq /F MrqualnamectURS5n[U5S:wa[SUS35eUSUS4$)Nz::zAExpected `qualname` to be of the form "namespace::name", but got zf. The qualname passed to the torch.library APIs must consist of a namespace and a name, e.g. aten::sinr)splitlen ValueError)r=splitss rparse_namespacerE2sR ^^D !F 6{a**248 9  !9fQi rc[U5upSU;aURS5up#OSn[[RU5n[XB5n[XS5$)N.default)rErAgetattrtorchops)r= namespacenamer nspackets r lookup_oprP>sP%h/OI d{Ch I &B R F 6 $$ropcx[U[5(d[S[U535eURS;$)Nop must be OpOverload, got >atenprimprims) isinstancer AssertionErrortyperL)rQs r is_builtinrZIs6 b* % %:48*EFF <<4 44rF)allow_valid_viewschemar[c(^U4Sjn[U[RR5(aU"U5$SSKJn [U[ 5(aUR U5n[X5(d[S[U535eU"U5$)aFCheck if the schema is functional. An operator is functional if: - it does not mutate any of its inputs - If no view are allowed - it does not return a view on any of its inputs - If valid views are allowed - it is not a view or a view with a single input Tensor and single output Tensor - it has at least one return c>UR(agURn[U5S:=(a [SU55nSnSn[ U[ R 5(aURH3n[ UR[ R5(dM.US- nM5 URH3n[ UR[ R5(dM.US- nM5 O[ U[RR 5(a|URRH)nURR5(dM$US- nM+ URH)nURR5(dM$US- nM+ U(aT =(a US:H=(a US:H$UR(dgg)NFrc3# UH4oRSL=(a URR(+v M6 g7fr) alias_infois_write).0rs r >is_functional_schema..is_functional.._s/5 LPqLL $ BQ\\-B-B)B BDs<>r@T) is_mutablereturnsrBanyrWrJFunctionSchema argumentsrY TensorTypetorchgenmodel flat_non_outis_tensor_like) r\retsis_non_mutating_viewnum_tensor_inputsnum_tensor_outputsargretargumentret_argr[s r is_functional+is_functional_schema..is_functional[ss   ~~"4y1} 5 LP5 2  fe22 3 3''chh(8(899%*%(~~chh(8(899&!+&& = = > >",,99==//11%*%:">><<..00&!+&* #!Q&B+=+B ~~rr)riz#schema must be FunctionSchema, got ) rWrJr ritorchgen.modelr#parserXrY)r\r[rxris ` ris_functional_schemar|Os|"H&%((1122V$$.&#%%f- f - -B4<.QRR   rtypc tU[R"[RR55:H=(d U[R"[R"[RR555:H=(d U[R"[R"[RR555:H=(d] U[R"[R"[R"[RR5555:H$r)r ListTyperkget OptionalTyper}s ris_tensorlist_like_typers r{{2==,,.// U "++boobmm.?.?.ABC C U "//"++bmm.?.?.A"BC C U "//"++boobmm>O>O>Q.R"ST T rcU[RR5:H=(d5 U[R"[RR55:H$r)r rkrrrs ris_tensor_like_typers: "--##% % T @Q@Q@S0T)TTrcURS:wagURn[UR5S:wagURSRcgURSRR n[U5S:wag[ [U55n[UR5S:agURSnURcgURR(dgURR n[U5S:wagU[ [U55:wagURSSHnURcM g g)a:Check if an op is an inplace aten op, i.e. it mutates and returns the first arg. TODO: torchgen/model.py's FunctionSchema.parse is the source of truth for this, but not all PyTorch builds have torchgen (due to the yaml dependency being weird). Figure this out. Example: add_(Tensor(a!) x, Tensor y) -> Tensor(a) rTFr@rNT) rL_schemarBrgr` after_setnextiterrjra)rQr\ alias_setloc first_argrts rmutates_and_returns_first_argrs# ||v ZZF 6>>a ~~a##+q!,,66I 9~ tI C 6  q   #I#    ( ($$..I 9~ d4 ?### >> %$ rc/n0n[[UR55HnURUnUR(aFURU;aX&RXFR'MOUR XFR'MiU[U5:aUR X5 MUR UR 5 M [U5U4$r)rangerBrj kwarg_onlyrM default_valueappendtuple)r\rrnew_args new_kwargsiinfos r fill_defaultsrsHJ 3v''( )" ??yyF"(.yy(9 99%(,(:(: 99%3t9}( 2 23* ?J &&rr.rc #F# [UR5[U5[U5-:a:[S[UR5S[U5S[U5S35e[[UR55HnURUnUR(a$UR U;aXBUR 4v MGU[U5:a5UR(d"UR U;aXBUR 4v MXAU4v M g7f)zzips schema.arguments and (args, kwargs) together. Assumes that (args, kwargs) were the inputs to some torch._ops.OpOverload: that is, (args, kwargs) must be bindable to the schema (args, kwargs). z schema has z arguments but got z args and z kwargsN)rBrjrXrrrM)r\rrrrs r zip_schemars 6  s4y3v;66#f../00CCI;jY\]cYdXeel m  3v''( )" ??yyF"499---  D >??tyyF':499--- Gm* sDD!c SSKJn URn[U[R R 5(d [S5eSn/nURHn[U[RR[RRR45(aURU"U55 Mi[U[RRR[[ 45(a)URUVs/sH oc"U5PM sn5 M[S[#U535e [$R&"UR(5R*"U6nU"U5nUR-UR.[!UR0R355[U545$s snf)Nr)FunctionSchemaGenzfx_node's target must be a hop.cURRSS5nUcSURS:wa[SUR<35e[ UR R UR5nU$)Nvalget_attrz1node.op must be 'get_attr' when val is None, got )metarrQrXrIgraph owning_moduletarget)nodemeta_vals r_collect_example_val5hop_schema_from_fx_node.._collect_example_valsd99==-  ww*$$G{Stzz77EHrzUnsupported arg type )torchgen.gen_schema_utilsrrrWrJ_opsHigherOrderOperator RuntimeErrorrfxNoderrimmutable_collectionsimmutable_listlistrrYr5 signaturerbind from_example_namerjitems) rrhoprexample_inputsrtx bound_argsexample_outputs rhop_schema_from_fx_noders\; ++C c5::99 : :<==Nyy cEHHMM588==+=+=> ? ?  ! !"6s"; <  %((00??uM    ! !C"HCq#7#:C"H I!6tCykBC C*1):):3<<)H)M)M *J *$/N  ) ) 5--3356n9M8O #IsF> c[U[5(d[S[U535e[ U5(agUR nUR (dg[UR5S:agg)NrSFrT) rWr rXrYrZrrfrBrg)rQr\s rcan_generate_trivial_fake_implrs` b* % %:48*EFF"~~ ZZF    6>>Q rc$[[SS5$)zIf an op was defined in C++ and extended from Python using the torch.library APIs, returns if we require that there have been a m.set_python_module("mylib.ops") call from C++ that associates the C++ op with a python module. REQUIRES_SET_PYTHON_MODULET)rIr rrrrequires_set_python_moduler*s ?$@$ GGrc^[U[RRR5(d[ S[ U535e[RRRX#R545upEUVs/sHn[U[R5(dM$[RRU5R[RRR5(dM{[ U5PM nnUR!XX#5$s snf)Nz)curr_mode must be TorchDispatchMode, got )rWrJutils_python_dispatchTorchDispatchModerXrY_pytree tree_flattenvaluesTensorr _dispatch_keyshas DispatchKeyPython__torch_dispatch__) curr_mode op_overloadrrargs_flattened_aoverload_typess rhandle_dispatch_moder3s i!=!=!O!O P P7Y7H I   ++88$ 9PQN A a &  HH # #A & * *588+?+?+F+F G Q  ' ' T RRs #D*0AD*D*c:[SUR55$)Nc38# UHoRv M g7fr)rrbrs rrd&has_kwarg_only_args..Is6%5||%5srhrjr\s rhas_kwarg_only_argsrHs 6V%5%56 66rcURHLn[UR5(d[UR5(dM9UR(dML g g)NTF)rjrrYrr)r\rs rhas_kwarg_only_tensorsrLsE   #AFF++/Fqvv/N/N ||   rc:[SUR55$)z Given a schema, returns True if the schema has a Tensor arg. A Tensor arg is any arg with a type annotation that might involve Tensor. c3# UH6n[UR5=(d [UR5v M8 g7fr)rrYrrs rrd!has_tensor_arg..[s2!A QVV $ G(?(G G!s>Arrs rhas_tensor_argrVs$ !! rc[UR5HFupUR[RR 5LdM2UR S:XdMDUs $ g)zl Given a schema, returns the id of the `device: torch.device` argument. If it does not exist, returns None. deviceN) enumeraterjrYr DeviceObjTyperrM)r\indexrts rget_device_arg_indexrasK   0 01  88r''++- -#((h2FL2 rallowed_nestingc#^# U4SjnUHnU"U5ShvN M UR5HnU"U5ShvN M gN0N 7f)Nc3># [U[R5(aUv gTS:a>[U[[45(a"[ [U50TS- 5ShvN gggN7f)Nrr@)rWrJrrr iter_tensors)rtrs rcheckiter_tensors..checkos[ c5<< ( (I q ZeT]%C%C#E#JOa4GH H H&D HsA"A/%A-&A/)r)rrrrrtkwargs ` rrrlsJI :<! s!AA &AA  A AcgNz???rrrrr{sUrcUVs1sH>n[U[R5(dM$UR5RiM@ nnUn[U[ 5(dU4n[ U05HbnUR5RnUR5RU;a[USU"5S35eURU5 Md gs snf)zG custom operators' outputs must not alias any inputs or other outputs.  (with implementation in ): The output of this custom operator (1) must not also be an input to this custom operator and (2) may not alias any inputs to this custom operator or other returns. The most common way to trigger this error is if we have y = custom_op(x) and y and x are the same Tensor. Please instead return a clone of the offending output tensor(s) (e.g. return x.clone()) or refactor the custom operator to not return y.N) rWrJruntyped_storage_cdatarrradd) rMprevresult get_moduletstorages tuple_resulttensorkeys rcheck_aliasing_constraintr{s59XDqJq%,,URU:Xag[TRRSURSTRR SUR(aSOSS35e)Nz: for argument 'z': the operator's schema z specified that the operator mutateszdoes not mutatea* the argument, but this seems to be empirically wrong. Please make the schema and operator behavior consistent. You can specify that an operator mutates a Tensor by e.g. changing its schema type from 'Tensor name' to 'Tensor(a!) name'(use different identifiers (a, b, c, ...) for different Tensors))rarrQrrMr)r was_mutatedrs r check_one(MutationChecker.check..check_onesi==K/"ww}}o%5dii[@Yww'($15IDU#VWWX  rF)r rWrJrr zipr equalisnanallpytreetree_unflattenr rrQrrrYrrh) rrreal_post_hashesprepostrwas_mutated_argswas_mutated_kwargsrrwas_any_mutateds ` rrMutationChecker.checkso^^ #)ELL99KNt C#  !!5!57GH  I #u||,,D%,,1O1O C& & ?YY[__&=4::<+;+;+=> I  06/D/D 0 ,", GGOO-" D #499--$,(33+6+>%C DT$0-"   s 6G!B6G )r r rQr N)rrrr r!r,rr$rrrrrs %1rrrcZUR5R5R5$)zNSome inexpensive hash. Used as a quick and dirty indicator for tensor mutation)detachfloatmean)rs rr r s 88:    " " $$rc0[U5(agURn[RR US5(ag[R R RU5nUc[RR US5(ag[R RRRU5nURRbg[RR US5(aggURbgg)zIf an operator (that stays alive until FakeTensorMode) has a Fake kernel. Don't use this if the operator decomposes before FakeTensorMode. TCompositeImplicitAutogradCompositeExplicitAutogradMetaF)rrrJr %_dispatch_has_kernel_for_dispatch_key_library custom_ops_maybe_get_opdefsimple_registry singletonfind fake_implkernel _abstract_fn)rQrMopdefentrys rhas_fake_kernelr5s&b)) 88D xx55 ) NN % % 6 6t  srcgrrr=s rr>r>'src[HnX R;dMUs $ U(a^[U5(a[RR $SSKnSSKJn [URRUR5$g)Nr)config) tags_by_prioritytagsrZr Tagflexible_layouttorch._functorchrArI#custom_op_default_layout_constraint)r;r:tagrJrAs rr>r>-s\ ''>J  b>>66)) )+uxx||V%O%OPP r)rr impure_randomrIcSSKJn SSKJn [ U[ R R5(a2[USS5nUbUR(agX;agU"U5bg[ U[ R R5(auU[ RRR[ RRR4;aU(a[U5S:aUSU;$U"U5bggU(a[USS5(agU[ ;ag[USS5nUbUR(agX;agg) aU An operator is impure if it: - Mutates its inputs (has a mutable schema) - Has nondeterministic/random behavior that mutates RNG state - Is explicitly marked as effectful via torch.library._register_effectful_op Args: op: The operator to check (function, OpOverload, HigherOrderOperator, etc.) args: Optional arguments that would be passed to the callable kwargs: Optional keyword arguments that would be passed to the callable impure_random: Whether to treat random operations as impure (default: True) Returns: bool: True if the callable has side effects, False otherwise r) _get_effect)_side_effectful_functionsrNTF_nondeterministic_seeded)torch._higher_order_ops.effectsrK torch.fx.noderLrWrJrr rIrfrrK higher_orderauto_functionalizedauto_functionalized_v2rB_RANDOM_FUNCTIONS)rQrrrIrKrLr\s r is_impurerTKs.<7"ejj++,,Y-  &"3"3 * r? &"ejj4455 II " " 6 6 II " " 9 9  D A Aw";;; r? &%?GG  RD )F f// & r)r@)Q dataclassesr5r7collections.abcrrrtypingrrrr r rJtorch.utils._pytreerrrrlr r torch._opsr dataclassrr&intr#r<rrErPboolrZr|rrrrridictArgumentrrrrrrrrrrrrrrr rr5rr9rDneeds_exact_stridesneeds_contiguous_stridesneeds_fixed_stride_orderrErBr>randrandnrandintrandperm rand_like randn_like randint_likenormalpoisson bernoulli multinomialrSrTrrrrms 88:: $$%! *** 3 3   c  eCHo  %% %5:5$5 CH:!:!4:!D:!|USUTU#j#L'$    %*38_ >B38n  eBKK$%& :&Rzd"HDHS*7 1 172#4#42,,!2!2uS$Y7GFG  *  "38n  ?B   ell  >K4IV 27171t%5<<%ELL%  --$<  1 1 eDItCy