HEX

File: //opt/saltstack/salt/lib/python3.10/site-packages/salt/ext/tornado/__pycache__/gen.cpython-310.pyc
o

�N�g���@s�dZddlmZmZmZddlZddlZddlZddlZddl	Z	ddl
Z
ddlZddlZddl
mmZddlmZmZmZmZddlmZddlmZddl
mZddlmZmZzzdd	lmZWneysdd	lmZYnwWney�d
ejvr��dZYnwz2zddl m!Z"Wney�ddl#m!Z"Ynwzddl$m%Z%Wney�ddl#m%Z%YnwWney�d
ejvrƂdd
lm"Z"dd�Z%Ynwer�ddl&Z&nddl'Z&Gdd�de(�Z)Gdd�de(�Z*Gdd�de(�Z+Gdd�de(�Z,Gdd�de(�Z-Gdd�de(�Z.dd�Z/dd�Z0dTd!d"�Z1e�2�Z3d#d$�Z4d%d&�Z5Gd'd(�d(e(�Z6Gd)d*�d*e7�Z8Gd+d,�d,e7�Z9Gd-d.�d.e9�Z:Gd/d0�d0e9�Z;Gd1d2�d2e9�Z<d3d4�Z=Gd5d6�d6e9�Z>d7d8�Z?dUd:d;�Z@e@ZAGd<d=�d=e9�ZBdUd>d?�ZCd@dA�ZDdVdBdC�ZEdDdE�ZFe�ZGeG�Hd�e�ZIdFeI_eI�Hd�GdGdH�dHe7�ZJe�KdIdJdKg�ZLdLdM�ZMe	jNdNk�r�eOe
�PdO��ne1dPdQ��ZQdRdS�ZRedu�r�eeR�ZRzddlSZTWne�y�YdSwedSdS)Wa�	``tornado.gen`` is a generator-based interface to make it easier to
work in an asynchronous environment.  Code using the ``gen`` module
is technically asynchronous, but it is written as a single generator
instead of a collection of separate functions.

For example, the following asynchronous handler:

.. testcode::

    class AsyncHandler(RequestHandler):
        @asynchronous
        def get(self):
            http_client = AsyncHTTPClient()
            http_client.fetch("http://example.com",
                              callback=self.on_fetch)

        def on_fetch(self, response):
            do_something_with_response(response)
            self.render("template.html")

.. testoutput::
   :hide:

could be written with ``gen`` as:

.. testcode::

    class GenAsyncHandler(RequestHandler):
        @gen.coroutine
        def get(self):
            http_client = AsyncHTTPClient()
            response = yield http_client.fetch("http://example.com")
            do_something_with_response(response)
            self.render("template.html")

.. testoutput::
   :hide:

Most asynchronous functions in Tornado return a `.Future`;
yielding this object returns its `~.Future.result`.

You can also yield a list or dict of ``Futures``, which will be
started at the same time and run in parallel; a list or dict of results will
be returned when they are all finished:

.. testcode::

    @gen.coroutine
    def get(self):
        http_client = AsyncHTTPClient()
        response1, response2 = yield [http_client.fetch(url1),
                                      http_client.fetch(url2)]
        response_dict = yield dict(response3=http_client.fetch(url3),
                                   response4=http_client.fetch(url4))
        response3 = response_dict['response3']
        response4 = response_dict['response4']

.. testoutput::
   :hide:

If the `~functools.singledispatch` library is available (standard in
Python 3.4, available via the `singledispatch
<https://pypi.python.org/pypi/singledispatch>`_ package on older
versions), additional types of objects may be yielded. Tornado includes
support for ``asyncio.Future`` and Twisted's ``Deferred`` class when
``tornado.platform.asyncio`` and ``tornado.platform.twisted`` are imported.
See the `convert_yielded` function to extend this mechanism.

.. versionchanged:: 3.2
   Dict support added.

.. versionchanged:: 4.1
   Support added for yielding ``asyncio`` Futures and Twisted Deferreds
   via ``singledispatch``.

�)�absolute_import�division�print_functionN)�Future�TracebackFuture�	is_future�chain_future)�IOLoop)�app_log)�
stack_context)�PY3�raise_exc_info)�singledispatchZAPPENGINE_RUNTIME)�	Generator)�isawaitable)�
GeneratorTypecC�dS�NF�)�xrr�H/opt/saltstack/salt/lib/python3.10/site-packages/salt/ext/tornado/gen.pyr��rc@�eZdZdS)�
KeyReuseErrorN��__name__�
__module__�__qualname__rrrrr��rc@r)�UnknownKeyErrorNrrrrrr�rrc@r)�LeakedCallbackErrorNrrrrrr �rr c@r)�
BadYieldErrorNrrrrrr!�rr!c@r)�ReturnValueIgnoredErrorNrrrrrr"�rr"c@seZdZdZdS)�TimeoutErrorz%Exception raised by ``with_timeout``.N)rrr�__doc__rrrrr#�sr#c	CsBz|jWSty
Ynwz|jdWSttfy YdSw)Nr)�value�AttributeError�args�
IndexError)�errr�_value_from_stopiteration�s��r*cs&t�dd��t����fdd��}|S)a�Callback-oriented decorator for asynchronous generators.

    This is an older interface; for new code that does not need to be
    compatible with versions of Tornado older than 3.0 the
    `coroutine` decorator is recommended instead.

    This decorator is similar to `coroutine`, except it does not
    return a `.Future` and the ``callback`` argument is not treated
    specially.

    In most cases, functions decorated with `engine` should take
    a ``callback`` argument and invoke it with their result when
    they are finished.  One notable exception is the
    `~tornado.web.RequestHandler` :ref:`HTTP verb methods <verbs>`,
    which use ``self.finish()`` in place of a callback argument.
    F��replace_callbackcs*�|i|��}dd�}|�t�|��dS)NcSs"|��durtd|��f��dS)Nz.@gen.engine functions cannot return values: %r)�resultr"��futurerrr�final_callback�s���z/engine.<locals>.wrapper.<locals>.final_callback)�add_done_callbackr�wrap)r'�kwargsr/r0��funcrr�wrapper�szengine.<locals>.wrapper)�_make_coroutine_wrapper�	functools�wraps)r5r6rr4r�engine�sr:TcCst|dd�S)a>Decorator for asynchronous generators.

    Any generator that yields objects from this module must be wrapped
    in either this decorator or `engine`.

    Coroutines may "return" by raising the special exception
    `Return(value) <Return>`.  In Python 3.3+, it is also possible for
    the function to simply use the ``return value`` statement (prior to
    Python 3.3 generators were not allowed to also return values).
    In all versions of Python a coroutine that simply wishes to exit
    early may use the ``return`` statement without a value.

    Functions with this decorator return a `.Future`.  Additionally,
    they may be called with a ``callback`` keyword argument, which
    will be invoked with the future's result when it resolves.  If the
    coroutine fails, the callback will not be run and an exception
    will be raised into the surrounding `.StackContext`.  The
    ``callback`` argument is not visible inside the decorated
    function; it is handled by the decorator itself.

    From the caller's perspective, ``@gen.coroutine`` is similar to
    the combination of ``@return_future`` and ``@gen.engine``.

    .. warning::

       When exceptions occur inside a coroutine, the exception
       information will be stored in the `.Future` object. You must
       examine the result of the `.Future` object, or the exception
       may go unnoticed by your code. This means yielding the function
       if called from another coroutine, using something like
       `.IOLoop.run_sync` for top-level calls, or passing the `.Future`
       to `.IOLoop.add_future`.

    Tr+)r7�r5r,rrr�	coroutine�s#r<cs@�}ttd�rt����t�|���fdd��}||_d|_|S)z�The inner workings of ``@gen.coroutine`` and ``@gen.engine``.

    The two decorators differ in their treatment of the ``callback``
    argument, so we cannot simply implement ``@engine`` in terms of
    ``@coroutine``.
    r<c
sdt�}�rd|vr|�d��t���|�fdd��z	�|i|��}Wn)ttfy;}z
t|�}WYd}~ntd}~wtyL|�	t
���|YSwt|t
�r�ztjj}t|�}tjj|urlt�}|�t�d��Wn*ttfy�}z
|�t|��WYd}~nd}~wty�|�	t
���Yn	wt|||�t|<d}z|Wd}Sd}w|�|�|S)N�callbackcs�|���S�N�r-r.�r=rr�<lambda>#sz:_make_coroutine_wrapper.<locals>.wrapper.<locals>.<lambda>�Ystack_context inconsistency (probably caused by yield within a "with StackContext" block))r�popr	�current�
add_future�Return�
StopIterationr*�	Exception�set_exc_info�sys�exc_info�
isinstancerr�_state�contexts�next�
set_exception�StackContextInconsistentError�
set_result�Runner�_futures_to_runners)r'r3r/r-r)�orig_stack_contexts�yieldedr;r@rr6sP
���
�����

z(_make_coroutine_wrapper.<locals>.wrapperT)�hasattr�typesr<r8r9�__wrapped__�__tornado_coroutine__)r5r,�wrappedr6rr;rr7s	

5r7cCst|dd�S)z�Return whether *func* is a coroutine function, i.e. a function
    wrapped with `~.gen.coroutine`.

    .. versionadded:: 4.5
    rZF)�getattrr4rrr�is_coroutine_functionWsr]cs"eZdZdZd�fdd�	Z�ZS)rFa�Special exception to return a value from a `coroutine`.

    If this exception is raised, its value argument is used as the
    result of the coroutine::

        @gen.coroutine
        def fetch_json(url):
            response = yield AsyncHTTPClient().fetch(url)
            raise gen.Return(json_decode(response.body))

    In Python 3.3, this exception is no longer necessary: the ``return``
    statement can be used directly to return a value (previously
    ``yield`` and ``return`` with a value could not be combined in the
    same function).

    By analogy with the return statement, the value argument is optional,
    but it is never necessary to ``raise gen.Return()``.  The ``return``
    statement can be used with no arguments instead.
    Ncs tt|���||_|f|_dSr>)�superrF�__init__r%r')�selfr%��	__class__rrr_tszReturn.__init__r>)rrrr$r_�
__classcell__rrrarrF`srFc@sHeZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dS)�WaitIteratora�Provides an iterator to yield the results of futures as they finish.

    Yielding a set of futures like this:

    ``results = yield [future1, future2]``

    pauses the coroutine until both ``future1`` and ``future2``
    return, and then restarts the coroutine with the results of both
    futures. If either future is an exception, the expression will
    raise that exception and all the results will be lost.

    If you need to get the result of each future as soon as possible,
    or if you need the result of some futures even if others produce
    errors, you can use ``WaitIterator``::

      wait_iterator = gen.WaitIterator(future1, future2)
      while not wait_iterator.done():
          try:
              result = yield wait_iterator.next()
          except Exception as e:
              print("Error {} from {}".format(e, wait_iterator.current_future))
          else:
              print("Result {} received from {} at {}".format(
                  result, wait_iterator.current_future,
                  wait_iterator.current_index))

    Because results are returned as soon as they are available the
    output from the iterator *will not be in the same order as the
    input arguments*. If you need to know which future produced the
    current result, you can use the attributes
    ``WaitIterator.current_future``, or ``WaitIterator.current_index``
    to get the index of the future from the input list. (if keyword
    arguments were used in the construction of the `WaitIterator`,
    ``current_index`` will use the corresponding keyword).

    On Python 3.5, `WaitIterator` implements the async iterator
    protocol, so it can be used with the ``async for`` statement (note
    that in this version the entire iteration is aborted if any value
    raises an exception, while the previous example can continue past
    individual errors)::

      async for result in gen.WaitIterator(future1, future2):
          print("Result {} received from {} at {}".format(
              result, wait_iterator.current_future,
              wait_iterator.current_index))

    .. versionadded:: 4.1

    .. versionchanged:: 4.3
       Added ``async for`` support in Python 3.5.

    cOs�|r|rtd��|rtdd�|��D��|_t|���}ntdd�t|�D��|_|}t��|_	d|_
|_d|_|D]}|�
|j�q;dS)Nz)You must provide args or kwargs, not bothcs��|]	\}}||fVqdSr>r)�.0�k�frrr�	<genexpr>���z(WaitIterator.__init__.<locals>.<genexpr>csrer>r)rf�irhrrrri�rj)�
ValueError�dict�items�_unfinished�list�values�	enumerate�collections�deque�	_finished�
current_index�current_future�_running_futurer1�_done_callback)r`r'r3Zfuturesr/rrrr_�s�
�zWaitIterator.__init__cCs |js|jrdSd|_|_dS)z2Returns True if this iterator has no more results.FNT)rurorvrw�r`rrr�done�szWaitIterator.donecCs$t�|_|jr|�|j���|jS)z�Returns a `.Future` that will yield the next available result.

        Note that this `.Future` will not be the same object as any of
        the inputs.
        )rrxru�_return_result�popleftrzrrrrO�szWaitIterator.nextcCs.|jr|j��s|�|�dS|j�|�dSr>)rxr{r|ru�append�r`r{rrrry�szWaitIterator._done_callbackcCs$t||j�||_|j�|�|_dS)z�Called set the returned future's state that of the future
        we yielded, and set the current future for the iterator.
        N)rrxrwrorCrvrrrrr|�szWaitIterator._return_resultcCs|�r>rrzrrr�	__aiter__�rzWaitIterator.__aiter__cCs|��r
ttd���|��S)N�StopAsyncIteration)r{r\�builtinsrOrzrrr�	__anext__�szWaitIterator.__anext__N)rrrr$r_r{rOryr|r�r�rrrrrd{s4
	rdc@s(eZdZdZdd�Zdd�Zdd�ZdS)	�
YieldPointz�Base class for objects that may be yielded from the generator.

    .. deprecated:: 4.0
       Use `Futures <.Future>` instead.
    cC�t��)z�Called by the runner after the generator has yielded.

        No other methods will be called on this object before ``start``.
        ��NotImplementedError�r`�runnerrrr�start��zYieldPoint.startcCr�)z�Called by the runner to determine whether to resume the generator.

        Returns a boolean; may be called more than once.
        r�rzrrr�is_ready�r�zYieldPoint.is_readycCr�)z�Returns the value to use as the result of the yield expression.

        This method will only be called once, and only after `is_ready`
        has returned true.
        r�rzrrr�
get_resultszYieldPoint.get_resultN)rrrr$r�r�r�rrrrr��s
r�c@�0eZdZdZdd�Zdd�Zdd�Zdd	�Zd
S)�CallbackaaReturns a callable object that will allow a matching `Wait` to proceed.

    The key may be any value suitable for use as a dictionary key, and is
    used to match ``Callbacks`` to their corresponding ``Waits``.  The key
    must be unique among outstanding callbacks within a single run of the
    generator function, but may be reused across different runs of the same
    function (so constants generally work fine).

    The callback may be called with zero or one arguments; if an argument
    is given it will be returned by `Wait`.

    .. deprecated:: 4.0
       Use `Futures <.Future>` instead.
    cC�
||_dSr>��key�r`r�rrrr_�
zCallback.__init__cCs||_|�|j�dSr>)r��register_callbackr�r�rrrr� szCallback.startcCr�NTrrzrrrr�$rzCallback.is_readycC�|j�|j�Sr>)r��result_callbackr�rzrrrr�'�zCallback.get_resultN�rrrr$r_r�r�r�rrrrr�sr�c@r�)�Waitz�Returns the argument passed to the result of a previous `Callback`.

    .. deprecated:: 4.0
       Use `Futures <.Future>` instead.
    cCr�r>r�r�rrrr_1r�z
Wait.__init__cCr�r>�r�r�rrrr�4r�z
Wait.startcCr�r>�r�r�r�rzrrrr�7r�z
Wait.is_readycCr�r>)r��
pop_resultr�rzrrrr�:r�zWait.get_resultNr�rrrrr�+sr�c@r�)�WaitAlla8Returns the results of multiple previous `Callbacks <Callback>`.

    The argument is a sequence of `Callback` keys, and the result is
    a list of results in the same order.

    `WaitAll` is equivalent to yielding a list of `Wait` objects.

    .. deprecated:: 4.0
       Use `Futures <.Future>` instead.
    cCr�r>��keys)r`r�rrrr_Ir�zWaitAll.__init__cCr�r>r�r�rrrr�Lr�z
WaitAll.startcst�fdd��jD��S)Nc3s�|]	}�j�|�VqdSr>)r�r��rfr�rzrrriPrjz#WaitAll.is_ready.<locals>.<genexpr>)�allr�rzrrzrr�OszWaitAll.is_readycs�fdd��jD�S)Ncsg|]}�j�|��qSr)r�r�r�rzrr�
<listcomp>Ssz&WaitAll.get_result.<locals>.<listcomp>r�rzrrzrr�RszWaitAll.get_resultNr�rrrrr�>s
r�csdt���fdd�}�fdd�}t�|��||dt|�i|��Wd��S1s+wY�S)a�Adapts a callback-based asynchronous function for use in coroutines.

    Takes a function (and optional additional arguments) and runs it with
    those arguments plus a ``callback`` keyword argument.  The argument passed
    to the callback is returned as the result of the yield expression.

    .. versionchanged:: 4.0
       ``gen.Task`` is now a function that returns a `.Future`, instead of
       a subclass of `YieldPoint`.  It still behaves the same way when
       yielded.
    cs ���rdS��|||f�dS)NFT)r{rI)�typr%�tbr.rr�handle_exceptiondszTask.<locals>.handle_exceptioncs���rdS��|�dSr>)r{rRr?r.rrrRjszTask.<locals>.set_resultr=N)rr�ExceptionStackContext�_argument_adapter)r5r'r3r�rRrr.r�TaskVs
��r�c@s.eZdZd
dd�Zdd�Zdd�Zdd	�ZdS)�YieldFutureNcCs||_|pt��|_dS)z�Adapts a `.Future` to the `YieldPoint` interface.

        .. versionchanged:: 4.1
           The ``io_loop`` argument is deprecated.
        N)r/r	rD�io_loop)r`r/r�rrrr_tszYieldFuture.__init__cCsT|j��s ||_t�|_|�|j�|j�|j|�|j��dSd|_|jj	|_
dSr>)r/r{r��objectr�r�r�rEr�r-�	result_fnr�rrrr�}s
zYieldFuture.startcCs|jdur|j�|j�SdSr�r�rzrrrr��s
zYieldFuture.is_readycCs$|jdur|j�|j���S|��Sr>)r�r�r�r-r�rzrrrr��s
zYieldFuture.get_resultr>)rrrr_r�r�r�rrrrr�ss

	
r�cCs@t|t�rtdd�|��D��St|t�rtdd�|D��SdS)z�Returns True if ``children`` contains any YieldPoints.

    ``children`` may be a dict or a list, as used by `MultiYieldPoint`
    and `multi_future`.
    cs��|]}t|t�VqdSr>�rLr��rfrkrrrri���z'_contains_yieldpoint.<locals>.<genexpr>csr�r>r�r�rrrri�r�F)rLrm�anyrqrp)�childrenrrr�_contains_yieldpoint�s


r�rcCs t|�r
t||d�St||d�S)ahRuns multiple asynchronous operations in parallel.

    ``children`` may either be a list or a dict whose values are
    yieldable objects. ``multi()`` returns a new yieldable
    object that resolves to a parallel structure containing their
    results. If ``children`` is a list, the result is a list of
    results in the same order; if it is a dict, the result is a dict
    with the same keys.

    That is, ``results = yield multi(list_of_futures)`` is equivalent
    to::

        results = []
        for future in list_of_futures:
            results.append(yield future)

    If any children raise exceptions, ``multi()`` will raise the first
    one. All others will be logged, unless they are of types
    contained in the ``quiet_exceptions`` argument.

    If any of the inputs are `YieldPoints <YieldPoint>`, the returned
    yieldable object is a `YieldPoint`. Otherwise, returns a `.Future`.
    This means that the result of `multi` can be used in a native
    coroutine if and only if all of its children can be.

    In a ``yield``-based coroutine, it is not normally necessary to
    call this function directly, since the coroutine runner will
    do it automatically when a list or dict is yielded. However,
    it is necessary in ``await``-based coroutines, or to pass
    the ``quiet_exceptions`` argument.

    This function is available under the names ``multi()`` and ``Multi()``
    for historical reasons.

    .. versionchanged:: 4.2
       If multiple yieldables fail, any exceptions after the first
       (which is raised) will be logged. Added the ``quiet_exceptions``
       argument to suppress this logging for selected exception types.

    .. versionchanged:: 4.3
       Replaced the class ``Multi`` and the function ``multi_future``
       with a unified function ``multi``. Added support for yieldables
       other than `YieldPoint` and `.Future`.

    ��quiet_exceptions)r��MultiYieldPoint�multi_future)r�r�rrr�multi�s.r�c@s2eZdZdZddd�Zdd�Zdd�Zd	d
�ZdS)
r�a�Runs multiple asynchronous operations in parallel.

    This class is similar to `multi`, but it always creates a stack
    context even when no children require it. It is not compatible with
    native coroutines.

    .. versionchanged:: 4.2
       If multiple ``YieldPoints`` fail, any exceptions after the first
       (which is raised) will be logged. Added the ``quiet_exceptions``
       argument to suppress this logging for selected exception types.

    .. versionchanged:: 4.3
       Renamed from ``Multi`` to ``MultiYieldPoint``. The name ``Multi``
       remains as an alias for the equivalent `multi` function.

    .. deprecated:: 4.3
       Use `multi` instead.
    rcCs�d|_t|t�rt|���|_|��}g|_|D]}t|t�s#t|�}t|�r+t	|�}|j�
|�qtdd�|jD��s>J�t|j�|_
||_dS)Ncsr�r>r�r�rrrri�r�z+MultiYieldPoint.__init__.<locals>.<genexpr>)r�rLrmrprqr�r��convert_yieldedrr�r~r��set�unfinished_childrenr�)r`r�r�rkrrrr_�s


zMultiYieldPoint.__init__cCs|jD]}|�|�qdSr>)r�r�)r`r�rkrrrr��s
�zMultiYieldPoint.startcCs*tt�dd�|j��}|j�|�|jS)NcSs|��Sr>)r�)rkrrrrAsz*MultiYieldPoint.is_ready.<locals>.<lambda>)rp�	itertools�	takewhiler��difference_update)r`�finishedrrrr��s

�zMultiYieldPoint.is_readycCs�g}d}|jD]3}z	|�|���Wqty:}z|dur#t��}n
t||j�s0tj	ddd�WYd}~qd}~ww|durCt
|�|jdurPtt
|j|��St|�S�Nz!Multiple exceptions in yield listT�rK)r�r~r�rHrJrKrLr�r
�errorr
r�rm�ziprp)r`�result_listrKrhr)rrrr�s&

���
zMultiYieldPoint.get_resultN�rr�rrrrr��s
r�cs�t�t�rt���������nd�ttt����tdd��D��s$J�t���t	���s8��
�dur5ing������fdd�}t�}�D]}||vrW|�|�|�|�qG�S)a�Wait for multiple asynchronous futures in parallel.

    This function is similar to `multi`, but does not support
    `YieldPoints <YieldPoint>`.

    .. versionadded:: 4.0

    .. versionchanged:: 4.2
       If multiple ``Futures`` fail, any exceptions after the first (which is
       raised) will be logged. Added the ``quiet_exceptions``
       argument to suppress this logging for selected exception types.

    .. deprecated:: 4.3
       Use `multi` instead.
    Ncss�|]}t|�VqdSr>)rr�rrrri0s�zmulti_future.<locals>.<genexpr>cs���|��s\g}�D]5}z	|�|���Wqty@}z���r/t|��s.tjddd�n��t	�
��WYd}~qd}~ww���s^�durU��tt
�|���dS��|�dSdSdSr�)�remover~r-rHr{rLr
r�rIrJrKrRrmr�)rhr�r)�r�r/r�r�r�rrr=7s,

�����zmulti_future.<locals>.callback)
rLrmrpr�rq�mapr�r�r�rrR�addr1)r�r�r=Z	listeningrhrr�rr�s$



�r�cCs t|�r|St�}|�|�|S)aConverts ``x`` into a `.Future`.

    If ``x`` is already a `.Future`, it is simply returned; otherwise
    it is wrapped in a new `.Future`.  This is suitable for use as
    ``result = yield gen.maybe_future(f())`` when you don't know whether
    ``f()`` returns a `.Future` or not.

    .. deprecated:: 4.3
       This function only handles ``Futures``, not other yieldable objects.
       Instead of `maybe_future`, check for the non-future result types
       you expect (often just ``None``), and ``yield`` anything unknown.
    )rrrR)rZfutrrr�maybe_futureSs


r�cs�t���t��t����durt����fdd�����fdd�}��||��t�t�r9����fdd���S�����fdd���S)	a)Wraps a `.Future` (or other yieldable object) in a timeout.

    Raises `TimeoutError` if the input future does not complete before
    ``timeout``, which may be specified in any form allowed by
    `.IOLoop.add_timeout` (i.e. a `datetime.timedelta` or an absolute time
    relative to `.IOLoop.time`)

    If the wrapped `.Future` fails after it has timed out, the exception
    will be logged unless it is of a type contained in ``quiet_exceptions``
    (which may be an exception type or a sequence of types).

    Does not support `YieldPoint` subclasses.

    .. versionadded:: 4.0

    .. versionchanged:: 4.1
       Added the ``quiet_exceptions`` argument and the logging of unhandled
       exceptions.

    .. versionchanged:: 4.4
       Added support for yieldable objects other than `.Future`.
    Nc
s^z|��WdSty.}zt|��s#tjd|dd�WYd}~dSWYd}~dSd}~ww)Nz$Exception in Future %r after timeoutTr�)r-rHrLr
r�)r/r)r�rr�error_callback�s
����z$with_timeout.<locals>.error_callbackcs��td������dS)NZTimeout)rPr#r1r)r�r/r-rr�timeout_callback�sz&with_timeout.<locals>.timeout_callbackc�
����Sr>�Zremove_timeoutr.�r��timeout_handlerrrA��
zwith_timeout.<locals>.<lambda>cr�r>r�r.r�rrrA�r�)	r�rrr	rDZadd_timeoutrLr1rE)�timeoutr/r�r�r�r)r�r/r�r�r-r�r�with_timeouths&
�
���r�cs"t��t���|�fdd���S)a�Return a `.Future` that resolves after the given number of seconds.

    When used with ``yield`` in a coroutine, this is a non-blocking
    analogue to `time.sleep` (which should not be used in coroutines
    because it is blocking)::

        yield gen.sleep(0.5)

    Note that calling this function on its own does nothing; you must
    wait on the `.Future` it returns (usually by yielding it).

    .. versionadded:: 4.1
    cs
��d�Sr>)rRr�rhrrrA�r�zsleep.<locals>.<lambda>)rr	rDZ
call_later)Zdurationrr�r�sleep�sr�ahA special object which may be yielded to allow the IOLoop to run for
one iteration.

This is not needed in normal use but it can be helpful in long-running
coroutines that are likely to yield Futures that are ready instantly.

Usage: ``yield gen.moment``

.. versionadded:: 4.0

.. deprecated:: 4.5
   ``yield None`` is now equivalent to ``yield gen.moment``.
c@s`eZdZdZdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�Zdd�Zdd�Z
dS)rSz�Internal implementation of `tornado.gen.engine`.

    Maintains information about pending callbacks and their results.

    The results of the generator are stored in ``result_future`` (a
    `.TracebackFuture`)
    cCsl||_||_t|_d|_d|_d|_d|_d|_d|_	t
��|_d|_
|�|�r4d}}}|��dSdSr)�gen�
result_future�_null_futurer/�yield_point�pending_callbacks�results�runningr��
had_exceptionr	rDr��stack_context_deactivate�handle_yield�run)r`r�r�Z
first_yieldedrrrr_�s

�zRunner.__init__cCs@|jdurt�|_i|_||jvrtd|f��|j�|�dS)z&Adds ``key`` to the list of callbacks.Nzkey %r is already pending)r�r�r�rr�r�rrrr��s

zRunner.register_callbackcCs,|jdus
||jvrtd|f��||jvS)z2Returns true if a result is available for ``key``.Nzkey %r is not pending)r�rr�r�rrrr��s
zRunner.is_readycCsh||j|<|jdur0|j��r2z|j�|j���Wn|j�t���Yd|_|�	�dSdSdS)zASets the result for ``key`` and attempts to resume the generator.N)
r�r�r�r/rRr�rIrJrKr�)r`r�r-rrrrR�s
�zRunner.set_resultcCs|j�|�|j�|�S)z2Returns the result for ``key`` and unregisters it.)r�r�r�rCr�rrrr�	szRunner.pop_resultc
Cs�|js|jrdSz�d|_	|j}|��sWd|_dSd|_zHtjj}d}z|��}Wnty:d|_	t
��}Ynwd}|durOz
|jj
|�}Wd}n	d}w|j�|�}tjj|urd|j�
t�d��Wn]ttfy�}z-d|_t|_|jr�|j	s�td|j��|j�t|��d|_|��WYd}~Wd|_dSd}~wty�d|_t|_|j�t
���d|_|��YWd|_dSw|�|�s�Wd|_dSd}q
d|_w)zkStarts or resumes the generator, running until it reaches a
        yield point that is not ready.
        NTFrBz)finished without waiting for callbacks %r)r�r�r/r{rrMrNr-rHr�rJrKr��throw�sendrQrGrFr�r�r r�rRr*�_deactivate_stack_contextrIr�)r`r/rUrKr%rVr)rrrr�s|
6�������
��
�

��9z
Runner.runcst��rt���t�t�rJt��_��fdd���jdurFt��j	��}|�_��fdd�}�j
�|�	Wd�dS1s@wYn!��nzt���_Wnt
yft��_�j�t���Ynw�j��rq�jtur��fdd�}�j
��j|�dSdS)	Ncsbz�������r�j�����WdS��_WdSty0t��_�j�t	�
��YdSwr>)r�r�r/rRr�r�rHrrIrJrKr)r`rVrr�start_yield_point\s

��z.Runner.handle_yield.<locals>.start_yield_pointcs�����dSr>�r�r)r`r�rr�cboszRunner.handle_yield.<locals>.cbFcsd}���dSr>r�r�rzrr�inner~sz"Runner.handle_yield.<locals>.innerT)r�r�rLr�rr/r�rr�r�r�Zadd_callbackr�r!rIrJrKr{�momentrE)r`rVZ
deactivater�r�r)r`r�rVrr�Qs:

�"�
��zRunner.handle_yieldcCst�tt�|j|���Sr>)rr2r�r8�partialrRr�rrrr��s�zRunner.result_callbackcCs6|js|jst�|_|j�|||f�|��dSdS)NTF)r�r�rr/rIr�)r`r�r%r�rrrr��szRunner.handle_exceptioncCs |jdur|��d|_dSdSr>)r�rzrrrr��s

�z Runner._deactivate_stack_contextN)rrrr$r_r�r�rRr�r�r�r�r�r�rrrrrS�s
C6	rS�	Argumentsr'r3cs�fdd�}|S)aReturns a function that when invoked runs ``callback`` with one arg.

    If the function returned by this function is called with exactly
    one argument, that argument is passed to ``callback``.  Otherwise
    the args tuple and kwargs dict are wrapped in an `Arguments` object.
    csB|st|�dkr�t||��dS|r�|d�dS�d�dS)N�r)�lenr�)r'r3r@rrr6�s
z"_argument_adapter.<locals>.wrapperr)r=r6rr@rr��sr�)�r�z�
    @coroutine
    def _wrap_awaitable(x):
        if hasattr(x, '__await__'):
            x = x.__await__()
        return (yield from x)
    c
cs��t|d�r|��}nt|�}zt|�}Wnty.}z
t|�}WYd}~t|��d}~ww	z|V}WnjtyV}zz|j}Wn
tyLY|�w|�|�d}~wt	y�}z>t
��}z|j}Wn	tyo|�wz||�}Wnty�}zt|�}WYd}~WYd}~t|��d}~wwWYd}~n/d}~wwz|dur�t|�}n|�
|�}Wnty�}z
t|�}WYd}~t|��d}~wwq0)N�	__await__)rWr��iterrOrGr*�
GeneratorExit�closer&�
BaseExceptionrJrKr�r�rF)rZ_iZ_y�_eZ_rZ_s�_mZ_xrrr�_wrap_awaitable�sl�

"��

��
�
�����


�
���r�cCsL|durtSt|ttf�rt|�St|�r|St|�rt|�Std|f��)a�Convert a yielded object into a `.Future`.

    The default implementation accepts lists, dictionaries, and Futures.

    If the `~functools.singledispatch` library is available, this function
    may be extended to support additional types. For example::

        @convert_yielded.register(asyncio.Future)
        def _(asyncio_future):
            return tornado.platform.asyncio.to_tornado_future(asyncio_future)

    .. versionadded:: 4.1
    Nzyielded unknown object %r)	r�rLrprmr�rrr�r!)rVrrrr��sr�)Tr�)Nr)Ur$Z
__future__rrrrsr8r��osrJ�textwraprX�weakrefZsalt.ext.tornado�extZtornadoZsalt.ext.tornado.concurrentrrrrZsalt.ext.tornado.ioloopr	Zsalt.ext.tornado.logr
rZsalt.ext.tornado.utilrr
r�ImportError�environ�collections.abcrrZsalt.ext.backports_abc�inspectrr�Z__builtin__rHrrr r!r"r#r*r:r<�WeakKeyDictionaryrTr7r]rFr�rdr�r�r�r�r�r�r�r�ZMultir�r�r�r�r�r�rRr�rS�
namedtupler�r��version_info�exec�dedentr�r�Z!salt.ext.tornado.platform.asyncio�saltrrrr�<module>s�M��
����
�

#7H	v!

4
B9
A
�
J

-
	��