o
    ~îj-’  ã                   @   sX  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&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ƒZ0G dd„ dƒZ1d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ÚSetÚ	TypedDict)ÚProtocolc                   @   s$   e Zd Zdefdd„Zddd„ZdS )Ú_SelectableÚreturnc                 C   ó   d S ©N© ©Úselfr   r   úX/raid/bulk_storage/M2HATS/real-image-venv/lib/python3.10/site-packages/tornado/ioloop.pyÚfileno=   ó   z_Selectable.filenoNc                 C   r   r   r   r   r   r   r    Úclose@   r"   z_Selectable.close©r   N)Ú__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
ƒ Zeddded	d
f‡ fdd„ƒZedodd„ƒZdpdd„Zedpdd„ƒZejedodd„ƒƒZejedqded	ed  fdd„ƒƒZedqded	ed  fdd„ƒZdpdd„Zdpdd„Zedpdd„ƒZedpdd „ƒZdpd!d"„Zed	ee fd#d$„ƒZed	ee fd%d&„ƒZ dqd'ed	d
fd(d)„Z!drd+ed	d
fd,d-„Z"ejd.e#d/e$e#e#gd
f d0e#d	d
fd1d2„ƒZ%ejd.e&d/e$e&e#gd
f d0e#d	d
fd3d2„ƒZ%d.e'e#e(f d/e$d4 d0e#d	d
fd5d2„Z%d.e'e#e(f d0e#d	d
fd6d7„Z)d.e'e#e(f d	d
fd8d9„Z*dpd:d;„Z+dpd<d=„Z,dsd>e$d?ee- d	efd@dA„Z.d	e-fdBdC„Z/dDe'e-e0j1f dEe$dFeded	e2f
dGdH„Z3dIe-dEe$dFeded	e2f
dJdK„Z4dLe-dEe$dFeded	e2f
dMdN„Z5d?e2d	d
fdOdP„Z6dEe$dFeded	d
fdQdR„Z7dEe$dFeded	d
fdSdT„Z8dEe$dFeded	d
fdUdV„Z9dWdXdEe$dYgd
f d	d
fdZd[„Z:d\ee;j<j= d>e$d]e>f dFed	dYfd^d_„Z?d\e;j<j=d	d
fd`da„Z@dEe$g ef d	d
fdbdc„ZAdWeBd	d
fddde„ZCd.e'e#e(f d	eDe#e'e#e(f f fdfdg„ZEd.e'e#e(f d	d
fdhdi„ZFdjeBd	d
fdkdl„ZGdjeBd	d
fdmdn„ZH‡  ZIS )tÚ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())

    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   é   é   é   Úimplz$Union[None, str, Type[Configurable]]Úkwargsr   Nc                    sR   ddl m} t|tƒrt|ƒ}t|tƒrt||ƒstdƒ‚tƒ j	|fi |¤Ž d S )Nr   )ÚBaseAsyncIOLoopz5only AsyncIOLoop is allowed when asyncio is available)
Útornado.platform.asyncior2   Ú
isinstanceÚstrr   ÚtypeÚ
issubclassÚRuntimeErrorÚsuperÚ	configure)Úclsr0   r1   r2   ©Ú	__class__r   r    r:   «   s   
zIOLoop.configurec                   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   r   r   r   r   r   r   r    r>   ë   ó   zIOLoop.currentTr?   c                 C   r   r   r   ©r?   r   r   r    r>   ð   rD   c                 C   s~   zt  ¡ }W n ty   | sY dS t  ¡ }t  |¡ Y nw ztj| W S  ty>   | r9ddlm	} |ƒ }Y |S d}Y |S w )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_loopr8   Únew_event_loopÚset_event_loopr,   Ú_ioloop_for_asyncioÚKeyErrorr3   rF   )r?   ÚlooprF   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   ó   t ƒ ‚r   ©ÚNotImplementedErrorr   r   r   r    rT   =  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 deprecatedrN   rO   N)rQ   rR   rS   r,   Ú_clear_currentr   r   r   r    rB   A  s   
ýzIOLoop.clear_currentc                  C   s$   t jdd�} | d ur|  ¡  d S d S )NFrE   )r,   r>   Ú_clear_current_hook)Úoldr   r   r    rX   R  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    rY   X  s   zIOLoop._clear_current_hookc                 C   s   t S r   )r,   )r;   r   r   r    Úconfigurable_base_  s   zIOLoop.configurable_basec                 C   s   ddl m} |S )Nr   )ÚAsyncIOLoop)r3   r\   )r;   r\   r   r   r    Úconfigurable_defaultc  s   zIOLoop.configurable_defaultr@   c                 C   s   |r|   ¡  d S d S r   )rT   )r   r@   r   r   r    Ú
initializei  s   ÿzIOLoop.initializeFÚall_fdsc                 C   rU   )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.
        rV   )r   r_   r   r   r    r#   m  s   zIOLoop.closeÚfdÚhandlerÚeventsc                 C   r   r   r   ©r   r`   ra   rb   r   r   r    Úadd_handlerˆ  ó   zIOLoop.add_handlerc                 C   r   r   r   rc   r   r   r    rd   Ž  re   ).Nc                 C   rU   )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.
        rV   rc   r   r   r    rd   ”  s   c                 C   rU   )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.
        rV   )r   r`   rb   r   r   r    Úupdate_handler§  ó   zIOLoop.update_handlerc                 C   rU   )zµStop listening for events on ``fd``.

        .. versionchanged:: 4.0
           Added the ability to pass file-like objects in addition to
           raw file descriptors.
        rV   ©r   r`   r   r   r    Úremove_handler°  rg   zIOLoop.remove_handlerc                 C   rU   )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.
        rV   r   r   r   r    Ústart¹  s   zIOLoop.startc                 C   rU   )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.
        rV   r   r   r   r    ÚstopÁ  s   zIOLoop.stopÚfuncÚtimeoutc                    sÖ   t jrtdtt tdœƒ}dddœ‰d‡ ‡‡fdd„}ˆ |¡ |dur6d‡‡fdd	„}ˆ ˆ ¡ | |¡}ˆ 	¡  |durCˆ 
|¡ ˆd
 dusKJ ‚ˆd
  ¡ sWˆd
  ¡ seˆd ratd| ƒ‚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``.
        Ú
FutureCell)ÚfutureÚtimeout_calledNFr   c                     s¬   zˆ ƒ } | d urddl m} || ƒ} W n ty*   tƒ }|ˆd< t|t ¡ ƒ Y nw t| ƒr4| ˆd< ntƒ }|ˆd< | | ¡ ˆd d usHJ ‚ˆ 	ˆd ‡fdd„¡ d S )Nr   )Úconvert_yieldedro   c                    s   ˆ   ¡ S r   )rk   )ro   r   r   r    Ú<lambda>  s    z.IOLoop.run_sync.<locals>.run.<locals>.<lambda>)
Útornado.genrq   Ú	Exceptionr   r   ÚsysÚexc_infor   Ú
set_resultÚ
add_future)Úresultrq   Úfut©rl   Úfuture_cellr   r   r    Úrunô  s$   €ý

zIOLoop.run_sync.<locals>.runc                      s4   dˆ d< ˆ d d usJ ‚ˆ d   ¡ sˆ ¡  d S d S )NTrp   ro   )Úcancelrk   r   )r|   r   r   r    Útimeout_callback  s
   ÿz)IOLoop.run_sync.<locals>.timeout_callbackro   rp   z$Operation timed out after %s secondsz+Event loop stopped before Future completed.r$   )ÚtypingÚTYPE_CHECKINGr   r   r   ÚboolÚadd_callbackÚadd_timeoutÚtimerj   Úremove_timeoutÚ	cancelledÚdoner
   r8   ry   )r   rl   rm   rn   r}   r   Útimeout_handler   r{   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`.

        )r…   r   r   r   r    r…   %  s   zIOLoop.timeÚdeadlineÚcallbackÚargsc                 O   sd   t |tjƒr| j||g|¢R i |¤ŽS t |tjƒr,| j|  ¡ | ¡  |g|¢R i |¤ŽS td| ƒ‚)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 %r)	r4   ÚnumbersÚRealÚcall_atÚdatetimeÚ	timedeltar…   Útotal_secondsÚ	TypeError)r   r‹   rŒ   r�   r1   r   r   r    r„   3  s    ÿÿÿzIOLoop.add_timeoutÚdelayc                 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‘   r…   )r   r–   rŒ   r�   r1   r   r   r    Ú
call_later\  s   "zIOLoop.call_laterÚwhenc                 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
        )r„   )r   r˜   rŒ   r�   r1   r   r   r    r‘   k  s   zIOLoop.call_atc                 C   rU   )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.
        rV   )r   rm   r   r   r    r†   }  rg   zIOLoop.remove_timeoutc                 O   rU   )aÙ  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.
        rV   ©r   rŒ   r�   r1   r   r   r    rƒ   †  s   
zIOLoop.add_callbackc                 O   rU   )aˆ  Calls the given callback on the next I/O loop iteration.

        Intended to be afe for use from a Python signal handler; should not be
        used otherwise.

        .. deprecated:: 6.4
           Use ``asyncio.AbstractEventLoop.add_signal_handler`` instead.
           This method is suspected to have been broken since Tornado 5.0 and
           will be removed in version 7.0.
        rV   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©rƒ   r™   r   r   r    Úspawn_callback¡  s   zIOLoop.spawn_callbackro   z0Union[Future[_T], concurrent.futures.Future[_T]]z
Future[_T]c                    sF   t |tƒr| ‡ ‡fdd„¡ dS 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Œ   r   r   r    rr   Ã  s    z#IOLoop.add_future.<locals>.<lambda>c                    s   ˆ  ˆ | ¡S r   r›   r    r¢   r   r    rr   É  s    N)r4   r   Úadd_done_callbackr   r   )r   ro   rŒ   r   r¢   r    rx   ª  s   
	ÿzIOLoop.add_futureÚexecutor.c                    sj   |du rt | dƒsd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    ©Út_futurer   r    rr   ä  s   
 z(IOLoop.run_in_executor.<locals>.<lambda>)
ÚhasattrÚtornado.processr¦   Ú
concurrentÚfuturesÚThreadPoolExecutorr¥   Úsubmitr   rx   )r   r¤   rl   r�   r¦   Úc_futurer   r©   r    Úrun_in_executorË  s   
ÿzIOLoop.run_in_executorc                 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_executorc                 C   s–   z.|ƒ }|dur,ddl m} z| |¡}W n |jy!   Y W dS w |  || j¡ W dS W dS  tjy9   Y dS  tyJ   t	j
d|dd� Y dS w )z€Runs a callback with error handling.

        .. versionchanged:: 6.0

           CancelledErrors are no longer logged.
        Nr   )ÚgenúException in callback %rT©rv   )Útornador´   rq   ÚBadYieldErrorrx   Ú_discard_future_resultrG   ÚCancelledErrorrt   r   Úerror)r   rŒ   Úretr´   r   r   r    r�   î  s    üñÿzIOLoop._run_callbackc                 C   s   |  ¡  dS )z;Avoid unhandled-exception warnings from spawned coroutines.N)ry   )r   ro   r   r   r    r¹     s   zIOLoop._discard_future_resultc                 C   s   t |tƒr	||fS | ¡ |fS r   )r4   r(   r!   rh   r   r   r    Úsplit_fd  s   
zIOLoop.split_fdc                 C   s>   zt |tƒrt |¡ W d S | ¡  W d S  ty   Y d S w r   )r4   r(   Úosr#   ÚOSErrorrh   r   r   r    Úclose_fd&  s   
ÿzIOLoop.close_fdr¡   c                 C   ó   | j  |¡ d S r   )Ú_pending_tasksÚadd©r   r¡   r   r   r    Ú_register_task:  ó   zIOLoop._register_taskc                 C   rÁ   r   )rÂ   ÚdiscardrÄ   r   r   r    Ú_unregister_task=  rÆ   zIOLoop._unregister_task)r   r,   r$   )T)Fr   )Jr%   r&   r'   Ú__doc__ÚNONEÚREADÚWRITEÚERRORÚdictrK   ÚsetrÂ   Úclassmethodr   r:   Ústaticmethodr?   rA   rC   r€   Úoverloadr>   r‚   r   r@   rT   rB   rX   rY   r   r	   r[   r]   r^   r#   r(   r   rd   r*   r   r   rf   ri   rj   rk   ÚfloatrŠ   r…   r’   r“   Úobjectr„   r—   r‘   r†   rƒ   rš   rœ   rx   r­   r®   ÚExecutorr)   r²   r³   r�   r   r¹   r   r½   rÀ   rÅ   rÈ   Ú__classcell__r   r   r<   r    r,   H   s*   Nÿÿþ

,

ÿÿÿþÿÿÿþ
ÿÿÿ
þ	
	
Wþýüû
ú)ÿÿÿÿ
þÿÿÿÿ
þ	ÿÿÿ
þ	þý
ü!
þ
ýü
û
ÿ
þr,   c                   @   s^   e Zd ZdZg d¢Zdedeg df deddfdd	„Zd
d de	fdd„Z
d
d de	fdd„ZdS )Ú_Timeoutz2An IOLoop timeout, a UNIX timestamp and a callback)r‹   rŒ   Ú	tdeadliner‹   rŒ   NÚio_loopr   c                 C   s8   t |tjƒstd| ƒ‚|| _|| _|t|jƒf| _d S )NrŽ   )	r4   r�   r�   r•   r‹   rŒ   ÚnextÚ_timeout_counterrØ   )r   r‹   rŒ   rÙ   r   r   r    Ú__init__G  s   
þz_Timeout.__init__Úotherc                 C   s   | j |j k S r   ©rØ   ©r   rÝ   r   r   r    Ú__lt__W  ó   z_Timeout.__lt__c                 C   s   | j |j kS r   rÞ   rß   r   r   r    Ú__le__Z  rá   z_Timeout.__le__)r%   r&   r'   rÉ   Ú	__slots__rÓ   r   r,   rÜ   r‚   rà   râ   r   r   r   r    r×   A  s    ÿ
ÿÿ
þr×   c                	   @   sŒ   e Zd ZdZ	ddeg ee f deej	e
f de
ddfdd	„Zdd
d„Zddd„Zdefdd„Zddd„Zddd„Zde
ddf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   rŒ   Úcallback_timeÚjitterr   Nc                 C   sR   || _ t|tjƒr|tjdd� | _n|dkrtdƒ‚|| _|| _d| _d | _d S )Nr-   )Úmillisecondsr   z4Periodic callback must have a positive callback_timeF)	rŒ   r4   r’   r“   rå   Ú
ValueErrorræ   Ú_runningÚ_timeout)r   rŒ   rå   ræ   r   r   r    rÜ   „  s   
zPeriodicCallback.__init__c                 C   s(   t  ¡ | _d| _| j ¡ | _|  ¡  dS )zStarts the timer.TN)r,   r>   rÙ   ré   r…   Ú_next_timeoutÚ_schedule_nextr   r   r   r    rj   •  s   
zPeriodicCallback.startc                 C   s,   d| _ | jdur| j | j¡ d| _dS dS )zStops the timer.FN)ré   rê   rÙ   r†   r   r   r   r    rk   Ÿ  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                 Ã   s€   �| j sd S z4z|  ¡ }|d urt|ƒr|I d H  W n ty,   tjd| jdd� Y nw W |  ¡  d S W |  ¡  d S |  ¡  w )Nrµ   Tr¶   )ré   rŒ   r   rt   r   r»   rì   )r   Úvalr   r   r    Ú_run­  s   €
€ÿ€þzPeriodicCallback._runc                 C   s2   | j r|  | j ¡ ¡ | j | j| j¡| _d S d S r   )ré   Ú_update_nextrÙ   r…   r„   rë   rï   rê   r   r   r   r    rì   ¹  s   þzPeriodicCallback._schedule_nextÚcurrent_timec                 C   sp   | j d }| jr|d| jt ¡ d   9 }| j|kr/|  jt || j | ¡d | 7  _d S |  j|7  _d S )Ng     @�@r-   g      à?)rå   ræ   Úrandomrë   ÚmathÚfloor)r   rñ   Úcallback_time_secr   r   r    rð   ¾  s   

þzPeriodicCallback._update_next)r   r$   )r%   r&   r'   rÉ   r   r   r   r   r’   r“   rÓ   rÜ   rj   rk   r‚   rí   rï   rì   rð   r   r   r   r    rä   ^  s$    )üþýü
û




rä   )2rÉ   rG   Úconcurrent.futuresr­   r’   rž   r�   r¾   ru   r…   ró   rò   rQ   Úinspectr   Útornado.concurrentr   r   r   r   r   Útornado.logr   Útornado.utilr	   r
   r   r€   r   r   r   r   r   r   r   r   r�   r   r   r   r   Útyping_extensionsr   rÔ   r   r)   r*   r,   r×   rä   r   r   r   r    Ú<module>   sB   
(     ~