o )Zhҏ@sXdZddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl mZddlmZmZmZmZmZddlmZddlmZmZmZddlZddlmZmZmZmZm Z m!Z!m"Z"m#Z#ej$r~ddlm%Z%m&Z&m'Z'dd l(m)Z)ne*Z)Gd d d e)Z+e!d Z,e!d e+dZ-GdddeZ.Gddde*Z/Gddde*Z0dS)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)Protocolc@s$eZdZdefddZdddZdS) _SelectablereturncCdSNselfrrE/var/www/html/lang_env/lib/python3.10/site-packages/tornado/ioloop.pyfileno=z_Selectable.filenoNcCrrrrrrrclose@r!z_Selectable.closerN)__name__ __module__ __qualname__intr r"rrrrr<sr_T_S)boundc seZdZdZdZdZdZdZeZ e Z e ddde d d ffd d Zedod dZdpddZedpddZejedoddZejedqded edfddZedqded edfddZdpddZdpddZedpddZedpdd Zdpd!d"Ze d eefd#d$Ze d eefd%d&Z dqd'ed d fd(d)Z!drd+ed d fd,d-Z"ejd.e#d/e$e#e#gd fd0e#d d fd1d2Z%ejd.e&d/e$e&e#gd fd0e#d d fd3d2Z%d.e'e#e(fd/e$d4d0e#d d fd5d2Z%d.e'e#e(fd0e#d d fd6d7Z)d.e'e#e(fd d fd8d9Z*dpd:d;Z+dpde$d?ee-d e fd@dAZ.d e-fdBdCZ/dDe'e-e0j1fdEe$dFe de d e2f dGdHZ3dIe-dEe$dFe de d e2f dJdKZ4dLe-dEe$dFe de d e2f dMdNZ5d?e2d d fdOdPZ6dEe$dFe de d d fdQdRZ7dEe$dFe de d d fdSdTZ8dEe$dFe de d d fdUdVZ9dWdXdEe$dYgd fd d fdZd[Z:d\ee;je$d]e>fdFe d dYfd^d_Z?d\e;jcCrrrr>rrrr=rCcCs~zt}Wnty|sYdSt}t|Ynwztj|WSty>|r9ddlm }|}Y|Sd}Y|Sw)aCReturns 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_loopr7Znew_event_loopZset_event_loopr+_ioloop_for_asyncioKeyErrorr2rE)r>looprEr=rrrr=s$     cCstjdtdd|dS)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_currentrrrrr?%s  zIOLoop.make_currentcCtrNotImplementedErrorrrrrrP@szIOLoop._make_currentcCstjdtddtdS)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 deprecatedrJrKN)rMrNrOr+_clear_currentrrrrrADs   zIOLoop.clear_currentcCs$tjdd}|dur|dSdS)NFrD)r+r=_clear_current_hook)oldrrrrTUs  zIOLoop._clear_currentcCsdS)zInstance method called when an IOLoop ceases to be current. May be overridden by subclasses as a counterpart to make_current. NrrrrrrU[szIOLoop._clear_current_hookcCstSr)r+)r:rrrconfigurable_basebszIOLoop.configurable_basecCsddlm}|S)Nr) AsyncIOLoop)r2rX)r:rXrrrconfigurable_defaultfs zIOLoop.configurable_defaultr?cCs|r|dSdSr)rP)rr?rrr initializels zIOLoop.initializeFall_fdscCrQ)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. rR)rr[rrrr"psz IOLoop.closefdhandlereventscCrrrrr\r]r^rrr add_handlerzIOLoop.add_handlercCrrrr_rrrr`ra).NcCrQ)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. rRr_rrrr`scCrQ)zChanges the events we listen for ``fd``. .. versionchanged:: 4.0 Added the ability to pass file-like objects in addition to raw file descriptors. rR)rr\r^rrrupdate_handlerzIOLoop.update_handlercCrQ)zStop listening for events on ``fd``. .. versionchanged:: 4.0 Added the ability to pass file-like objects in addition to raw file descriptors. rRrr\rrrremove_handlerrczIOLoop.remove_handlercCrQ)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. rRrrrrstartsz IOLoop.startcCrQ)aStop 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. rRrrrrstops z IOLoop.stopfunctimeoutcsdgd fdd }||dur'd fdd }||}|dur4|ddussz.IOLoop.run_sync..run..) Z tornado.genrj Exceptionrrsysexc_inforZ set_result add_future)resultrjZfutrh future_cellrrrruns$    zIOLoop.run_sync..runcs,ddusJdsdSdS)Nr)cancelrgr)rsrrrtimeout_callback s  z)IOLoop.run_sync..timeout_callbackrz$Operation timed out after %s secondsr#) add_callback add_timeouttimerfremove_timeoutZ cancelleddoner rq)rrhrirtrvZtimeout_handlerrrrrun_syncs      zIOLoop.run_synccCstS)aReturns 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`. )ryrrrrrys z IOLoop.timedeadlinecallbackargscOsdt|tjr|j||g|Ri|St|tjr,|j|||g|Ri|Std|)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) r3numbersRealcall_atdatetime timedeltary total_seconds TypeError)rr}r~rr0rrrrx+s   zIOLoop.add_timeoutdelaycOs"|j|||g|Ri|S)aRuns 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 )rry)rrr~rr0rrr call_laterTs" zIOLoop.call_laterwhencOs|j||g|Ri|S)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 )rx)rrr~rr0rrrrcszIOLoop.call_atcCrQ)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. rR)rrirrrrzurczIOLoop.remove_timeoutcOrQ)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. rRrr~rr0rrrrw~s zIOLoop.add_callbackcOrQ)aCalls 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. rRrrrradd_callback_from_signals zIOLoop.add_callback_from_signalcOs|j|g|Ri|dS)zCalls the given callback on the next IOLoop iteration. As of Tornado 6.0, this method is equivalent to `add_callback`. .. versionadded:: 4.0 Nrwrrrrspawn_callbackszIOLoop.spawn_callbackrkz0Union[Future[_T], concurrent.futures.Future[_T]]z Future[_T]csFt|tr|fdddSt|sJt|fdddS)aASchedules 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). cst|Sr) _run_callback functoolspartialfr~rrrrlsz#IOLoop.add_future..cs |Srrrrrrrls N)r3rZadd_done_callbackrr)rrkr~rrrrps   zIOLoop.add_futureexecutor.csj|durt|dsddlm}tjj|dd|_|j}|j|g|R}t| |fddS) 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 N _executorr) cpu_count) max_workerscs t|Sr)rrZt_futurerrrls z(IOLoop.run_in_executor..) hasattrZtornado.processr concurrentfuturesZThreadPoolExecutorrZsubmitrrp)rrrhrrZc_futurerrrrun_in_executors  zIOLoop.run_in_executorcCs ||_dS)zfSets the default executor to use with :meth:`run_in_executor`. .. versionadded:: 5.0 N)r)rrrrrset_default_executors zIOLoop.set_default_executorcCsz.|}|dur,ddlm}z||}Wn |jy!YWdSw|||jWdSWdStjy9YdStyJt j d|ddYdSw)zRuns a callback with error handling. .. versionchanged:: 6.0 CancelledErrors are no longer logged. Nr)genException in callback %rTro) tornadorrjZ BadYieldErrorrp_discard_future_resultrFZCancelledErrorrmrerror)rr~retrrrrrs   zIOLoop._run_callbackcCs |dS)z;Avoid unhandled-exception warnings from spawned coroutines.N)rq)rrkrrrrs zIOLoop._discard_future_resultcCst|tr ||fS||fSr)r3r'r rdrrrsplit_fds  zIOLoop.split_fdcCs>zt|trt|WdS|WdStyYdSwr)r3r'osr"OSErrorrdrrrclose_fds  zIOLoop.close_fdrcC|j|dSr)_pending_tasksaddrrrrr_register_task2zIOLoop._register_taskcCrr)rdiscardrrrr_unregister_task5rzIOLoop._unregister_task)rr+r#)T)Fr)Jr$r%r&__doc__NONEREADWRITEERRORdictrGsetr classmethodr r9 staticmethodr>r@rBtypingoverloadr=boolrr?rPrArTrUrr rWrYrZr"r'rr`r)r rrbrerfrgfloatr|ryrrobjectrxrrrzrwrrrprrZExecutorr(rrrrrrrrrr __classcell__rrr;rr+Hs*Q     ,          L  )        !     r+c@s^eZdZdZgdZdedegdfdeddfdd Zd dde fd d Z d dde fd dZ dS)_Timeoutz2An IOLoop timeout, a UNIX timestamp and a callback)r}r~ tdeadliner}r~Nio_looprcCs8t|tjs td|||_||_|t|jf|_dS)Nr) r3rrrr}r~nextZ_timeout_counterr)rr}r~rrrr__init__?s   z_Timeout.__init__othercCs |j|jkSrrrrrrr__lt__O z_Timeout.__lt__cCs |j|jkSrrrrrr__le__Rrz_Timeout.__le__) r$r%r&r __slots__rrr+rrrrrrrrr9s  rc @seZdZdZ ddegeefdeej e fde ddfdd Z dd d Z dd d Z defddZdddZdddZde ddfddZdS)PeriodicCallbackaSchedules 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. rr~ callback_timejitterrNcCsR||_t|tjr|tjdd|_n |dkrtd||_||_d|_d|_dS)Nr,)Z millisecondsrz4Periodic callback must have a positive callback_timeF) r~r3rrr ValueErrorr_running_timeout)rr~rrrrrr|s  zPeriodicCallback.__init__cCs(t|_d|_|j|_|dS)zStarts the timer.TN)r+r=rrry _next_timeout_schedule_nextrrrrrfs   zPeriodicCallback.startcCs,d|_|jdur|j|jd|_dSdS)zStops the timer.FN)rrrrzrrrrrgs   zPeriodicCallback.stopcCs|jS)zfReturns ``True`` if this `.PeriodicCallback` has been started. .. versionadded:: 4.1 )rrrrr is_runningszPeriodicCallback.is_runningcs|jsdSz4z|}|durt|r|IdHWnty,tjd|jddYnwW|dSW|dS|w)NrTr)rr~rrmrrr)rvalrrr_runs   zPeriodicCallback._runcCs2|jr||j|j|j|j|_dSdSr)r _update_nextrryrxrrrrrrrrszPeriodicCallback._schedule_next current_timecCsp|jd}|jr|d|jtd9}|j|kr/|jt||j|d|7_dS|j|7_dS)Ng@@r,g?)rrrandomrmathfloor)rrZcallback_time_secrrrrs   zPeriodicCallback._update_next)rr#)r$r%r&rrrrr rrrrrfrgrrrrrrrrrrVs$)     r)1rrFconcurrent.futuresrrrrrrnryrrrMinspectrZtornado.concurrentrrrrrZ tornado.logrZ tornado.utilr r r rr r rrrrrr TYPE_CHECKINGrrrtyping_extensionsrrrr(r)r+rrrrrrsB   ( v