U d@sddlZddlmZddlZddlmZmZmZmZm Z ddl m Z m Z ddl mZeGdddeZejddd edd d d Zd dZGddde ZGdddeZGdddedZGdddeZejeed ddZdS)N)Iterator) _enable_mode _push_mode _ModeInfo _wrap_initMetaInitErrorInfo)_get_torch_dispatch_mode_set_torch_dispatch_mode) dataclasscs,eZdZfddZddZddZZS)TorchDispatchModeInfocstjdttddS)Ntorch_dispatch) mode_nameZ mode_classZbase_mode_class)super__init__TorchDispatchModeBaseTorchDispatchModeself __class__@/tmp/pip-unpacked-wheel-ua33x9lu/torch/utils/_python_dispatch.pyr s zTorchDispatchModeInfo.__init__cCstSN)rrrrrget_modeszTorchDispatchModeInfo.get_modecCst|Sr)r )rmoderrrset_modeszTorchDispatchModeInfo.set_mode)__name__ __module__ __qualname__rrr __classcell__rrrrr s r F)replaceignore_preexisting)returncCst|t||dS)ah Context manager that causes all pytorch operators to dispatch to the passed-in type's __torch_dispatch__ function, including operations that accept no tensors but return a tensor. This function is non-compositional; if there is already an existing mode, it will raise an error This function is safe to use inside a ``__torch_dispatch__`` mode handler, as the mode is guaranteed to be disabled in this context. You can use this context manager to reinstate the mode so that calls to overridable APIs recursively call back into your mode handler (this can easily cause infinite loops, so use with care!) enable_torch_dispatch_mode is affected by _DisableTorchDispatch. Args: mode (:class:`TorchDispatchMode`, Tensor-like class, or None): the mode to set as current mode. If you pass a Tensor-like class, it will be treated as a non-compositional mode with no state, which is convenient if you have an existing tensor subclass that you'd like to apply globally in a quick and dirty way. Passing None will disable the current mode. replace (:class:`TorchDispatchMode` or Tensor-like class): the mode to replace. You can use this argument to change the mode in a situation where you know what the current mode is (and you are intentionally overwriting it.) If you don't know what the current mode is, use ``ignore_preexisting`` instead. ignore_preexisting (bool): if True, ignore any preexisting mode and overwrite it with the passed mode. ) mode_infor r!)rr )rr r!rrrenable_torch_dispatch_modes"r$cstfdd}|S)Nc s2t|j|f||W5QRSQRXdSr)r$inner)rargskwargsfrrwrappedBs z%_wrap_torch_dispatch..wrapped) functoolswraps)r)r*rr(r_wrap_torch_dispatchAsr-cseZdZfddZZS)TorchDispatchMetaInitErrorInfocstjddddS)Nrr )Zmode_class_namer )rrrrrrrWsz'TorchDispatchMetaInitErrorInfo.__init__)rrrrrrrrrr.Vsr.cs eZdZdZfddZZS)TorchDispatchModeMetaau Metaclass for :class:`TorchDispatchMode`; it does two things: * Adds an implicit ``inner`` kwarg to ``__init__``, to allow the modes to be chained together to form a stack. * Reenables the inner mode, so that by default PyTorch API calls will compositionally proceed to the next mode on the stack. The default behavior for the second bullet is important, as it is easy to accidentally write ``_wrap_torch_dispatch`` implementations that are not compositional, and the wrapping here makes the obvious code do the right thing (aka, this is why there is a metaclass). csFd|krt|dt|d<d|kr4t|d|d<t||||S)Nr__torch_dispatch__)rr.r-r__new__)metaclsnamebasesdctrrrr1is zTorchDispatchModeMeta.__new__)rrr__doc__r1rrrrrr/Zsr/c@s.eZdZdZddZd ddZedd ZdS) ra A ``TorchDispatchMode`` allows you to override the meaning of all ``__torch_dispatch__`` overrideable functions within a dynamic scope, without having to actually create a tensor subclass or manually monkey-patch functions in the PyTorch API. Some common situations where you should use a mode: * You want to override the meaning of factory functions, or other functions that do not otherwise take a tensor as an argument (these cannot be overridden with tensor subclasses). * You want to override the behavior of all functions without needing to wrap your inputs in tensor subclasses; e.g., if you are just interested in logging intermediate computations. * You want to control the order of execution of various tensor subclasses explicitly, rather than implicitly via the return of ``NotImplemented``. Independent subclasses of :class:`TorchDispatchMode` are compositional: modes can be pushed onto a stack with :func:`push_torch_dispatch_mode`. When you call functions in the PyTorch API inside your ``__torch_dispatch__`` implementation, by default, they will forward on to the next mode on the mode stack. If you want recursively call back into your current ``__torch_dispatch__`` implementation, either explicitly invoke ``self.__torch_dispatch__(...)``, or use the context manager ``__torch_dispatch__(self, replace=self.inner)`` to make PyTorch API self-referential (beware of infinite loops, in this case!) cCsdSrrrrrrrszTorchDispatchMode.__init__rNcCs tdSr)NotImplementedErrorrfunctypesr&r'rrrr0sz$TorchDispatchMode.__torch_dispatch__cOsttj|f||Sr)push_torch_dispatch_moder+partial)clsr&r'rrrpushszTorchDispatchMode.push)rN)rrrr6rr0 classmethodr>rrrrrqs  r) metaclassc@seZdZdddZdS)rrNcCs|dkr i}|||Srrr8rrrr0sz(BaseTorchDispatchMode.__torch_dispatch__)rN)rrrr0rrrrrsrcCst|tdS)N)r#)rr )Zctorrrrr;sr;) contextlibtypingrr+Ztorch.utils._mode_utilsrrrrrZtorch._Crr Z dataclassesr r contextmanagerr$r-r.typer/rrobjectr;rrrrs   $*