3

	��fe��@sH
dZd
dl
Z
d
dlZd
dlZd
dlZd
dlZd
dlZd
dlZd
dl	Z	d
dl
Z
d
dlZd
dlZd
dl
mZmZmZmZmZ
d
dlmZ
d
dlmZmZmZ
d
dlZd
dlmZmZmZmZmZmZm Z m!Z!
ej"r�d
dlm#Z#m$Z$
d
dl%m&Z&
ne'Z&Gd	d
�d
e&�Z(ed�
Z)ede(d
�Z*Gdd�de�Z+Gdd�de'�Z,Gdd�de'�Z-dS)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 for historical reasons.
Applications can use either the `.IOLoop` interface or the underlying
`asyncio` event loop directly (unless compatibility with older
versions of Tornado is desired, in which case `.IOLoop` must be used).

Typical applications will use a single `IOLoop` object, accessed via
`IOLoop.current` class method. The `IOLoop.start` method (or
equivalently, `asyncio.AbstractEventLoop.run_forever`) should usually
be called at the end of the ``main()`` function. Atypical applications
may use more than one `IOLoop`, such as one `IOLoop` per thread, or
per `unittest` case.

�N)�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(eZ
dZed
�
dd�Zdd
�
dd�ZdS)�_Selectable)
�returnc


CsdS)
N�)
�selfrr�/usr/lib64/python3.6/ioloop.py�filenoCs
z_Selectable.filenoNc


CsdS)
Nr)
rrrr�closeFs
z_Selectable.close)�__name__�
__module__�__qualname__�intrrrrrrrBs
r�_T�_S)
Zboundcs�eZ
dZd
ZdZdZdZdZe�Z	e
dedd��f
d	d
��
Ze
dd�
dd
��
Zdd�
dd�Ze
dd�
dd��
Zeje
dd�
dd��
�
Zeje
dheedd�dd��
�
Ze
dieedd�dd��
Zdd�
dd�Ze
dd�
dd��
Zdd�
dd�Ze
eed�
dd��
Ze
eed�
d d!��
Zdjedd"�d#d$�Zdkedd&�d'd(�Zejee eegdfedd)�d*d+��
Z!eje"e e"egdfedd)�d,d+��
Z!e#ee$fe dledd)�d.d+�Z!e#ee$fedd/�d0d1�Z%e#ee$fdd2�d3d4�Z&dd�
d5d6�Z'dd�
d7d8�Z(dd�
d9d:�Z)dme e*ed;�d<d=�Z+e*d�
d>d?�Z,e#e*e-j.fe dneee/d@�dAdB�Z0e*e doeee/dC�dDdE�Z1e*e dpeee/dF�dGdH�Z2e/ddI�dJdK�Z3e eeddL�dMdN�Z4e eeddL�dOdP�Z5e eeddL�dQdR�Z6dSe dTg
dfddU�dVdW�Z7ee8j9j:e d-e;fee<e;dX�dYdZ�Z=e8j9j:dd[�d\d]�Z>e gefdd^�d_d`�Z?e@dda�dbdc�ZAe#ee$feBee#ee$ffd2�ddde�ZCe#ee$fdd2�dfdg�ZD�ZES)q�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 errno
        import functools
        import socket

        import tornado.ioloop
        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 socket.error as e:
                    if e.args[0] not in (errno.EWOULDBLOCK, errno.EAGAIN):
                        raise
                    return
                connection.setblocking(0)
                io_loop = tornado.ioloop.IOLoop.current()
                io_loop.spawn_callback(handle_connection, connection, address)

        if __name__ == '__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)
            io_loop.start()

    .. testoutput::
       :hide:

    By default, a newly-constructed `IOLoop` becomes the thread's current
    `IOLoop`, unless there already is a current `IOLoop`. This behavior
    can be controlled with the ``make_current`` argument to the `IOLoop`
    constructor: if ``make_current=True``, the new `IOLoop` will always
    try to become current and it raises an error if there is already a
    current instance. If ``make_current=False``, the new `IOLoop` will
    not try to become current.

    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 in ``main()``.

    .. 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.

    r
�
��z$Union[None, str, Type[Configurable]]N)�impl�kwargsrcs\tdk	rDd
dl
m}
t|
t�r&t|
�
}
t|
t�rDt|
|�rDtd�
�
t	t
|�j|
f
|�

dS)Nr
)
�BaseAsyncIOLoopz5only AsyncIOLoop is allowed when asyncio is available)�asyncio�tornado.platform.asyncior)�
isinstance�strr
�type�
issubclass�RuntimeError�superr#�	configure)�clsr'r(r))
�	__class__rrr2�s





zIOLoop.configure)
rc
Cstj
�S)
aKDeprecated 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#�currentrrrr�instance�szIOLoop.instancec


Cs|j�
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_current)
rrrr�install�szIOLoop.installc
Cstj
�
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_currentrrrr�clear_instance�szIOLoop.clear_instancec
CsdS)
Nrrrrrr5�szIOLoop.currentT)r6rc


CsdS)
Nr)
r6rrrr5�sc
Cstytj
�}
Wn"ttfk
r.


|s(d
S�YnXy
tj|
Stk
rn


|rfddlm}
|dd�
}nd
}YnX|S)a�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.
        Nr
)
�AsyncIOMainLoopT)
r7)	r*Zget_event_loopr0�AssertionErrorr#�_ioloop_for_asyncio�KeyErrorr+r;)r6Zloopr;r5rrrr5�s












c


Cs
t��
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.
        N)
�NotImplementedError)
rrrrr7
szIOLoop.make_currentc
Cs0tj
d
d�
}|dk	r|j�
tdkr,dtj_dS)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.
        F)
r6N)r#r5�_clear_current_hookr*Z_currentr6)
�oldrrrr9,
s
	



zIOLoop.clear_currentc


Csd
S)z�Instance method called when an IOLoop ceases to be current.

        May be overridden by subclasses as a counterpart to make_current.
        Nr)
rrrrr@;
szIOLoop._clear_current_hookc


CstS)
N)
r#)
r3rrr�configurable_baseB
szIOLoop.configurable_basec
Csd
dlm
}

|
S)Nr
)
�AsyncIOLoop)r+rC)r3rCrrr�configurable_defaultF
szIOLoop.configurable_default)r7rcCsV|
dkr"tj
d
d�
dkrR|j�
n0|
rRtj
d
d�
}|dk	rJ||k	rJtd�
�
|j�
dS)NF)
r6zcurrent IOLoop already exists)r#r5r7r0)rr7r5rrr�
initializeL
s







zIOLoop.initializeF)�all_fdsrc
Cs
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.
        N)
r?)rrFrrrrW
szIOLoop.close)�fd�handler�eventsrc
CsdS)
Nr)rrGrHrIrrr�add_handlerr
szIOLoop.add_handlerc
CsdS)
Nr)rrGrHrIrrrrJx
s.c
Cs
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.
        N)
r?)rrGrHrIrrrrJ~
s)rGrIrc
Cs
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.
        N)
r?)rrGrIrrr�update_handler�
szIOLoop.update_handler)rGrc
Cs
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.
        N)
r?)rrGrrr�remove_handler�
szIOLoop.remove_handlerc


Cs
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.
        N)
r?)
rrrr�start�
szIOLoop.startc

Cs0tt
j�jt
jd
�
jt
jd�
jg�
s,t
j�
dS)a�
The IOLoop catches and logs exceptions, so it's
        important that log output be visible.  However, python's
        default behavior for non-root loggers (prior to python
        3.2) is to print an unhelpful "no handlers could be
        found" message rather than the actual log entry, so we
        must explicitly configure logging if we've made it this
        far without anything.

        This method should be called from start() in subclasses.
        �tornadoztornado.applicationN)�any�loggingZ	getLoggerZhandlersZbasicConfig)
rrrr�_setup_logging�
s



zIOLoop._setup_loggingc


Cs
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.
        N)
r?)
rrrr�stop�
szIOLoop.stop)�func�timeoutrcs�d
g
�
d
d�
��
�fdd�}�j|�

|d
k	rVd
d�
�
�fdd�}�j
�j�||�}�j�
|d
k	rp�j|�

�
dd
k	s�t�
�
dj�s��
dj�r�td|�
�
�
dj	�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 `tornado.util.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.

        N)
rc
s�y&��}|dk	r$d
dlm
}

|
|�
}Wn0tk
rV


t�}|�
d
<t|tj��
Yn,Xt|�
rj|�
d
<nt�}|�
d
<|j|�

�
d
dk	s�t	�
�j
�
d
�f
dd��
dS)Nr
)
�convert_yieldedc


s�j�S)
N)
rR)
�future)
rrr�<lambda>�
sz.IOLoop.run_sync.<locals>.run.<locals>.<lambda>)Ztornado.genrU�	Exceptionrr�sys�exc_inforZ
set_resultr<�
add_future)�resultrUZfut)rS�future_cellrrr�run�
s 














zIOLoop.run_sync.<locals>.runcs(�d
dk	st�
�d
j
�s$�
j�
dS)Nr
)r<ZcancelrRr)r]rrr�timeout_callbacks

z)IOLoop.run_sync.<locals>.timeout_callbackr
z$Operation timed out after %s seconds)
�add_callback�add_timeout�timerM�remove_timeoutr<Z	cancelled�doner	r\)rrSrTr^r_Ztimeout_handler)rSr]rr�run_sync�
s

	







zIOLoop.run_syncc


Cstj�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`.

        )
rb)
rrrrrbszIOLoop.time)�deadline�callback�argsr(rcOs\t|
t
j�r |j|
|f|�|�
St|
tj�rL|j|j�|
j�|f|�|�
Std
|
�
�
dS)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.
        zUnsupported deadline %rN)	r,�numbers�Real�call_at�datetime�	timedeltarbZ
total_seconds�	TypeError)rrfrgrhr(rrrra$s 



zIOLoop.add_timeout)�delayrgrhr(rcOs|j|j
�|
|f|�|�
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
        )rkrb)rrorgrhr(rrr�
call_laterMs
zIOLoop.call_later)�whenrgrhr(rcOs|j|
|f|�|�
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
        )
ra)rrqrgrhr(rrrrk\szIOLoop.call_at)rTrc
Cs
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.
        N)
r?)rrTrrrrcnszIOLoop.remove_timeout)rgrhr(rc
Os
t��
d
S)a3Calls 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`.
        N)
r?)rrgrhr(rrrr`ws
zIOLoop.add_callbackc
Os
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.
        N)
r?)rrgrhr(rrr�add_callback_from_signal�szIOLoop.add_callback_from_signalcOs|j|
f
|�|�

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`)rrgrhr(rrr�spawn_callback�szIOLoop.spawn_callbackz0Union[Future[_T], concurrent.futures.Future[_T]]z
Future[_T])rVrgrcsHt�
t
�r"�
j��
�fd
d��

n"t�
�
s.t�
t�
��
�fdd��
dS)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�jt
j��
��
S)
N)�
_run_callback�	functools�partial)
�
f)rgrVrrrrW�sz#IOLoop.add_future.<locals>.<lambda>c

s�j��
�S)
N)
r`)
rw)rgrVrrrrW�sN)r,rZadd_done_callbackrr<r)rrVrgr)rgrVrrr[�s
	

zIOLoop.add_future)�executorrSrhrcsh|
d
kr:t|d�s4ddl
m}
tjj|�dd�
|_|j}
|
j|f
|��}t��|j	|�f
dd��
�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)
N)
r)
rw)
�t_futurerrrW�sz(IOLoop.run_in_executor.<locals>.<lambda>)
�hasattrZtornado.processrz�
concurrent�futuresZThreadPoolExecutorryZsubmitrr[)rrxrSrhrzZc_futurer)
r}r�run_in_executor�s







zIOLoop.run_in_executor)rxrcCs
|
|_d
S)zfSets the default executor to use with :meth:`run_in_executor`.

        .. versionadded:: 5.0
        N)
ry)rrxrrr�set_default_executor�szIOLoop.set_default_executor)rgrcCs�yR|
�}|d
k	rPddlm
}
y|j|�
}Wn|jk
r@


YnX|j||j�
Wn8tjk
rh


Yn$tk
r�


t	j
d|
dd�
YnXd
S)z�Runs a callback with error handling.

        .. versionchanged:: 6.0

           CancelledErrors are no longer logged.
        Nr
)
�genzException in callback %rT)
rZ)rNr�rUZ
BadYieldErrorr[�_discard_future_resultr*ZCancelledErrorrXr�error)rrg�retr�rrrrt�s








zIOLoop._run_callback)rVrc
Cs|
j�
d
S)z;Avoid unhandled-exception warnings from spawned coroutines.N)
r\)rrVrrrr��szIOLoop._discard_future_resultcCst|
t
�r|
|
fS|
j�|
fS)
N)r,r r)rrGrrr�split_fd
s


zIOLoop.split_fdcCs<y"t|
t
�rtj|
�

n|
j�
Wntk
r6


YnXdS)
N)r,r �osr�OSError)rrGrrr�close_fds




zIOLoop.close_fd)
T)
T)
N)
F).N)
N).N).N).N)Frrr�__doc__ZNONEZREADZWRITEZERROR�dictr=�classmethodrr2�staticmethodr6r8r:�typingZoverloadr5�boolrr7r9r@r
rrBrDrErr rrJr"rrrKrLrMrQrR�floatrerbrlrm�objectrarprkrcr`rrrsr[rr�ZExecutorr!rr�r�rtrr�rr�r��
__classcell__rr)
r4rr#Ns�M










%





		
J



$

	


!






r#c@sVeZ
dZd
ZdddgZeegdfedd�dd�Zde	d	�d
d�Z
de	d	�dd
�ZdS)�_Timeoutz2An IOLoop timeout, a UNIX timestamp and a callbackrfrg�	tdeadlineN)rfrg�io_looprcCs8t|
t
j�std
|
�
�
|
|_||_|
t|j�
f|_dS)NzUnsupported deadline %r)	r,rirjrnrfrg�nextZ_timeout_counterr�)rrfrgr�rrr�__init__2s



z_Timeout.__init__)�otherrcCs|j|
jkS)
N)
r�)rr�rrr�__lt__Bs
z_Timeout.__lt__cCs|j|
jk
S)
N)
r�)rr�rrr�__le__Es
z_Timeout.__le__)rrrr��	__slots__r�rr#r�r�r�r�rrrrr�,s


r�c@s�eZ
dZd
Zdegdfeedd�dd�Zdd�
dd	�Zdd�
d
d�Ze	d�
dd
�Z
dd�
dd�Zdd�
dd�Zedd�dd�Z
dS)�PeriodicCallbacka?Schedules the given callback to be called periodically.

    The callback is called every ``callback_time`` milliseconds.
    Note that the timeout is given in milliseconds, while most other
    time-related functions in Tornado use seconds.

    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.
    r
N)rg�
callback_time�jitterrcCs2|
|_|d
k
rt
d�
�
||_||_d|_d|_dS)Nr
z4Periodic callback must have a positive callback_timeF)rg�
ValueErrorr�r��_running�_timeout)rrgr�r�rrrr�ds





zPeriodicCallback.__init__)
rc

Cs(tj
�|_d
|_|jj�|_|j�
dS)zStarts the timer.TN)r#r5r�r�rb�
_next_timeout�_schedule_next)
rrrrrMos



zPeriodicCallback.startc

Cs(d
|_|j
dk	r$|jj|j
�

d|_
dS)zStops the timer.FN)r�r�r�rc)
rrrrrRys



zPeriodicCallback.stopc


Cs|jS)
zfReturns ``True`` if this `.PeriodicCallback` has been started.

        .. versionadded:: 4.1
        )
r�)
rrrr�
is_running�szPeriodicCallback.is_runningc

CsN|js
dSz4y|j
�Stk
r:


tjd
|j
dd�
YnXWd|j�
XdS)NzException in callback %rT)
rZ)r�rgrXrr�r�)
rrrr�_run�s





zPeriodicCallback._runc

Cs.|jr*|j
|jj��

|jj|j|j�|_dS)
N)r��_update_nextr�rbrar�r�r�)
rrrrr��s


zPeriodicCallback._schedule_next)�current_timercCsn|jd
}|j
r*|d|j
tj�d9}|j|
k
r\|jtj|
|j|�
d|7_n|j|7_dS)Ng@�@r$g�?)r�r��randomr��mathZfloor)rr�Zcallback_time_secrrrr��s






zPeriodicCallback._update_next)
r
)rrrr�rr�r�rMrRr�r�r�r�r�rrrrr�Is
	

r�).r�r*�concurrent.futuresrrlrurPrir�rYrbr�r�Ztornado.concurrentrrrrrZtornado.logrZtornado.utilrr	r
r�rrr
rrrrrZ
TYPE_CHECKINGrrZtyping_extensionsrr�rr!r"r#r�r�rrrr�<module>s>











(

c