]j-SrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSK r SSK r SSK r SSK r SSK Jr SSKJrJrJrJrJr SSKJr SSKJrJrJr SSKrSSKJrJrJrJrJ r J!r!J"r"J#r# \RH(aSSKJ%r%J&r&J'r'J(r( SS K)J*r* O\+r*"S S \*5r,\!"S 5r-\!"S \,S9r."SS\5r/"SS5r0"SS5r1g)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)Protocolc,\rSrSrS\4SjrSSjrSrg) _Selectable<returncgNselfs K/home/mande/repo/quber/.venv/lib/python3.13/site-packages/tornado/ioloop.pyfileno_Selectable.fileno= Ncgrr r!s r#close_Selectable.close@r&r'r rN)__name__ __module__ __qualname____firstlineno__intr$r)__static_attributes__r r'r#rr<s   r'r_T_S)boundc F^\rSrSrSrSrSrSrSr\ "5r \ "5r \ SSS \S S 4U4S jj5r\SJS j5rSKSjr\SKSj5r\R*\SJSj55r\R*\SLS\S \S4Sjj55r\SLS\S \S4Sjj5rSKSjrSKSjr\SKSj5r\SKSj5rSKSjr\ S \\4Sj5r \ S \\4Sj5r!SLS\S S 4Sjjr"SMS\S S 4Sjjr#\R*S\$S \%\$\$/S 4S!\$S S 4S"j5r&\R*S\'S \%\'\$/S 4S!\$S S 4S#j5r&S\(\$\)4S \%S$S!\$S S 4S%jr&S\(\$\)4S!\$S S 4S&jr*S\(\$\)4S S 4S'jr+SKS(jr,SKS)jr-SNS*\%S+\\.S \4S,jjr/S \.4S-jr0S.\(\.\1Rd4S/\%S0\S \S \34 S1jr4S2\.S/\%S0\S \S \34 S3jr5S4\.S/\%S0\S \S \34 S5jr6S+\3S S 4S6jr7S/\%S0\S \S S 4S7jr8S/\%S0\S \S S 4S8jr9S/\%S0\S \S S 4S9jr:S:S;S/\%S\\\SSKJn [U[5(a [ U5n[U[ 5(a[ X5(d [S5e[TU]$"U40UD6 g)Nr)BaseAsyncIOLoopz5only AsyncIOLoop is allowed when asyncio is available) tornado.platform.asyncior> isinstancestrr type issubclass RuntimeErrorsuper configure)clsr;r<r> __class__s r#rFIOLoop.configuresT = dC  &D dD ! !*T*K*KVW W $)&)r'c*[R5$)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 )r6currentr r'r#instanceIOLoop.instances(~~r'c$UR5 g)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,[R5 g)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)r6 clear_currentr r'r#clear_instanceIOLoop.clear_instances r'cgrr r r'r#rKIOLoop.current r'rLcgrr rLs r#rKrWrXr'c2[R"5n[ R U$![a7 U(dg[R"5n[R"U5 NTf=f![a U(aSSKJ n U"5nU$SnU$f=f)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. Nr)AsyncIOMainLoop) asyncioget_event_looprDnew_event_loopset_event_loopr6_ioloop_for_asyncioKeyErrorr?r\)rLloopr\rKs r#rKrWs2 )))+D --d3 3 )))+D  " "4 (  ) D)+ s++A/A,+A,+A,/BBBcX[R"S[SS9 UR5 g)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#rOIOLoop.make_current"s'(  D  r'c[5erNotImplementedErrorr!s r#rkIOLoop._make_current=s !##r'c`[R"S[SS9 [R 5 g)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 deprecatedrerfN)rhrirjr6_clear_currentr r'r#rSIOLoop.clear_currentAs'  )  r'cR[RSS9nUbUR5 gg)NFrZ)r6rK_clear_current_hook)olds r#rrIOLoop._clear_currentRs(nnen, ?  # # % r'cg)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#ruIOLoop._clear_current_hookXs r'c[$r)r6)rGs r#configurable_baseIOLoop.configurable_base_s r'cSSKJn U$)Nr) AsyncIOLoop)r?r~)rGr~s r#configurable_defaultIOLoop.configurable_defaultcs 8r'rOc4U(aUR5 ggr)rk)r"rOs r# initializeIOLoop.initializeis      r'all_fdsc[5e)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. rn)r"rs r#r) IOLoop.closems 2"##r'fdhandlereventscgrr r"rrrs r# add_handlerIOLoop.add_handler r'cgrr rs r#rrrr').Nc[5e)aRegisters 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. rnrs r#rrs ""##r'c[5e)zChanges the events we listen for ``fd``. .. versionchanged:: 4.0 Added the ability to pass file-like objects in addition to raw file descriptors. rn)r"rrs r#update_handlerIOLoop.update_handler "##r'c[5e)zStop listening for events on ``fd``. .. versionchanged:: 4.0 Added the ability to pass file-like objects in addition to raw file descriptors. rnr"rs r#remove_handlerIOLoop.remove_handlerrr'c[5e)zStarts 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. rnr!s r#start IOLoop.starts "##r'c[5e)aYStop 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. rnr!s r#stop IOLoop.stops "##r'functimeoutc0^^^[R(a[S[[[ S.5nSSS.mS UUU4SjjnTR U5 Ub,S UU4SjjnTRTR5U-U5nTR5 UbTRW5 TSceTSR5(dTSR5(d#TS(a[S U-5e[S 5eTSR5$) aStarts 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)futuretimeout_calledNFcd>T"5nUbSSKJn U"U5n[U5(aUTS'O![5nUTS'UR U5 TSceTRTSU4Sj5 g![ a1 [5nUTS'[ U[R"55 N\f=f)Nr)convert_yieldedrc$>TR5$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 9sA448B/.B/cr>STS'TSceTSR5(dTR5 gg)NTrr)cancelr)rr"sr#timeout_callback)IOLoop.run_sync..timeout_callback sC04 ,- #8,888"8,3355IIK6r'rrz$Operation timed out after %s secondsz+Event loop stopped before Future completed.r+)typing TYPE_CHECKINGrrrbool add_callback add_timeouttimerremove_timeout cancelleddoner rDr)r"rrrrrtimeout_handlers`` @r#run_syncIOLoop.run_syncs@   "&)9TRJ"&?  O O* #   "--diikG.CEUVN      /8$000 x * * , ,K4I4N4N4P4P+,"#IG#STT##PQQ8$++--r'c,[R"5$)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'deadlinecallbackargsc2[U[R5(aUR"X/UQ70UD6$[U[R 5(a6UR"UR 5UR5-U/UQ70UD6$[SU-5e)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) r@numbersRealcall_atdatetime timedeltar total_seconds TypeError)r"rrrr<s r#rIOLoop.add_timeout3s@ h - -<<DTDVD D ("4"4 5 5<< h4466CGKQ 5@A Ar'delaycRUR"UR5U-U/UQ70UD6$)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"rrrr<s r# call_laterIOLoop.call_later\s*||DIIK%/KDKFKKr'whenc.UR"X/UQ70UD6$)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"rrrr<s r#rIOLoop.call_atks @@@@r'c[5e)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. rn)r"rs r#rIOLoop.remove_timeout}rr'c[5e)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. rnr"rrr<s r#rIOLoop.add_callbacks "##r'c[5e)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. rnrs r#add_callback_from_signalIOLoop.add_callback_from_signals "##r'c0UR"U/UQ70UD6 g)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'rz0Union[Future[_T], concurrent.futures.Future[_T]]z Future[_T]c^^[U[5(aURUU4Sj5 g[U5(de[ UUU4Sj5 g)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>TR[R"TU55$r) _run_callback functoolspartialfrr"s r#r#IOLoop.add_future..s$,,Y->->x-KLr'c(>TRTU5$rrrs r#rrst7H7HST7Ur'N)r@radd_done_callbackrr)r"rrs` `r#rIOLoop.add_futuresE ff % %  $ $L V$$ $$ %V-U Vr'executor.c^UcM[US5(d0SSKJn [RR U"5S-S9UlUR nUR"U/UQ76n[5mURUU4Sj5 T$)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 _executorr) cpu_count) max_workersc>[UT5$r)r)rt_futures r#r(IOLoop.run_in_executor..s LH,Er') hasattrtornado.processr concurrentfuturesThreadPoolExecutorrsubmitrr)r"rrrrc_futurers @r#run_in_executorIOLoop.run_in_executors}  4--5!+!3!3!F!F!*q"G"~~H??4/$/8 "EFr'cXlg)zVSets the default executor to use with :meth:`run_in_executor`. .. versionadded:: 5.0 Nr)r"rs r#set_default_executorIOLoop.set_default_executors "r'c$U"5nUb4SSKJn URU5nURX R5 gg!UR a gf=f![ Ra g[a [R"SUSS9 gf=f)zhRuns a callback with error handling. .. versionchanged:: 6.0 CancelledErrors are no longer logged. Nr)genException in callback %rTr) tornador rr_discard_future_result BadYieldErrorr]CancelledErrorrr error)r"rretr s r#rIOLoop._run_callbacks O*C' F--c2COOC)D)DE(( %%   O MM4h N Os9AAAAAAAB-BBc$UR5 g)z;Avoid unhandled-exception warnings from spawned coroutines.N)r)r"rs r#r IOLoop._discard_future_result s  r'cV[U[5(aX4$UR5U4$r)r@r0r$rs r#split_fdIOLoop.split_fds($ b#  6Myy{Br'c[U[5(a[R"U5 gUR5 g![a gf=fr)r@r0osr)OSErrorrs r#close_fdIOLoop.close_fd&s: "c""     s+?? A  A rc:URRU5 gr)_pending_tasksaddr"rs r#_register_taskIOLoop._register_task:s "r'c:URRU5 gr)rdiscardr s r#_unregister_taskIOLoop._unregister_task=s ##A&r'r)rr6r+)T)Fr)Lr,r-r.r/__doc__NONEREADWRITEERRORdictrasetr classmethodrrF staticmethodrLrPrTroverloadrKrrrOrkrSrrrurr r{rrr)r0rrr3r rrrrrfloatrrrrobjectrrrrrrrrrrExecutorr2rrrrr rrrr!r%r1 __classcell__)rHs@r#r6r6HsJK\ D D E E&UN *9 *EH *  * *  *    __   __ $ (8*<  *$*(8*<**X6$  &&  $|"4T,%7 !t!t!$T$d$6 __  (#sT)9 : DG    __  'S 48 BE   $[()$44/0W  WB:--667sBw   8"Z-?-?-H-H"T"Ohr3w&7ODO<V[() sE#{*++ ,,5k!12t(##4#'&'T''r'r6ch\rSrSrSr/SQrS\S\/S4S\SS4S jr S SS\ 4S jr S SS\ 4S jr S r g)_TimeoutiAz2An IOLoop timeout, a UNIX timestamp and a callback)rr tdeadlinerrNio_looprc[U[R5(d[SU-5eXlX lU[ UR54Ulg)Nr) r@rrrrrnext_timeout_counterr7)r"rrr8s r#__init___Timeout.__init__GsJ(GLL115@A A   )) * r'otherc4URUR:$rr7r"r>s r#__lt___Timeout.__lt__Ws~~//r'c4URUR:*$rr@rAs r#__le___Timeout.__le__Zs~~00r')rrr7)r,r-r.r/r' __slots__r1rr6r<rrBrEr1r r'r#r6r6As`<6I    )1"d();  FL    0J0401J141r'r6c \rSrSrSrSS\/\\4S\\ R\ 4S\ SS4Sjjr SS jr SS jrS\4S jrSS jrSS jrS\ SS4SjrSrg)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. r callback_timejitterrNcXl[U[R5(aU[R"SS9- UlOUS::a [ S5eX lX0lSUlSUlg)Nr8) millisecondsrz4Periodic callback must have a positive callback_timeF) rr@rrrJ ValueErrorrK_running_timeout)r"rrJrKs r#r<PeriodicCallback.__init__sb ! mX%7%7 8 8!.1C1CQR1S!SD ! !WXX!.    r'c[R5UlSUlURR 5UlUR 5 g)zStarts the timer.TN)r6rKr8rOr _next_timeout_schedule_nextr!s r#rPeriodicCallback.starts: ~~'  !\\..0 r'cSUlURb-URRUR5 SUlgg)zStops the timer.FN)rOrPr8rr!s r#rPeriodicCallback.stops5 == $ LL ' ' 6 DM %r'cUR$)zVReturns ``True`` if this `.PeriodicCallback` has been started. .. versionadded:: 4.1 )rOr!s r# is_runningPeriodicCallback.is_runnings }}r'c:# UR(dgUR5nUb[U5(a UIShvN UR 5 gN![a# [R "SURSS9 N?f=f!UR 5 f=f7f)Nr Tr )rOrrrr rrT)r"vals r#_runPeriodicCallback._runs|}}  "--/C;s#3#3     !  T MM4dmmd S T    !sDB(AAABA*BBBBBBcUR(a_URURR55 URR UR UR 5Ulggr)rO _update_nextr8rrrSr]rPr!s r#rTPeriodicCallback._schedule_nextsK ==   dll//1 2 LL44T5G5GSDM r' current_timecbURS- nUR(a+USUR[R"5S- ---nURU::a?U=R[R "XR- U- 5S-U-- slgU=RU- slg)Ng@@r8g?)rJrKrandomrSmathfloor)r"rbcallback_time_secs r#r`PeriodicCallback._update_nexts ..7 ;; dkkV]]_s5J&K!L L     -    L+=+==ARRSVWW!#" " $   "3 3 r')rSrOrPrrJr8rK)rr+)r,r-r.r/r'rrrr rrr1r<rrrrYr]rTr`r1r r'r#rIrI^s#R 2x 223X//67   "!D "T 4444r'rI)2r'r]concurrent.futuresrrrrrrrrerdrhinspectrtornado.concurrentrrrrr tornado.logr tornado.utilr r r rr rrrrrrrrrrrrtyping_extensionsrr2rr2r3r6r6rIr r'r#ros   BB RRR 11*H (  T] T%v '\v 'r11:|4|4r'