[Th %SSKrSSKrSSKJrJr SSKJr SSKrSSKJ r J r "SS5r S\ S\ S \4S jr S r\q\\S '\R"S 5r"SS5rSSjrg)N)CallableOptional) deprecated)KernelRegistrationHandlec<\rSrSrSrS\4SjrS\S\S\4Sjr S r g ) FakeImplHolder z0A holder where one can register an fake impl to.qualnamec,XlSUlSUlgN)r kernellib)selfr s P/var/www/auris/envauris/lib/python3.13/site-packages/torch/_library/fake_impl.py__init__FakeImplHolder.__init__s% (, 48funcsourcereturnc^TRb0[STRSTRRS35e[R R TRS5(a[STRS35e[R R TRS5(a[STRS35e[X5TlTRcCTRRS5S n[RRUS 5Tl[TRT5nTRRTRUS5 U4S jn[U5$) zeRegister an fake impl. Returns a RegistrationHandle that one can use to de-register this fake impl. z!register_fake(...): the operator z( already has an fake impl registered at .Metaz already has an DispatchKey::Meta implementation via a pre-existing torch.library or TORCH_LIBRARY registration. Please either remove that registration or don't call register_fake.CompositeImplicitAutograda% already has an implementation for this device type via a pre-existing registration to DispatchKey::CompositeImplicitAutograd.CompositeImplicitAutograd operators do not need an fake impl; instead, the operator will decompose into its constituents and those can have fake impls defined on them.z::rFRAGMENTcx>TR(a!TRR5 STlSTlgr )r_destroyr)rsrderegister_fake_class6FakeImplHolder.register..deregister_fake_classAs(xx!!#DKr)r RuntimeErrorr rtorch_C%_dispatch_has_kernel_for_dispatch_keyrrsplitlibraryLibraryconstruct_meta_kernelimplr)rrrns meta_kernelrs` rregisterFakeImplHolder.registersR ;; "3DMM?C:;;%%&a)  88 9 9$-- P P3DMM?C!"  88 9 9 MM6  3DMM?C78  T*  88 $$T*1-B}},,R^TRceTRRmUU4Sjn[U5 TR"U0UD6sSSS5 $!,(df  g=f)Nc&>[TSTS35e)Nz (a): You're trying to run this operator with meta Tensors (as opposed to FakeTensors), but this operator may return an output Tensor with data-dependent shape. Meta Tensors don't support operators with outputs that have data-dependent shapes but FakeTensors do. If your operator does not return an output with data-dependent shape, make sure the FakeTensor and/or meta kernel does not call torch.library.get_ctx(). Otherwise, please use FakeTensors.)r!)r rsr error_on_ctx@construct_meta_kernel..meta_kernel..error_on_ctxRs'*Bvh'NO  r)rrset_ctx_getter)argskwargsr:rr6r s @rr+*construct_meta_kernel..meta_kernelMsT&&222!((// L )#**D;F;* ) )s A A$)r functoolswrapsr)r r6r+s`` rr(r(JsE  " " .. .__%,,112<3<& rcgr r5r5rrget_nonerCds rglobal_ctx_getterc#8# [nUqSv Uqg!Uqf=f7fr )rD) ctx_getterprevs rr<r<ks& D!&  Dsc\rSrSrSrSr\"S\S9SSS.S \R4S jj5r S SS.S \R4S jjr S r g) FakeImplCtxvzG Context object for writing fake implementations for custom operators. c>XlURUlX lgr ) _fake_mode shape_env _shape_env_op)rrLrOs rrFakeImplCtx.__init__{s$$..rzM`create_unbacked_symint` is deprecated, please use `new_dynamic_size` instead)categoryNminmaxrc URXS9$NrS)new_dynamic_sizerrTrUs rcreate_unbacked_symint"FakeImplCtx.create_unbacked_symints $$$66rrcURbURR(d3[RRR UR 5e[U[R5(d[U[R5(a[SUSUS35eUS:a[SUS35e[URX5$)aConstructs a new symint (symbolic int) representing a data-dependent value. This is useful for writing the fake implementation (which is necessary for torch.compile) for a CustomOp where an output Tensor has a size that depends on the data of the input Tensors. Args: min (int): A statically known inclusive lower bound for this symint. Default: 0 max (Optional[int]): A statically known inclusive upper bound for this symint. Default: None .. warning: It is important that the ``min`` and ``max`` (if not None) values are set correctly, otherwise, there will be undefined behavior under torch.compile. The default value of ``min`` is 2 due to torch.compile specializing on 0/1 sizes. You must also verify that your implementation on concrete Tensors (e.g. CPU/CUDA) only returns Tensors where the size that corresponds to the symint also has respects these constraint. The easiest way to do this is to add an assertion in the CPU/CUDA/etc implementation that the size follows these bounds. Example:: >>> # An operator with data-dependent output shape >>> lib = torch.library.Library("mymodule", "FRAGMENT") >>> lib.define("mymodule::custom_nonzero(Tensor x) -> Tensor") >>> >>> @torch.library.register_fake("mymodule::custom_nonzero") >>> def _(x): >>> # Number of nonzero-elements is data-dependent. >>> # Since we cannot peek at the data in an fake impl, >>> # we use the ctx object to construct a new symint that >>> # represents the data-dependent size. >>> ctx = torch.library.get_ctx() >>> nnz = ctx.new_dynamic_size() >>> shape = [nnz, x.dim()] >>> result = x.new_empty(shape, dtype=torch.int64) >>> return result >>> >>> @torch.library.impl(lib, "custom_nonzero", "CPU") >>> def _(x): >>> x_np = x.numpy() >>> res = np.stack(np.nonzero(x_np), axis=1) >>> return torch.tensor(res, device=x.device) zctx.new_dynamic_size(min=z, max=zZ): expected min and max to be statically known ints but got SymInt. This is not supported.rzc, ...): expected min to be greater than or equal to 0: this API can only create non-negative sizes.) rNallow_dynamic_output_shape_opsr" _subclasses fake_tensorDynamicOutputShapeExceptionrO isinstanceSymInt ValueError allocate_sizerYs rrXFakeImplCtx.new_dynamic_sizesf OO #??AA##//KKDHHU U c5<< ( (JsELL,I,I+C5se<)*  7+C51&'  T__c77r)rLrOrN) r.r/r0r1r2rr FutureWarningr"rbrZrXr4r5rrrIrIvs\ W-.47ELL7 7'(TF8ellF8F8rrIcUR5n[RRRR X1US9 U$rW)rZr"fx experimentalsymbolic_shapes_constrain_range_for_size)rMmin_valmax_valresults rrdrds@  - - /F HH))CCD Mr)rN) contextlibr@typingrrtyping_extensionsrr"torch._library.utilsrrr r3r(rCrD__annotations__contextmanagerr<rIrdr5rrrusz%( ;<9<9~C>h4'8& !!W8W8tr