File manager - Edit - /opt/saltstack/salt/lib/python3.10/site-packages/tornado/__pycache__/ioloop.cpython-310.pyc
Back
o ;j-� � @ sX d Z ddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl mZ ddlmZmZmZmZmZ ddlmZ ddlmZmZmZ ddlZddlm Z m Z m Z m Z m Z m!Z!m"Z"m#Z# ej$r�ddlm%Z%m&Z&m'Z'm(Z( dd l)m*Z* ne+Z*G d d � d e*�Z,e!d �Z-e!d e,d�Z.G dd� de�Z/G dd� d�Z0G dd� d�Z1dS )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 Zd Zdefdd�Zddd�ZdS )� _Selectable�returnc C � d S �N� ��selfr r �B/opt/saltstack/salt/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 Zd ZdZdZdZdZdZe� Z e � Z e ddde d d f� fd d � �Zedod d��Zdpdd�Zedpdd��Zejedodd���Zejedqded ed fdd���Zedqded ed fdd��Zdpdd�Zdpdd �Zedpd d ��Zedpd d ��Zdpd!d"�Z e d e e fd#d$��Z e d e e fd%d&��Z dqd'ed d fd(d)�Z!drd+ed d fd,d-�Z"ejd.e#d/e$e#e#gd f d0e#d d fd1d2��Z%ejd.e&d/e$e&e#gd f d0e#d d fd3d2��Z%d.e'e#e(f d/e$d4 d0e#d d fd5d2�Z%d.e'e#e(f d0e#d d fd6d7�Z)d.e'e#e(f d d fd8d9�Z*dpd:d;�Z+dpd<d=�Z,dsd>e$d?ee- d e fd@dA�Z.d e-fdBdC�Z/dDe'e-e0j1f dEe$dFe de d e2f dGdH�Z3dIe-dEe$dFe de d e2f dJdK�Z4dLe-dEe$dFe de d e2f dMdN�Z5d?e2d d fdOdP�Z6dEe$dFe de d d fdQdR�Z7dEe$dFe de d d fdSdT�Z8dEe$dFe de d d fdUdV�Z9dWdXdEe$dYgd f d d fdZd[�Z:d\ee;j<j= d>e$d]e>f dFe d dYfd^d_�Z?d\e;j<j=d d fd`da�Z@dEe$g e f d d fdbdc�ZAdWeBd d fddde�ZCd.e'e#e(f d eDe#e'e#e(f f fdfdg�ZEd.e'e#e(f d d fdhdi�ZFdjeBd d fdkdl�ZGdjeBd d fdmdn�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 ddl m} t|t�rt|�}t|t�r t||�s td��t� j |fi |�� 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 zIOLoop.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 zIOLoop.instancec C s | � � dS )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 zIOLoop.installc C s t �� dS )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 zIOLoop.clear_instancec C r r r r r r r r> � � zIOLoop.currentTr? c C r r r �r? r r r r> � rD c C s~ zt �� }W n ty | sY dS t �� }t �|� Y nw ztj| W S ty> | r9ddlm } |� }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) �asyncioZget_event_loopr8 Znew_event_loopZset_event_loopr, �_ioloop_for_asyncio�KeyErrorr3 rF )r? ZlooprF r> r r r r> � s$ � ��c C s t jdtdd� | �� dS )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 � zIOLoop.make_currentc C � t � �r ��NotImplementedErrorr r r r rP = s zIOLoop._make_currentc C s t jdtdd� t�� 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. .. deprecated:: 6.2 zclear_current is deprecatedrJ rK N)rM rN rO r, �_clear_currentr r r r rB A s � zIOLoop.clear_currentc C s$ t jdd�} | d ur| �� d S d S )NFrE )r, r> �_clear_current_hook)�oldr r r rT R s �zIOLoop._clear_currentc C s dS )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 rU X s zIOLoop._clear_current_hookc C s t S r )r, )r; r r r �configurable_base_ s zIOLoop.configurable_basec C s ddl m} |S )Nr )� AsyncIOLoop)r3 rX )r; rX r r r �configurable_defaultc s zIOLoop.configurable_defaultr@ c C s |r| � � d S d S r )rP )r r@ r r r � initializei s �zIOLoop.initializeF�all_fdsc C rQ )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. rR )r r[ r r r r# m s z IOLoop.close�fd�handler�eventsc C r r r �r r\ r] r^ r r r � add_handler� � zIOLoop.add_handlerc C r r r r_ r r r r` � ra ).Nc C rQ )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. rR r_ r r r r` � s c C rQ )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. rR )r r\ r^ r r r �update_handler� � zIOLoop.update_handlerc C rQ )z�Stop listening for events on ``fd``. .. versionchanged:: 4.0 Added the ability to pass file-like objects in addition to raw file descriptors. rR �r r\ r r r �remove_handler� rc zIOLoop.remove_handlerc C rQ )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. rR r r r r �start� s z IOLoop.startc C rQ )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. rR r r r r �stop� s z IOLoop.stop�func�timeoutc s� t jr tdtt td��}ddd��d� ��fdd� }��|� |dur6d��fdd � }����� | |�}�� � |durC�� |� �d dusKJ ��d � � sW�d � � se�d rat d | ��td ���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 urddl m} || �} W n ty* t� }|�d< t|t�� � Y nw t| �r4| �d< n t� }|�d< |�| � �d d usHJ ��� �d �fdd�� d S )Nr )�convert_yieldedrk c s � � � S r )rg )rk r r r �<lambda> s z.IOLoop.run_sync.<locals>.run.<locals>.<lambda>) Z tornado.genrm � Exceptionr r �sys�exc_infor Z set_result� add_future)�resultrm Zfut�rh � future_cellr r r �run� s$ � � z IOLoop.run_sync.<locals>.runc s4 d� d< � d d us J �� d � � s��� d S d S )NTrl rk )�cancelrg r )ru r r r �timeout_callback s �z)IOLoop.run_sync.<locals>.timeout_callbackrk rl z$Operation timed out after %s secondsz+Event loop stopped before Future completed.r$ )�typing� TYPE_CHECKINGr r r �bool� add_callback� add_timeout�timerf �remove_timeoutZ cancelledZdoner r8 rs )r rh ri rj rv rx Ztimeout_handler rt r �run_sync� s& � zIOLoop.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 |tj�r| j||g|�R i |��S t |tj�r,| j| �� |�� |g|�R i |��S td| ��)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 ��� zIOLoop.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 " zIOLoop.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 zIOLoop.call_atc C rQ )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. rR )r ri r r r r } rc zIOLoop.remove_timeoutc O rQ )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. rR �r r� r� r1 r r r r| � s zIOLoop.add_callbackc O rQ )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. rR r� r r r �add_callback_from_signal� s z IOLoop.add_callback_from_signalc O s | j |g|�R i |�� dS )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 zIOLoop.spawn_callbackrk z0Union[Future[_T], concurrent.futures.Future[_T]]z Future[_T]c sF t |t�r|�� �fdd�� dS t|�sJ �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 �� t�� | ��S r )� _run_callback� functools�partial��f�r� r r r rn � s z#IOLoop.add_future.<locals>.<lambda>c s �� � | �S r r� r� r� r r rn � s N)r4 r Zadd_done_callbackr r )r rk r� r r� r rr � s � zIOLoop.add_future�executor.c sj |du r t | d�sddlm} tjj|� d d�| _| j}|j|g|�R � }t� � | � |� fdd�� � 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� �Zt_futurer r rn � s z(IOLoop.run_in_executor.<locals>.<lambda>) �hasattrZtornado.processr� � concurrent�futuresZThreadPoolExecutorr� Zsubmitr rr )r r� rh r� r� Zc_futurer r� r �run_in_executor� s �zIOLoop.run_in_executorc C s || _ dS )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 zIOLoop.set_default_executorc C s� z.|� }|dur,ddl m} z|�|�}W n |jy! Y W dS w | �|| j� W dS W dS tjy9 Y dS tyJ t j d|dd� Y dS w )z�Runs a callback with error handling. .. versionchanged:: 6.0 CancelledErrors are no longer logged. Nr )�gen�Exception in callback %rT�rq ) Ztornador� rm Z BadYieldErrorrr �_discard_future_resultrG ZCancelledErrorro r �error)r r� �retr� r r r r� � s �� �zIOLoop._run_callbackc C s |� � dS )z;Avoid unhandled-exception warnings from spawned coroutines.N)rs )r rk r r r r� s z IOLoop._discard_future_resultc C s t |t�r ||fS |�� |fS r )r4 r( r! rd r r r �split_fd s zIOLoop.split_fdc C s> zt |t�rt�|� W d S |�� W d S ty Y d S w r )r4 r( �osr# �OSErrorrd r r r �close_fd& s �zIOLoop.close_fdr� c C � | j �|� d S r )�_pending_tasks�add�r r� r r r �_register_task: � zIOLoop._register_taskc C r� r )r� �discardr� r r r �_unregister_task= r� zIOLoop._unregister_task)r r, r$ )T)Fr )Jr% r& r' �__doc__ZNONEZREADZWRITE�ERROR�dictrH �setr� � classmethodr r: � staticmethodr? rA rC ry �overloadr> r{ r r@ rP rB rT rU r r rW rY rZ r# r( r r` r* r r rb re rf rg �floatr� r~ r� r� �objectr} r� r� r r| r� r� rr r� r� ZExecutorr) r� r� r� r r� r r� r� r� r� � __classcell__r r r< r r, H s* N ��� , ��� ���� � ��� � W ���� �)���� ����� � ��� � � � �! � �� � � �r, c @ s^ e Zd ZdZg d�Zdedeg df deddfdd �Zd d de fd d �Z d d de fd d�Z dS )�_Timeoutz2An IOLoop timeout, a UNIX timestamp and a callback)r� r� � tdeadliner� r� N�io_loopr c C s8 t |tj�s td| ��|| _|| _|t|j�f| _d S )Nr� ) r4 r� r� r� r� r� �nextZ_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 kS 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 Zd ZdZ ddeg ee f deej e f de ddfdd �Z dd d �Z dd d �Z defdd�Zddd�Zddd�Zde ddfdd�ZdS )�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|tj�r|tjdd� | _n |dkrtd��|| _|| _d| _d | _d S )Nr- )Z 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 zPeriodicCallback.__init__c C s( t �� | _d| _| j�� | _| �� dS )zStarts the timer.TN)r, r> r� r� r~ � _next_timeout�_schedule_nextr r r r rf � s zPeriodicCallback.startc C s, d| _ | jdur| j�| j� d| _dS dS )zStops the timer.FN)r� r� r� r r r r r rg � s �zPeriodicCallback.stopc C s | j S )zfReturns ``True`` if this `.PeriodicCallback` has been started. .. versionadded:: 4.1 )r� r r r r � is_running� s zPeriodicCallback.is_runningc � s� �| j sd S z4z| �� }|d urt|�r|I d H W n ty, tjd| jdd� Y nw W | �� d S W | �� d S | �� w )Nr� Tr� )r� r� r ro r r� r� )r �valr r r �_run� s � � �� �zPeriodicCallback._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 }| jr|d| jt�� d 9 }| j|kr/| jt�|| j | �d | 7 _d S | j|7 _d S )Ng @�@r- g �?)r� r� �randomr� �math�floor)r r� Zcallback_time_secr r r r� � s �z PeriodicCallback._update_next)r r$ )r% r& r' r� r r r r r� r� r� r� rf rg r{ r� r� r� r� r r r r r� ^ s$ )�� �� � r� )2r� rG �concurrent.futuresr� r� r� r� r� rp r~ r� r� rM �inspectr Ztornado.concurrentr r r r r Z tornado.logr Z tornado.utilr r r ry r r r r r r r r rz r r r r Ztyping_extensionsr r� r r) r* r, r� r� r r r r �<module> sB ( ~
| ver. 1.4 |
Github
|
.
| PHP 8.2.30 | Generation time: 0 |
proxy
|
phpinfo
|
Settings