Ë êÇ„g·ãó¾—UddlZddlZddlmZmZddlmZddlZddlm Z m Z Gd„d«Zdeded efd „Z d„Zeaeed<ej"d „«ZGd„d«Zy)éN)ÚCallableÚOptional)Ú deprecated)ÚKernelÚRegistrationHandlecó0—eZdZdZdefd„Zdededefd„Zy) ÚFakeImplHolderz0A holder where one can register an fake impl to.Úqualnamecó.—||_d|_d|_y©N)r ÚkernelÚlib)Úselfr s ú`/home/mcse/projects/flask_80/flask-venv/lib/python3.12/site-packages/torch/_library/fake_impl.pyÚ__init__zFakeImplHolder.__init__s€Ø%ˆŒ Ø(,ˆŒØ48ˆóÚfuncÚsourceÚreturncóâ‡—‰j0td‰j›d‰jj›d«‚tj j ‰jd«rtd‰j›d«‚tj j ‰jd«rtd‰j›d«‚t||«‰_‰j€C‰jjd«d }tjj|d «‰_t‰j‰«}‰jj‰j|d«ˆfd„}t|«S)z}Register 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::rÚFRAGMENTcón•—‰jr!‰jj«d‰_d‰_yr)rÚ_destroyr )rs€rÚderegister_fake_classz6FakeImplHolder.register..deregister_fake_classAs(ø€ØxŠxØ—‘×!Ñ!Ô#Ø”ØˆDKr)r ÚRuntimeErrorr rÚtorchÚ_CÚ%_dispatch_has_kernel_for_dispatch_keyrrÚsplitÚlibraryÚLibraryÚconstruct_meta_kernelÚimplr)rrrÚnsÚmeta_kernelrs` rÚregisterzFakeImplHolder.registersLø€ð;‰;Ð"ÜØ3°D·M±M°?ðC:à—;‘;×%Ñ%Ð& að)óð ô 8‰8×9Ñ9¸$¿-¹-ÈÔPÜØ3°D·M±M°?ðC!ð"óð ô8‰8×9Ñ9ØM‰MÐ6ô ôØ3°D·M±M°?ðC7ð8ó ð ô˜T 6Ó*ˆŒð8‰8ÐØ—‘×$Ñ$ TÓ*¨1Ñ-ˆBÜ—}‘}×,Ñ,¨R°Ó<ˆDŒHÜ+¨D¯M©M¸4Ó@ˆØ‰ ‰ d—m‘m [°&Ô9ô ô"Ð"7Ó8Ð8rN) Ú__name__Ú __module__Ú__qualname__Ú__doc__Ústrrrrr)©rrr r s,„Ù:ð9 ó9ð 49˜Xð49¨sð49Ð7Iô49rr r Úfake_impl_holderrcóŠ‡‡—‰j€J‚tj‰jj«ˆˆfd„«}|S)NcóÀ•‡—‰j€J‚‰jjŠˆˆfd„}t|«5‰j|i|¤Žcddd«S#1swYyxYw)Ncó(•—td‰›d‰›d«‚)Nz.meta_kernel..error_on_ctxRs+ø€ÜðØjÐ 1°&°ð:ðóð r)r rÚset_ctx_getter)ÚargsÚkwargsr4rr0r s @€€rr(z*construct_meta_kernel..meta_kernelMs`ù€à×&Ñ&Ð2Ð2Ð2Ø!×(Ñ(×/Ñ/ˆõ ô˜LÓ )ñ <Ø*Ð#×*Ñ*¨DÐ;°FÑ;÷ <÷ <ò <ús¸AÁA)r Ú functoolsÚwrapsr)r r0r(s`` rr%r%JsEù€Ø×"Ñ"Ð.Ð.Ð.ä‡__Ð%×,Ñ,×1Ñ1Ó2ô<ó3ð<ð"Ðrcó—yrr/r/rrÚget_noner;bs€ØrÚglobal_ctx_getterc#ó8K—t} |ad–—|ay#|awxYwwr)r<)Ú ctx_getterÚprevs rr5r5is'èø€ô€Dð!Ø&ÐÛ à Ñø˜DÑüs‚Š“—có€—eZdZdZd„Zede¬«dddœdejfd „«Z d ddœdejfd„Z y)ÚFakeImplCtxzO Context object for writing fake implementations for custom operators. cóB—||_|j|_||_yr)Ú _fake_modeÚ shape_envÚ _shape_envÚ_op)rrCrFs rrzFakeImplCtx.__init__ys€Ø$ˆŒØ$×.Ñ.ˆŒØˆrzM`create_unbacked_symint` is deprecated, please use `new_dynamic_size` instead)ÚcategoryéN©ÚminÚmaxrcó(—|j||¬«S)NrI)Únew_dynamic_size)rrJrKs rÚcreate_unbacked_symintz"FakeImplCtx.create_unbacked_symint~s€ð ×$Ñ$¨°#Ð$Ó6Ð6rrcó—|j|jjs3tjjj|j«‚t|tj«st|tj«rtd|›d|›d«‚|dkrtd|›d«‚|jj«}tjjjj|||¬«|S)a Constructs 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.rI)rEÚallow_dynamic_output_shape_opsrÚ_subclassesÚfake_tensorÚDynamicOutputShapeExceptionrFÚ isinstanceÚSymIntÚ ValueErrorrNÚfxÚexperimentalÚsymbolic_shapesÚ_constrain_range_for_size)rrJrKÚresults rrMzFakeImplCtx.new_dynamic_size…sé€ðf O‰OÐ#Ø—?‘?×AÒAä×#Ñ#×/Ñ/×KÑKÈDÏHÉHÓUÐUäcœ5Ÿ<™<Ô(¬J°s¼E¿L¹LÔ,IÜØ+¨C¨5°°s°eð<)ð*óð ðŠ7ÜØ+¨C¨5ð1&ð'óð ð—‘×7Ñ7Ó9ˆÜ ‰×Ñ×-Ñ-×GÑGØ˜ ð Hô ðˆ r)r*r+r,r-rrÚ FutureWarningrrUrNrMr/rrrArAtsV„ñòñ ØWØôð-.°4ò7¸E¿L¹Lò7ó ð7ð'(¨TòJ°e·l±lôJrrA)Ú contextlibr8ÚtypingrrÚtyping_extensionsrrÚtorch._library.utilsrrr r.r%r;r<Ú__annotations__Úcontextmanagerr5rAr/rrúrcstðäÛß%Ý(ãß;÷<9ñ<9ð~ Cð¸>ðÈhóò0ð'Ð8Ó&ð×Ññ!óð!÷[ò[r