o
    Zht                     @  sr   d dl mZ d dlmZmZ d dlZdgZedZG dd deej	j
eeZG dd	 d	ej	j
ee ed
Z
dS )    )annotations)GenericTypeVarNAwaitWc                   @  s   e Zd ZdS )_PyAwaitMetaN)__name__
__module____qualname__ r   r   E/var/www/auris/lib/python3.10/site-packages/torch/_awaits/__init__.pyr      s    r   c                   @  s   e Zd ZdZdS )_AwaitaC  
    Wrapper around a ``torch._C.Await`` which encapsulates delayed execution
    of a callable. All manipulations happen with functions ``torch.jit._awaitable``,
    ``torch.jit._awaitable_wait``, ``torch.jit._awaitable_nowait``.

    Torch scriptable manipulations:
    ``torch.jit._awaitable(func, *args)``
    Creates ``Await[W]`` object, where W is return type of func.

    Returns:
    ``torch.jit._awaitable_wait(Await[W])``
    Returns the result of the function, specified at ``_awaitable``,  with specified arguments.

    Returns:
        The result of type ``W`` of the function call. The result is owned by ``Await[W]``
        and returned on all following ``_awaitable_wait`` calls.


    ``torch.jit._awaitable_nowait(W)``
    Returns:
        Trivial ``Await[W]`` with specified result.


    Only in eager mode:
    ``fn() -> Callable[Tuple[Any], W]``
    Returns:
        Specified at ``_awaitable`` python function ``func``.

    ``args() -> Tuple[Any]``
    Returns:
        Specified at ``_awaitable`` python args.

    ``is_nowait() -> _bool``
    Returns:
        ``True`` if this object was created via ``_awaitable_nowait`` call (trivial `Await[W]`).

    In eager mode ``Await[W]`` can be used as ``W`` i.e. attributes of W can be called on ``Await[W]``,
    ``_awaitable_wait()`` call will be transparently added.
    N)r   r	   r
   __doc__r   r   r   r   r      s    r   )	metaclass)
__future__r   typingr   r   Ztorch__all__r   typeZ_Cr   r   r   r   r   r   <module>   s    "