+ V@i-Rt^RIt^RIt^RIt^RIt^RIt^RIt^RIt^RI t ^RI t ^RI t ^RI t ^RI Ht^RIHtHtHtHtHt^RIHt^RIHtHtHt^RIt^RIHtHtHtHtH t H!t!H"t"H#t#]PH'd^RIH%t%H&t&H't'H(t(^RI)H*t*M]+t*!R R ]*4t,]!!R 4t-]!!R ],R 7t.!RR]4t/!RR4t0!RR4t1R#)aAn 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_futurefuture_set_exc_infofuture_add_done_callback)app_log) Configurable TimeoutError import_object)UnionAnyTypeOptionalCallableTypeVarTuple Awaitable)DictListSet TypedDict)ProtocolcDa]tRt^lR?lt+V3R@lRAlt,V3RBlRClt-V3RDlRElt.V3RFlRGlt/V3RHlRIlt0V3RJlRKlt1V3RLlRMlt2V3RNlROlt3V3RPlRQlt4V3RRlRSlt5RTt6Vt7V;t8#)XIOLoopa 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. c(<V^8dQhRRRS[RR/#)rimplz$Union[None, str, Type[Configurable]]kwargsrN)r )r r!s"r"r#IOLoop.__annotate__s% * *9 *EH *  *r%c <^RIHp\V\4'd \ V4p\V\ 4'd\ W4'g \R4h\SV`$!V3/VBR#))BaseAsyncIOLoopz5only AsyncIOLoop is allowed when asyncio is availableN) tornado.platform.asynciorE isinstancestrr type issubclass RuntimeErrorsuper configure)clsr@rArE __class__s&&, r"rMIOLoop.configuresT = dC  &D dD ! !*T*K*KVW W $)&)r%c<V^8dQhRR/#rrr>r()r r!s"r"r#rBs  h r%c *\P4#)aDeprecated 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"instanceIOLoop.instances(~~r%c<V^8dQhRR/#r/r()r r!s"r"r#rBs   r%c &VP4R#)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)s&r"installIOLoop.installs r%c<V^8dQhRR/#r/r()r r!s"r"r#rBs  D r%c .\P4R#)a3Deprecated 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"clear_instanceIOLoop.clear_instances r%c<V^8dQhRR/#rRr()r r!s"r"r#rBs  X r%cR#r'r(r(r%r"rTIOLoop.current r%c4<V^8dQhRS[RS[R,/#rrUrr>boolr)r r!s"r"r#rBs   $ (8*< r%cR#r'r(rUs&r"rTrcrdr%c4<V^8dQhRS[RS[R,/#rfrg)r r!s"r"r#rBs **$*(8*<*r%c D\P!4p\ P V,# \d:T'gR#\P!4p\P!T4L[i;i \dT'd^RIH pT!4pT#RpT#i;i)aReturns 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. N)AsyncIOMainLoop) asyncioget_event_looprKnew_event_loopset_event_loopr>_ioloop_for_asyncioKeyErrorrFrm)rUlooprmrTs& r"rTrcs2 )))+D --d3 3 )))+D  " "4 (  ) D)+ s2/A6A3+A32A36B BBBc<V^8dQhRR/#r/r()r r!s"r"r#rB"sdr%c `\P!R\^R7VP4R#)aMakes 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)warningswarnDeprecationWarning _make_currentr)s&r"rYIOLoop.make_current"s'(  D  r%c<V^8dQhRR/#r/r()r r!s"r"r#rB=s$$t$r%c\4hr'NotImplementedErrorr)s&r"r|IOLoop._make_current=s !##r%c<V^8dQhRR/#r/r()r r!s"r"r#rBBs  4 r%c h\P!R\^R7\P 4R#)zClears 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 deprecatedrwN)ryrzr{r>_clear_currentr(r%r"r^IOLoop.clear_currentAs'  )  r%c<V^8dQhRR/#r/r()r r!s"r"r#rBSs&&D&r%c^\PRR7pVeVP4R#R#)FrjN)r>rT_clear_current_hook)olds r"rIOLoop._clear_currentRs(nnen, ?  # # % r%c<V^8dQhRR/#r/r()r r!s"r"r#rBXs  T r%c R#)zInstance method called when an IOLoop ceases to be current. May be overridden by subclasses as a counterpart to make_current. Nr(r)s&r"rIOLoop._clear_current_hookXs r%c0<V^8dQhRS[S[,/#rrr )r r!s"r"r#rB`s$|"4r%c\#r')r>)rNs&r"configurable_baseIOLoop.configurable_base_s r%c0<V^8dQhRS[S[,/#rr)r r!s"r"r#rBdsT,%7r%c^RIHpV#)rD) AsyncIOLoop)rFr)rNrs& r"configurable_defaultIOLoop.configurable_defaultcs 8r%c$<V^8dQhRS[RR/#)rrYrNrh)r r!s"r"r#rBis!!t!t!r%c:V'dVP4R#R#r')r|)r*rYs&&r" initializeIOLoop.initializeis      r%c$<V^8dQhRS[RR/#)rall_fdsrNr)r r!s"r"r#rBms$$T$d$r%c \4h)aCloses 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. r)r*rs&&r"r1 IOLoop.closems 2"##r%cJ<V^8dQhRS[RS[S[S[.R3,RS[RR/#rfdhandlerNeventsr)rr)r r!s"r"r#rBs;   (#sT)9 : DG  r%cR#r'r(r*rrrs&&&&r" add_handlerIOLoop.add_handler r%cJ<V^8dQhRS[RS[S[S[.R3,RS[RR/#r)r;rr)r r!s"r"r#rBs:   'S 48 BE  r%cR#r'r(rs&&&&r"rrrr%cT<V^8dQhRS[S[S[3,RS[R,RS[RR/#)rrrNrr).N)r rrr)r r!s"r"r#rBs<$$[()$4.__annotate__s O OT Or%c~<S!4pVe^RIHpV!V4p\V4'dVSR&M!\4pVSR&VP V4SR,fQhSPSR,V3Rl4R# \ d2\4pTSR&\ T\P!44Lgi;i)N)convert_yieldedrc$<SP4#r')r)rr*s&r".IOLoop.run_sync..run..s $))+r%) tornado.genrrr set_result Exceptionrsysexc_info add_future)resultrfutr future_cellr*s r"runIOLoop.run_sync..runs +%;,V4F V$$,2K) (C,/K)NN6*x(4 44 OOK13M N 9h(+ H%#C8 9sB9B<;B<cV^8dQhRR/#r/r()r s"r"r#r s d r%c<RSR&SR,fQhSR,P4'gSP4R#R#)TrrN)cancelr)rr*sr"timeout_callback)IOLoop.run_sync..timeout_callback sC04 ,- #8,888"8,3355IIK6r%z$Operation timed out after %s secondsz+Event loop stopped before Future completed.)typing TYPE_CHECKINGrrrrh add_callback add_timeouttimerremove_timeout cancelleddoner rKr)r*rrrrrtimeout_handlersff& @r"run_syncIOLoop.run_syncs!@    "x&)9;KTRJ '7?  O O* #   "--diikG.CEUVN      /8$000 x * * , ,K4I4N4N4P4P+,,"#IG#STT##PQQ8$++--r%c <V^8dQhRS[/#rr)r r!s"r"r#rB%s  e r%c ,\P!4#)aOReturns 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`. )rr)s&r"r IOLoop.time%syy{r%c b<V^8dQhRS[S[S[P3,RS[RS[RS[RS[/#)rdeadlinecallbackargsrAr)r rdatetime timedeltarr object)r r!s"r"r#rB3sT'B'Bx1112'B'B 'B  'B  'Br%c F\V\P4'dVP!W.VO5/VB#\V\P 4'd;VP!VP 4VP4,V.VO5/VB#\RV,4h)aRuns 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) rGnumbersRealcall_atrrr total_seconds TypeError)r*rrrrAs&&&*,r"rIOLoop.add_timeout3s@ h - -<<DTDVD D ("4"4 5 5<< h4466CGKQ 5@A Ar%c 8<V^8dQhRS[RS[RS[RS[RS[/#)rdelayrrrArrrr r)r r!s"r"r#rB\s< L L L&. L7: LFI L  Lr%c ZVP!VP4V,V.VO5/VB#)aRRuns 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 )rr)r*rrrrAs&&&*,r" call_laterIOLoop.call_later\s*||DIIK%/KDKFKKr%c 8<V^8dQhRS[RS[RS[RS[RS[/#)rwhenrrrArr)r r!s"r"r#rBks<AAA%-A69AEHA Ar%c .VP!W.VO5/VB#)aRuns 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*rrrrAs&&&*,r"rIOLoop.call_atks @@@@r%c$<V^8dQhRS[RR/#)rrrN)r)r r!s"r"r#rB}s$$f$$r%c \4h)zCancels 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. r)r*rs&&r"rIOLoop.remove_timeout}rr%c0<V^8dQhRS[RS[RS[RR/#rrrrArNrr )r r!s"r"r#rBs) $ $X $c $S $T $r%c \4h)aCalls 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*rrrAs&&*,r"rIOLoop.add_callbacks "##r%c0<V^8dQhRS[RS[RS[RR/#rr)r r!s"r"r#rBs- $ $  $), $8; $  $r%c \4h)aPCalls 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. rrs&&*,r"add_callback_from_signalIOLoop.add_callback_from_signals "##r%c0<V^8dQhRS[RS[RS[RR/#rr)r r!s"r"r#rBs)55x55s5t5r%c 2VP!V.VO5/VBR#)zCalls the given callback on the next IOLoop iteration. As of Tornado 6.0, this method is equivalent to `add_callback`. .. versionadded:: 4.0 Nrrs&&*,r"spawn_callbackIOLoop.spawn_callbacks (4T4V4r%c<<V^8dQhRRRS[R.R3,RR/#)rrz0Union[Future[_T], concurrent.futures.Future[_T]]r Future[_T]Nr)r)r r!s"r"r#rBs:WWBWL>4/0W  Wr%c aa\V\4'dVPVV3Rl4R#\V4'gQh\ VVV3Rl4R#)a 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). cP<SP\P!SV44#r') _run_callback functoolspartialfrr*s&r"r#IOLoop.add_future..s$,,Y->->x-KLr%c(<SPSV4#r'rr$s&r"rr&st7H7HST7Ur%N)rGradd_done_callbackrr)r*rrsf&fr"rIOLoop.add_futuresE ff % %  $ $L V$$ $$ %V-U Vr%c|<V^8dQhRS[S[PP,RS[RS[3,RS[RR/#)rexecutorr.rrr)r concurrentfuturesExecutorrr:r )r r!s"r"r#rBsM:--667sBw   r%c "aVfV\VR4'g8^RIHp\PP V!4^,R7VnVP pVP!V.VO5!p\4oVPVV3Rl4S#)zRuns 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 _executor) cpu_count) max_workersc<\VS4#r')r)r%t_futures&r"r(IOLoop.run_in_executor..s LH,Er%) hasattrtornado.processr1r,r-ThreadPoolExecutorr0submitrr)r*r+rrr1c_futurer4s&&&* @r"run_in_executorIOLoop.run_in_executors}  4--5!+!3!3!F!F!*q"G"~~H??4/$/8 "EFr%cL<V^8dQhRS[PPRR/#)rr+rN)r,r-r.)r r!s"r"r#rBs'""Z-?-?-H-H"T"r%c WnR#)zVSets the default executor to use with :meth:`run_in_executor`. .. versionadded:: 5.0 Nr0)r*r+s&&r"set_default_executorIOLoop.set_default_executors "r%c8<V^8dQhRS[.S[3,RR/#)rrrNr)r r!s"r"r#rBs(OOhr3w&7ODOr%c <V!4pVe6^RIHpVPV4pVPW P4R#R# TP dR#i;i \ PdR#\d\P!RTRR7R#i;i)zhRuns a callback with error handling. .. versionchanged:: 6.0 CancelledErrors are no longer logged. N)genException in callback %rTr) tornadorDrr_discard_future_result BadYieldErrorrnCancelledErrorrrerror)r*rretrDs&& r"r!IOLoop._run_callbacks O*C' F--c2COOC)D)DE(( %%   O MM4h N N Os?AAAAAAAB4B=BBc$<V^8dQhRS[RR/#)rrrNr)r r!s"r"r#rB sVr%c &VP4R#)z;Avoid unhandled-exception warnings from spawned coroutines.N)r)r*rs&&r"rHIOLoop._discard_future_result s  r%ch<V^8dQhRS[S[S[3,RS[S[S[S[S[3,3,/#)rrr)r rrr)r r!s"r"r#rBs;[() sE#{*++ ,r%cX\V\4'dW3#VP4V3#r')rGrr+rs&&r"split_fdIOLoop.split_fds($ b#  6Myy{Br%c:<V^8dQhRS[S[S[3,RR/#rr)r r!s"r"r#rB&s%5k!12tr%c\V\4'd\P!V4R#VP4R# \dR#i;ir')rGrosr1OSErrorrs&&r"close_fdIOLoop.close_fd&s: "c""     s,AA AAc$<V^8dQhRS[RR/#rr%rNrO)r r!s"r"r#rB:s###4#r%c<VPPV4R#r')_pending_tasksaddr*r%s&&r"_register_taskIOLoop._register_task:s "r%c$<V^8dQhRS[RR/#r]rO)r r!s"r"r#rB=s''&'T'r%c<VPPV4R#r')r_discardras&&r"_unregister_taskIOLoop._unregister_task=s ##A&r%r?)T)Fr')9r3r4r5r6__doc__NONEREADWRITEERRORdictrrsetr_ classmethodrM staticmethodrUrZr_roverloadrTrYr|r^rrrrrr1rrrrrrrrrrrrrrrr;r@r!rHrTrZrbrgr7r8 __classcell__)rOr!s@@r"r>r>HsK\ D D E E&UN * * *  *     __   __   ***X6$$  &&    !!$$6 __   __  $$&$$$$$$ $ $U.U.n  'B'BR L LAA$$$ $ $ $ $55WWB8""OO<,(##'''r%r>cba]tRtRtoRt.R OtV3RlRltV3RlRltV3RlRltR t Vt R #) _TimeoutiAz2An IOLoop timeout, a UNIX timestamp and a callbackcB<V^8dQhRS[RS[.R3,RS[RR/#)rrrNio_loopr)rrr>)r r!s"r"r#_Timeout.__annotate__Gs6     )1"d();  FL    r%c\V\P4'g\RV,4hWnW nV\ VP43VnR#)rN) rGrrrrrnext_timeout_counter tdeadline)r*rrrws&&&&r"__init___Timeout.__init__GsJ(GLL115@A A   )) * r%c$<V^8dQhRRRS[/#rotherrurr)r r!s"r"r#rxWs00J040r%c4VPVP8#r'r|r*rs&&r"__lt___Timeout.__lt__Ws~~//r%c$<V^8dQhRRRS[/#rr)r r!s"r"r#rxZs11J141r%c4VPVP8*#r'rrs&&r"__le___Timeout.__le__Zs~~00r%)rrr|N)rrr|) r3r4r5r6ri __slots__r}rrr7r8r9s@r"ruruAs-<6I   0011r%ruca]tRtRtoRtRV3RlRlltV3RlRltV3RlRltV3R lR ltV3R lR lt V3R lRlt V3RlRlt Rt Vt R#)PeriodicCallbacki^aSchedules 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. c~<V^8dQhRS[.S[S[,3,RS[S[P S[3,RS[RR/#)rr callback_timejitterrN)rrrr rrr)r r!s"r"r#PeriodicCallback.__annotate__sR2x 223X//67   r%cWn\V\P4'd%V\P!^R7, VnMV^8:d \ R4hW nW0nRVnRVnR#)) millisecondsz4Periodic callback must have a positive callback_timeFN) rrGrrr ValueErrorr_running_timeout)r*rrrs&&&&r"r}PeriodicCallback.__init__sb ! mX%7%7 8 8!.1C1CQR1S!SD ! !WXX!.    r%c<V^8dQhRR/#r/r()r r!s"r"r#rstr%c \P4VnRVnVPP 4VnVP 4R#)zStarts the timer.TN)r>rTrwrr _next_timeout_schedule_nextr)s&r"rPeriodicCallback.starts: ~~'  !\\..0 r%c<V^8dQhRR/#r/r()r r!s"r"r#rs!!d!r%c RVnVPe/VPPVP4RVnR#R#)zStops the timer.FN)rrrwrr)s&r"rPeriodicCallback.stops5 == $ LL ' ' 6 DM %r%c <V^8dQhRS[/#rr)r r!s"r"r#rsDr%c VP#)zVReturns ``True`` if this `.PeriodicCallback` has been started. .. versionadded:: 4.1 )rr)s&r" is_runningPeriodicCallback.is_runnings }}r%c<V^8dQhRR/#r/r()r r!s"r"r#rs " "D "r%cL"VP'gR#VP4pVe\V4'd VGRjxL TP 4R#L \d'\P !RTPRR7LDi;i TP 4i;i5i)NrETrF)rrrrrrKr)r*vals& r"_runPeriodicCallback._runs~}}}  "--/C;s#3#3     !  T MM4dmmd S T    !sFB$*AAAB$A.B  B B  BB!!B$c<V^8dQhRR/#r/r()r r!s"r"r#rsTTTr%cVP'daVPVPP44VPP VP VP 4VnR#R#r')r _update_nextrwrrrrrr)s&r"rPeriodicCallback._schedule_nextsM ===   dll//1 2 LL44T5G5GSDM r%c$<V^8dQhRS[RR/#)r current_timerNr)r r!s"r"r#rs44444r%cVPR, pVP'd<V^VP\P!4R, ,,,pVPV8:dUV;P\P !WP, V, 4^,V,, unR#V;PV, unR#)g@@g?N)rrrandomrmathfloor)r*rcallback_time_secs&& r"rPeriodicCallback._update_nexts ..7 ;;; dkkV]]_s5J&K!L L     -    L+=+==ARRSVWW!#" " $   "3 3 r%)rrrrrrwrN)rD)r3r4r5r6rir}rrrrrrr7r8r9s@r"rr^sS#J"!! " "TT 44r%r)2rirnconcurrent.futuresr,rr"rrXrrrrryinspectrtornado.concurrentrrrrr tornado.logr tornado.utilr r r rr r rrrrrrrrrrrtyping_extensionsrrrr:r;r>rurr(r%r"rs   BB RRR 11*H (  T] T%v '\v 'r11:|4|4r%