a
    õ£Beø‹  ã                   @   sT  d Z ddlZddlZddlZddlZddlZddlZddlZddl	Z	ddl
Z
ddlZddlZddlmZ ddlmZmZmZmZmZ ddlmZ ddlmZmZmZ ddlZddlmZmZmZmZm Z m!Z!m"Z"m#Z# ej$røddlm%Z%m&Z& dd	l'm(Z( ne)Z(G d
d„ de(ƒZ*e!dƒZ+e!de*d�Z,G dd„ deƒZ-G dd„ de)ƒZ.G dd„ de)ƒZ/dS )a©  An I/O event loop for non-blocking sockets.

In Tornado 6.0, `.IOLoop` is a wrapper around the `asyncio` event loop, with a
slightly different interface. The `.IOLoop` interface is now provided primarily
for backwards compatibility; new code should generally use the `asyncio` event
loop interface directly. The `IOLoop.current` class method provides the
`IOLoop` instance corresponding to the running `asyncio` event loop.

é    N)Úisawaitable)ÚFutureÚ	is_futureÚchain_futureÚfuture_set_exc_infoÚfuture_add_done_callback)Úapp_log)ÚConfigurableÚTimeoutErrorÚimport_object)ÚUnionÚAnyÚTypeÚOptionalÚCallableÚTypeVarÚTupleÚ	Awaitable)ÚDictÚList)ÚProtocolc                   @   s(   e Zd Zedœdd„Zddœdd„ZdS )Ú_Selectable©Úreturnc                 C   s   d S ©N© ©Úselfr   r   úQ/home/yuhw/wc/wire-cell-python/wcpy/lib/python3.9/site-packages/tornado/ioloop.pyÚfileno=   s    z_Selectable.filenoNc                 C   s   d S r   r   r   r   r   r   Úclose@   s    z_Selectable.close)Ú__name__Ú
__module__Ú__qualname__Úintr   r    r   r   r   r   r   <   s   r   Ú_TÚ_S)Úboundc                       sž  e Zd ZdZdZdZdZdZeƒ Z	e
deddœ‡ fd	d
„ƒZed dœdd„ƒZddœdd„Zeddœdd„ƒZejed dœdd„ƒƒZejedkeed  dœdd„ƒƒZedleed  dœdd„ƒZddœdd„Zddœdd„Zeddœdd„ƒZeddœdd„ƒZddœd d!„Ze
ee dœd"d#„ƒZe
ee dœd$d%„ƒZdmedd&œd'd(„Zdnedd*œd+d,„Z eje!e"e!e!gdf e!dd-œd.d/„ƒZ#eje$e"e$e!gdf e!dd-œd0d/„ƒZ#e%e!e&f e"d1 e!dd-œd2d/„Z#e%e!e&f e!dd3œd4d5„Z'e%e!e&f dd6œd7d8„Z(ddœd9d:„Z)ddœd;d<„Z*doe"ee+ ed=œd>d?„Z,e+dœd@dA„Z-e%e+e.j/f e"eee0dBœdCdD„Z1e+e"eee0dEœdFdG„Z2e+e"eee0dHœdIdJ„Z3e0ddKœdLdM„Z4e"eeddNœdOdP„Z5e"eeddNœdQdR„Z6e"eeddNœdSdT„Z7dUe"dVgdf ddWœdXdY„Z8ee9j:j; e"dZe<f ee=e< d[œd\d]„Z>e9j:j;dd^œd_d`„Z?e"g ef ddaœdbdc„Z@eAdddœdedf„ZBe%e!e&f eCe!e%e!e&f f d6œdgdh„ZDe%e!e&f dd6œdidj„ZE‡  ZFS )pÚIOLoopaÿ  An I/O event loop.

    As of Tornado 6.0, `IOLoop` is a wrapper around the `asyncio` event loop.

    Example usage for a simple TCP server:

    .. testcode::

        import asyncio
        import errno
        import functools
        import socket

        import tornado
        from tornado.iostream import IOStream

        async def handle_connection(connection, address):
            stream = IOStream(connection)
            message = await stream.read_until_close()
            print("message from client:", message.decode().strip())

        def connection_ready(sock, fd, events):
            while True:
                try:
                    connection, address = sock.accept()
                except BlockingIOError:
                    return
                connection.setblocking(0)
                io_loop = tornado.ioloop.IOLoop.current()
                io_loop.spawn_callback(handle_connection, connection, address)

        async def main():
            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0)
            sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
            sock.setblocking(0)
            sock.bind(("", 8888))
            sock.listen(128)

            io_loop = tornado.ioloop.IOLoop.current()
            callback = functools.partial(connection_ready, sock)
            io_loop.add_handler(sock.fileno(), callback, io_loop.READ)
            await asyncio.Event().wait()

        if __name__ == "__main__":
            asyncio.run(main())

    .. testoutput::
       :hide:

    Most applications should not attempt to construct an `IOLoop` directly,
    and instead initialize the `asyncio` event loop and use `IOLoop.current()`.
    In some cases, such as in test frameworks when initializing an `IOLoop`
    to be run in a secondary thread, it may be appropriate to construct
    an `IOLoop` with ``IOLoop(make_current=False)``.

    In general, an `IOLoop` cannot survive a fork or be shared across processes
    in any way. When multiple processes are being used, each process should
    create its own `IOLoop`, which also implies that any objects which depend on
    the `IOLoop` (such as `.AsyncHTTPClient`) must also be created in the child
    processes. As a guideline, anything that starts processes (including the
    `tornado.process` and `multiprocessing` modules) should do so as early as
    possible, ideally the first thing the application does after loading its
    configuration, and *before* any calls to `.IOLoop.start` or `asyncio.run`.

    .. versionchanged:: 4.2
       Added the ``make_current`` keyword argument to the `IOLoop`
       constructor.

    .. versionchanged:: 5.0

       Uses the `asyncio` event loop by default. The ``IOLoop.configure`` method
       cannot be used on Python 3 except to redundantly specify the `asyncio`
       event loop.

    .. versionchanged:: 6.3
       ``make_current=True`` is now the default when creating an IOLoop -
       previously the default was to make the event loop current if there wasn't
       already a current one.
    r   é   é   é   z$Union[None, str, Type[Configurable]]N)ÚimplÚkwargsr   c                    sV   ddl m} t|tƒrt|ƒ}t|tƒr:t||ƒs:tdƒ‚tt	| ƒj
|fi |¤Ž d S )Nr   )ÚBaseAsyncIOLoopz5only AsyncIOLoop is allowed when asyncio is available)Útornado.platform.asyncior.   Ú
isinstanceÚstrr   ÚtypeÚ
issubclassÚRuntimeErrorÚsuperr(   Ú	configure)Úclsr,   r-   r.   ©Ú	__class__r   r   r6   ¢   s    
zIOLoop.configurer   c                   C   s   t  ¡ S )aK  Deprecated alias for `IOLoop.current()`.

        .. versionchanged:: 5.0

           Previously, this method returned a global singleton
           `IOLoop`, in contrast with the per-thread `IOLoop` returned
           by `current()`. In nearly all cases the two were the same
           (when they differed, it was generally used from non-Tornado
           threads to communicate back to the main thread's `IOLoop`).
           This distinction is not present in `asyncio`, so in order
           to facilitate integration with that package `instance()`
           was changed to be an alias to `current()`. Applications
           using the cross-thread communications aspect of
           `instance()` should instead set their own global variable
           to point to the `IOLoop` they want to use.

        .. deprecated:: 5.0
        )r(   Úcurrentr   r   r   r   Úinstance®   s    zIOLoop.instancec                 C   s   |   ¡  dS )a`  Deprecated alias for `make_current()`.

        .. versionchanged:: 5.0

           Previously, this method would set this `IOLoop` as the
           global singleton used by `IOLoop.instance()`. Now that
           `instance()` is an alias for `current()`, `install()`
           is an alias for `make_current()`.

        .. deprecated:: 5.0
        N)Úmake_currentr   r   r   r   ÚinstallÄ   s    zIOLoop.installc                   C   s   t  ¡  dS )ak  Deprecated alias for `clear_current()`.

        .. versionchanged:: 5.0

           Previously, this method would clear the `IOLoop` used as
           the global singleton by `IOLoop.instance()`. Now that
           `instance()` is an alias for `current()`,
           `clear_instance()` is an alias for `clear_current()`.

        .. deprecated:: 5.0

        N)r(   Úclear_currentr   r   r   r   Úclear_instanceÒ   s    zIOLoop.clear_instancec                   C   s   d S r   r   r   r   r   r   r:   â   s    zIOLoop.currentT)r;   r   c                 C   s   d S r   r   ©r;   r   r   r   r:   ç   s    c                 C   s|   zt  ¡ }W n. ty:   | s$Y dS t  ¡ }t  |¡ Y n0 ztj| W S  tyv   | rnddlm	} |ƒ }nd}Y n0 |S )aC  Returns the current thread's `IOLoop`.

        If an `IOLoop` is currently running or has been marked as
        current by `make_current`, returns that instance.  If there is
        no current `IOLoop` and ``instance`` is true, creates one.

        .. versionchanged:: 4.1
           Added ``instance`` argument to control the fallback to
           `IOLoop.instance()`.
        .. versionchanged:: 5.0
           On Python 3, control of the current `IOLoop` is delegated
           to `asyncio`, with this and other methods as pass-through accessors.
           The ``instance`` argument now controls whether an `IOLoop`
           is created automatically when there is none, instead of
           whether we fall back to `IOLoop.instance()` (which is now
           an alias for this method). ``instance=False`` is deprecated,
           since even if we do not create an `IOLoop`, this method
           may initialize the asyncio loop.

        .. deprecated:: 6.2
           It is deprecated to call ``IOLoop.current()`` when no `asyncio`
           event loop is running.
        Nr   )ÚAsyncIOMainLoop)
ÚasyncioÚget_event_loopr4   Únew_event_loopÚset_event_loopr(   Ú_ioloop_for_asyncioÚKeyErrorr/   rA   )r;   ÚlooprA   r:   r   r   r   r:   ì   s    
c                 C   s   t jdtdd� |  ¡  dS )aó  Makes this the `IOLoop` for the current thread.

        An `IOLoop` automatically becomes current for its thread
        when it is started, but it is sometimes useful to call
        `make_current` explicitly before starting the `IOLoop`,
        so that code run at startup time can find the right
        instance.

        .. versionchanged:: 4.1
           An `IOLoop` created while there is no current `IOLoop`
           will automatically become current.

        .. versionchanged:: 5.0
           This method also sets the current `asyncio` event loop.

        .. deprecated:: 6.2
           Setting and clearing the current event loop through Tornado is
           deprecated. Use ``asyncio.set_event_loop`` instead if you need this.
        z6make_current is deprecated; start the event loop firsté   ©Ú
stacklevelN)ÚwarningsÚwarnÚDeprecationWarningÚ_make_currentr   r   r   r   r<     s    ýzIOLoop.make_currentc                 C   s
   t ƒ ‚d S r   ©ÚNotImplementedErrorr   r   r   r   rO   4  s    zIOLoop._make_currentc                   C   s   t jdtdd� t ¡  dS )zÿClears the `IOLoop` for the current thread.

        Intended primarily for use by test frameworks in between tests.

        .. versionchanged:: 5.0
           This method also clears the current `asyncio` event loop.
        .. deprecated:: 6.2
        zclear_current is deprecatedrI   rJ   N)rL   rM   rN   r(   Ú_clear_currentr   r   r   r   r>   8  s    
ýzIOLoop.clear_currentc                  C   s    t jdd�} | d ur|  ¡  d S )NFr@   )r(   r:   Ú_clear_current_hook)Úoldr   r   r   rR   I  s    zIOLoop._clear_currentc                 C   s   dS )z�Instance method called when an IOLoop ceases to be current.

        May be overridden by subclasses as a counterpart to make_current.
        Nr   r   r   r   r   rS   O  s    zIOLoop._clear_current_hookc                 C   s   t S r   )r(   )r7   r   r   r   Úconfigurable_baseV  s    zIOLoop.configurable_basec                 C   s   ddl m} |S )Nr   )ÚAsyncIOLoop)r/   rV   )r7   rV   r   r   r   Úconfigurable_defaultZ  s    zIOLoop.configurable_default)r<   r   c                 C   s   |r|   ¡  d S r   )rO   )r   r<   r   r   r   Ú
initialize`  s    zIOLoop.initializeF)Úall_fdsr   c                 C   s
   t ƒ ‚dS )a¨  Closes the `IOLoop`, freeing any resources used.

        If ``all_fds`` is true, all file descriptors registered on the
        IOLoop will be closed (not just the ones created by the
        `IOLoop` itself).

        Many applications will only use a single `IOLoop` that runs for the
        entire lifetime of the process.  In that case closing the `IOLoop`
        is not necessary since everything will be cleaned up when the
        process exits.  `IOLoop.close` is provided mainly for scenarios
        such as unit tests, which create and destroy a large number of
        ``IOLoops``.

        An `IOLoop` must be completely stopped before it can be closed.  This
        means that `IOLoop.stop()` must be called *and* `IOLoop.start()` must
        be allowed to return before attempting to call `IOLoop.close()`.
        Therefore the call to `close` will usually appear just after
        the call to `start` rather than near the call to `stop`.

        .. versionchanged:: 3.1
           If the `IOLoop` implementation supports non-integer objects
           for "file descriptors", those objects will have their
           ``close`` method when ``all_fds`` is true.
        NrP   )r   rY   r   r   r   r    d  s    zIOLoop.close)ÚfdÚhandlerÚeventsr   c                 C   s   d S r   r   ©r   rZ   r[   r\   r   r   r   Úadd_handler  s    zIOLoop.add_handlerc                 C   s   d S r   r   r]   r   r   r   r^   …  s    ).Nc                 C   s
   t ƒ ‚dS )a+  Registers the given handler to receive the given events for ``fd``.

        The ``fd`` argument may either be an integer file descriptor or
        a file-like object with a ``fileno()`` and ``close()`` method.

        The ``events`` argument is a bitwise or of the constants
        ``IOLoop.READ``, ``IOLoop.WRITE``, and ``IOLoop.ERROR``.

        When an event occurs, ``handler(fd, events)`` will be run.

        .. versionchanged:: 4.0
           Added the ability to pass file-like objects in addition to
           raw file descriptors.
        NrP   r]   r   r   r   r^   ‹  s    )rZ   r\   r   c                 C   s
   t ƒ ‚dS )z¹Changes the events we listen for ``fd``.

        .. versionchanged:: 4.0
           Added the ability to pass file-like objects in addition to
           raw file descriptors.
        NrP   )r   rZ   r\   r   r   r   Úupdate_handlerž  s    zIOLoop.update_handler)rZ   r   c                 C   s
   t ƒ ‚dS )zµStop listening for events on ``fd``.

        .. versionchanged:: 4.0
           Added the ability to pass file-like objects in addition to
           raw file descriptors.
        NrP   ©r   rZ   r   r   r   Úremove_handler§  s    zIOLoop.remove_handlerc                 C   s
   t ƒ ‚dS )z¶Starts the I/O loop.

        The loop will run until one of the callbacks calls `stop()`, which
        will make the loop stop after the current event iteration completes.
        NrP   r   r   r   r   Ústart°  s    zIOLoop.startc                 C   s
   t ƒ ‚dS )a‘  Stop the I/O loop.

        If the event loop is not currently running, the next call to `start()`
        will return immediately.

        Note that even after `stop` has been called, the `IOLoop` is not
        completely stopped until `IOLoop.start` has also returned.
        Some work that was scheduled before the call to `stop` may still
        be run before the `IOLoop` shuts down.
        NrP   r   r   r   r   Ústop¸  s    zIOLoop.stop)ÚfuncÚtimeoutr   c                    s°   dg‰ddœ‡ ‡‡fdd„}ˆ  |¡ |durVddœ‡‡fdd„}ˆ ˆ ¡ | |¡}ˆ ¡  |durpˆ |¡ ˆd dus€J ‚ˆd  ¡ s˜ˆd  ¡ s¤td| ƒ‚ˆd  ¡ S )	a¯  Starts the `IOLoop`, runs the given function, and stops the loop.

        The function must return either an awaitable object or
        ``None``. If the function returns an awaitable object, the
        `IOLoop` will run until the awaitable is resolved (and
        `run_sync()` will return the awaitable's result). If it raises
        an exception, the `IOLoop` will stop and the exception will be
        re-raised to the caller.

        The keyword-only argument ``timeout`` may be used to set
        a maximum duration for the function.  If the timeout expires,
        a `asyncio.TimeoutError` is raised.

        This method is useful to allow asynchronous calls in a
        ``main()`` function::

            async def main():
                # do stuff...

            if __name__ == '__main__':
                IOLoop.current().run_sync(main)

        .. versionchanged:: 4.3
           Returning a non-``None``, non-awaitable value is now an error.

        .. versionchanged:: 5.0
           If a timeout occurs, the ``func`` coroutine will be cancelled.

        .. versionchanged:: 6.2
           ``tornado.util.TimeoutError`` is now an alias to ``asyncio.TimeoutError``.
        Nr   c                     s¬   z&ˆ ƒ } | d ur$ddl m} || ƒ} W n. tyT   tƒ }|ˆd< t|t ¡ ƒ Y n,0 t| ƒrh| ˆd< ntƒ }|ˆd< | | ¡ ˆd d us�J ‚ˆ 	ˆd ‡fdd„¡ d S )Nr   )Úconvert_yieldedc                    s   ˆ   ¡ S r   )rc   )Úfuturer   r   r   Ú<lambda>ú  ó    z.IOLoop.run_sync.<locals>.run.<locals>.<lambda>)
Ztornado.genrf   Ú	Exceptionr   r   ÚsysÚexc_infor   Ú
set_resultÚ
add_future)Úresultrf   Úfut©rd   Úfuture_cellr   r   r   Úrunç  s     

zIOLoop.run_sync.<locals>.runc                      s(   ˆ d d usJ ‚ˆ d   ¡ s$ˆ ¡  d S )Nr   )Úcancelrc   r   )rr   r   r   r   Útimeout_callbackÿ  s    z)IOLoop.run_sync.<locals>.timeout_callbackr   z$Operation timed out after %s seconds)	Úadd_callbackÚadd_timeoutÚtimerb   Úremove_timeoutÚ	cancelledÚdoner
   ro   )r   rd   re   rs   ru   Útimeout_handler   rq   r   Úrun_syncÅ  s     
	
zIOLoop.run_syncc                 C   s   t   ¡ S )a‡  Returns the current time according to the `IOLoop`'s clock.

        The return value is a floating-point number relative to an
        unspecified time in the past.

        Historically, the IOLoop could be customized to use e.g.
        `time.monotonic` instead of `time.time`, but this is not
        currently supported and so this method is equivalent to
        `time.time`.

        )rx   r   r   r   r   rx     s    zIOLoop.time)ÚdeadlineÚcallbackÚargsr-   r   c                 O   sh   t |tjƒr&| j||g|¢R i |¤ŽS t |tjƒrX| j|  ¡ | ¡  |g|¢R i |¤ŽS td| ƒ‚dS )a   Runs the ``callback`` at the time ``deadline`` from the I/O loop.

        Returns an opaque handle that may be passed to
        `remove_timeout` to cancel.

        ``deadline`` may be a number denoting a time (on the same
        scale as `IOLoop.time`, normally `time.time`), or a
        `datetime.timedelta` object for a deadline relative to the
        current time.  Since Tornado 4.0, `call_later` is a more
        convenient alternative for the relative case since it does not
        require a timedelta object.

        Note that it is not safe to call `add_timeout` from other threads.
        Instead, you must use `add_callback` to transfer control to the
        `IOLoop`'s thread, and then call `add_timeout` from there.

        Subclasses of IOLoop must implement either `add_timeout` or
        `call_at`; the default implementations of each will call
        the other.  `call_at` is usually easier to implement, but
        subclasses that wish to maintain compatibility with Tornado
        versions prior to 4.0 must use `add_timeout` instead.

        .. versionchanged:: 4.0
           Now passes through ``*args`` and ``**kwargs`` to the callback.
        úUnsupported deadline %rN)	r0   ÚnumbersÚRealÚcall_atÚdatetimeÚ	timedeltarx   Útotal_secondsÚ	TypeError)r   r~   r   r€   r-   r   r   r   rw     s     ÿÿÿzIOLoop.add_timeout)Údelayr   r€   r-   r   c                 O   s"   | j |  ¡ | |g|¢R i |¤ŽS )a‚  Runs the ``callback`` after ``delay`` seconds have passed.

        Returns an opaque handle that may be passed to `remove_timeout`
        to cancel.  Note that unlike the `asyncio` method of the same
        name, the returned object does not have a ``cancel()`` method.

        See `add_timeout` for comments on thread-safety and subclassing.

        .. versionadded:: 4.0
        )r„   rx   )r   r‰   r   r€   r-   r   r   r   Ú
call_laterH  s    zIOLoop.call_later)Úwhenr   r€   r-   r   c                 O   s   | j ||g|¢R i |¤ŽS )aæ  Runs the ``callback`` at the absolute time designated by ``when``.

        ``when`` must be a number using the same reference point as
        `IOLoop.time`.

        Returns an opaque handle that may be passed to `remove_timeout`
        to cancel.  Note that unlike the `asyncio` method of the same
        name, the returned object does not have a ``cancel()`` method.

        See `add_timeout` for comments on thread-safety and subclassing.

        .. versionadded:: 4.0
        )rw   )r   r‹   r   r€   r-   r   r   r   r„   W  s    zIOLoop.call_at)re   r   c                 C   s
   t ƒ ‚dS )zÃCancels a pending timeout.

        The argument is a handle as returned by `add_timeout`.  It is
        safe to call `remove_timeout` even if the callback has already
        been run.
        NrP   )r   re   r   r   r   ry   i  s    zIOLoop.remove_timeout)r   r€   r-   r   c                 O   s
   t ƒ ‚dS )a3  Calls the given callback on the next I/O loop iteration.

        It is safe to call this method from any thread at any time,
        except from a signal handler.  Note that this is the **only**
        method in `IOLoop` that makes this thread-safety guarantee; all
        other interaction with the `IOLoop` must be done from that
        `IOLoop`'s thread.  `add_callback()` may be used to transfer
        control from other threads to the `IOLoop`'s thread.

        To add a callback from a signal handler, see
        `add_callback_from_signal`.
        NrP   ©r   r   r€   r-   r   r   r   rv   r  s    zIOLoop.add_callbackc                 O   s
   t ƒ ‚dS )z›Calls the given callback on the next I/O loop iteration.

        Safe for use from a Python signal handler; should not be used
        otherwise.
        NrP   rŒ   r   r   r   Úadd_callback_from_signal�  s    zIOLoop.add_callback_from_signalc                 O   s   | j |g|¢R i |¤Ž dS )z§Calls the given callback on the next IOLoop iteration.

        As of Tornado 6.0, this method is equivalent to `add_callback`.

        .. versionadded:: 4.0
        N©rv   rŒ   r   r   r   Úspawn_callback‹  s    zIOLoop.spawn_callbackz0Union[Future[_T], concurrent.futures.Future[_T]]z
Future[_T])rg   r   r   c                    sH   t ˆtƒr"ˆ ‡ ‡‡fdd„¡ n"tˆƒs.J ‚tˆ‡ ‡‡fdd„ƒ dS )aA  Schedules a callback on the ``IOLoop`` when the given
        `.Future` is finished.

        The callback is invoked with one argument, the
        `.Future`.

        This method only accepts `.Future` objects and not other
        awaitables (unlike most of Tornado where the two are
        interchangeable).
        c                    s   ˆ  t ˆ ˆ¡¡S r   )Ú_run_callbackÚ	functoolsÚpartial©Úf©r   rg   r   r   r   rh   ­  ri   z#IOLoop.add_future.<locals>.<lambda>c                    s   ˆ  ˆ ˆ¡S r   rŽ   r“   r•   r   r   rh   ´  ri   N)r0   r   Úadd_done_callbackr   r   )r   rg   r   r   r•   r   rn   ”  s    
	ÿÿzIOLoop.add_future.)Úexecutorrd   r€   r   c                    sj   |du r:t | dƒs4ddlm} tjj|ƒ d d�| _| j}|j|g|¢R Ž }tƒ ‰ |  	|‡ fdd„¡ ˆ S )	z÷Runs a function in a ``concurrent.futures.Executor``. If
        ``executor`` is ``None``, the IO loop's default executor will be used.

        Use `functools.partial` to pass keyword arguments to ``func``.

        .. versionadded:: 5.0
        NÚ	_executorr   )Ú	cpu_counté   )Úmax_workersc                    s
   t | ˆ ƒS r   )r   r“   ©Zt_futurer   r   rh   Ð  ri   z(IOLoop.run_in_executor.<locals>.<lambda>)
ÚhasattrZtornado.processr™   Ú
concurrentÚfuturesÚThreadPoolExecutorr˜   Úsubmitr   rn   )r   r—   rd   r€   r™   Zc_futurer   rœ   r   Úrun_in_executor·  s    
ÿzIOLoop.run_in_executor)r—   r   c                 C   s
   || _ dS )zfSets the default executor to use with :meth:`run_in_executor`.

        .. versionadded:: 5.0
        N)r˜   )r   r—   r   r   r   Úset_default_executorÓ  s    zIOLoop.set_default_executor)r   r   c                 C   sŠ   zP|ƒ }|durNddl m} z| |¡}W n |jy>   Y n0 |  || j¡ W n4 tjyd   Y n" ty„   t	j
d|dd� Y n0 dS )z€Runs a callback with error handling.

        .. versionchanged:: 6.0

           CancelledErrors are no longer logged.
        Nr   )ÚgenúException in callback %rT©rl   )Útornador¤   rf   ZBadYieldErrorrn   Ú_discard_future_resultrB   ÚCancelledErrorrj   r   Úerror)r   r   Úretr¤   r   r   r   r�   Ú  s    zIOLoop._run_callback)rg   r   c                 C   s   |  ¡  dS )z;Avoid unhandled-exception warnings from spawned coroutines.N)ro   )r   rg   r   r   r   r¨   ø  s    zIOLoop._discard_future_resultc                 C   s   t |tƒr||fS | ¡ |fS r   )r0   r$   r   r`   r   r   r   Úsplit_fdü  s    
zIOLoop.split_fdc                 C   s:   z"t |tƒrt |¡ n| ¡  W n ty4   Y n0 d S r   )r0   r$   Úosr    ÚOSErrorr`   r   r   r   Úclose_fd  s    
zIOLoop.close_fd)T)T)T)F)N)Gr!   r"   r#   Ú__doc__ÚNONEÚREADÚWRITEÚERRORÚdictrF   Úclassmethodr   r6   Ústaticmethodr;   r=   r?   ÚtypingÚoverloadr:   Úboolr   r<   rO   r>   rR   rS   r   r	   rU   rW   rX   r    r$   r   r^   r&   r   r   r_   ra   rb   rc   Úfloatr}   rx   r…   r†   Úobjectrw   rŠ   r„   ry   rv   r�   r�   rn   rž   rŸ   ÚExecutorr%   r   r¢   r£   r�   r   r¨   r   r¬   r¯   Ú__classcell__r   r   r8   r   r(   H   s®   Qþ,þþþ		Lú*þþ	þ
ü%

û
þr(   c                   @   sT   e Zd ZdZg d¢Zeeg df eddœdd„Zd e	dœdd	„Z
d e	dœd
d„ZdS )Ú_Timeoutz2An IOLoop timeout, a UNIX timestamp and a callback)r~   r   Ú	tdeadlineN)r~   r   Úio_loopr   c                 C   s8   t |tjƒstd| ƒ‚|| _|| _|t|jƒf| _d S )Nr�   )	r0   r‚   rƒ   rˆ   r~   r   ÚnextZ_timeout_counterrÀ   )r   r~   r   rÁ   r   r   r   Ú__init__-  s    þz_Timeout.__init__)Úotherr   c                 C   s   | j |j k S r   ©rÀ   ©r   rÄ   r   r   r   Ú__lt__=  s    z_Timeout.__lt__c                 C   s   | j |j kS r   rÅ   rÆ   r   r   r   Ú__le__@  s    z_Timeout.__le__)r!   r"   r#   r°   Ú	__slots__r»   r   r(   rÃ   rº   rÇ   rÈ   r   r   r   r   r¿   '  s   þr¿   c                   @   s’   e Zd ZdZdeg ee f eej	e
f e
ddœdd„Zddœdd	„Zddœd
d„Zedœdd„Zddœdd„Zddœdd„Ze
ddœdd„ZdS )ÚPeriodicCallbacka�  Schedules the given callback to be called periodically.

    The callback is called every ``callback_time`` milliseconds when
    ``callback_time`` is a float. Note that the timeout is given in
    milliseconds, while most other time-related functions in Tornado use
    seconds. ``callback_time`` may alternatively be given as a
    `datetime.timedelta` object.

    If ``jitter`` is specified, each callback time will be randomly selected
    within a window of ``jitter * callback_time`` milliseconds.
    Jitter can be used to reduce alignment of events with similar periods.
    A jitter of 0.1 means allowing a 10% variation in callback time.
    The window is centered on ``callback_time`` so the total number of calls
    within a given interval should not be significantly affected by adding
    jitter.

    If the callback runs for longer than ``callback_time`` milliseconds,
    subsequent invocations will be skipped to get back on schedule.

    `start` must be called after the `PeriodicCallback` is created.

    .. versionchanged:: 5.0
       The ``io_loop`` argument (deprecated since version 4.1) has been removed.

    .. versionchanged:: 5.1
       The ``jitter`` argument is added.

    .. versionchanged:: 6.2
       If the ``callback`` argument is a coroutine, and a callback runs for
       longer than ``callback_time``, subsequent invocations will be skipped.
       Previously this was only true for regular functions, not coroutines,
       which were "fire-and-forget" for `PeriodicCallback`.

       The ``callback_time`` argument now accepts `datetime.timedelta` objects,
       in addition to the previous numeric milliseconds.
    r   N)r   Úcallback_timeÚjitterr   c                 C   sR   || _ t|tjƒr&|tjdd� | _n|dkr6tdƒ‚|| _|| _d| _d | _d S )Nr)   )Zmillisecondsr   z4Periodic callback must have a positive callback_timeF)	r   r0   r…   r†   rË   Ú
ValueErrorrÌ   Ú_runningÚ_timeout)r   r   rË   rÌ   r   r   r   rÃ   j  s    zPeriodicCallback.__init__r   c                 C   s(   t  ¡ | _d| _| j ¡ | _|  ¡  dS )zStarts the timer.TN)r(   r:   rÁ   rÎ   rx   Ú_next_timeoutÚ_schedule_nextr   r   r   r   rb   {  s    
zPeriodicCallback.startc                 C   s(   d| _ | jdur$| j | j¡ d| _dS )zStops the timer.FN)rÎ   rÏ   rÁ   ry   r   r   r   r   rc   …  s    
zPeriodicCallback.stopc                 C   s   | j S )zfReturns ``True`` if this `.PeriodicCallback` has been started.

        .. versionadded:: 4.1
        )rÎ   r   r   r   r   Ú
is_runningŒ  s    zPeriodicCallback.is_runningc                 Ã   sr   | j s
d S zXz&|  ¡ }|d ur0t|ƒr0|I d H  W n$ tyV   tjd| jdd� Y n0 W |  ¡  n
|  ¡  0 d S )Nr¥   Tr¦   )rÎ   r   r   rj   r   rª   rÑ   )r   Úvalr   r   r   Ú_run“  s    zPeriodicCallback._runc                 C   s.   | j r*|  | j ¡ ¡ | j | j| j¡| _d S r   )rÎ   Ú_update_nextrÁ   rx   rw   rÐ   rÔ   rÏ   r   r   r   r   rÑ   Ÿ  s    zPeriodicCallback._schedule_next)Úcurrent_timer   c                 C   sn   | j d }| jr*|d| jt ¡ d   9 }| j|kr\|  jt || j | ¡d | 7  _n|  j|7  _d S )Ng     @�@r)   g      à?)rË   rÌ   ÚrandomrÐ   ÚmathÚfloor)r   rÖ   Zcallback_time_secr   r   r   rÕ   ¤  s    

þ
zPeriodicCallback._update_next)r   )r!   r"   r#   r°   r   r   r   r   r…   r†   r»   rÃ   rb   rc   rº   rÒ   rÔ   rÑ   rÕ   r   r   r   r   rÊ   D  s   ) üû
rÊ   )0r°   rB   Úconcurrent.futuresrž   r…   r‘   r‚   r­   rk   rx   rØ   r×   rL   Úinspectr   Ztornado.concurrentr   r   r   r   r   Ztornado.logr   Ztornado.utilr	   r
   r   r¸   r   r   r   r   r   r   r   r   ÚTYPE_CHECKINGr   r   Ztyping_extensionsr   r¼   r   r%   r&   r(   r¿   rÊ   r   r   r   r   Ú<module>   s@   
(     d