Mhz DdZddlZddlZddlZddlmZddlZddlZddl Z ddl m Z ddl m Z ddl Z ddlZddlmZmZmZmZmZmZddlmZddlmZdd lmZ ddlZn #e$rdZYnwxYwddlZdd lmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)ej*r dd lm+Z+m,Z,m-Z-m.Z.ej/d Z0e de&e#e&e'e!e&fej1jfZ2Gd de3Z4Gdde3Z5Gdde3Z6Gdde3Z7Gdde3Z8de e9dfde!fdZ:defdZ;de"de0fde!de!de0fd Zfd'Z?Gd(de3Z@Gd)d*ZA dCd,e e(e2ee!e2ffd-d.dd/fd0ZBeBZC dCd,e e(e2ee!e2ffd-d.dd/fd1ZDd2e!defd3ZE dCd4e eFejGfd5e2d-d.defd6ZHd7eFdd8fd9ZIGd:d;ZJejKeeJZLejKeeJZMdZNd?e&defd@ZOdAe2defdBZPe ePZPdS)Da* ``tornado.gen`` implements generator-based coroutines. .. note:: The "decorator and generator" approach in this module is a precursor to native coroutines (using ``async def`` and ``await``) which were introduced in Python 3.5. Applications that do not require compatibility with older versions of Python should use native coroutines instead. Some parts of this module are still useful with native coroutines, notably `multi`, `sleep`, `WaitIterator`, and `with_timeout`. Some of these functions have counterparts in the `asyncio` module which may be used as well, although the two may not necessarily be 100% compatible. Coroutines provide an easier way to work in an asynchronous environment than chaining callbacks. Code using coroutines is technically asynchronous, but it is written as a single generator instead of a collection of separate functions. For example, here's a coroutine-based handler: .. testcode:: class GenAsyncHandler(RequestHandler): @gen.coroutine def get(self): http_client = AsyncHTTPClient() response = yield http_client.fetch("http://example.com") do_something_with_response(response) self.render("template.html") Asynchronous functions in Tornado return an ``Awaitable`` or `.Future`; yielding this object returns its result. You can also yield a list or dict of other yieldable objects, which will be started at the same time and run in parallel; a list or dict of results will be returned when they are all finished: .. testcode:: @gen.coroutine def get(self): http_client = AsyncHTTPClient() response1, response2 = yield [http_client.fetch(url1), http_client.fetch(url2)] response_dict = yield dict(response3=http_client.fetch(url3), response4=http_client.fetch(url4)) response3 = response_dict['response3'] response4 = response_dict['response4'] If ``tornado.platform.twisted`` is imported, it is also possible to yield Twisted's ``Deferred`` objects. See the `convert_yielded` function to extend this mechanism. .. versionchanged:: 3.2 Dict support added. .. versionchanged:: 4.1 Support added for yielding ``asyncio`` Futures and Twisted Deferreds via ``singledispatch``. N) Generator)singledispatch) isawaitable)Future is_future chain_futurefuture_set_exc_infofuture_add_done_callback"future_set_result_unless_cancelled)IOLoop)app_log) TimeoutError) MappingUnionAnyCallableListTypeTuple AwaitableDictSequenceoverload)DequeOptionalSetIterable_TceZdZdS) KeyReuseErrorN__name__ __module__ __qualname__K/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/tornado/gen.pyr r vDr&r ceZdZdS)UnknownKeyErrorNr!r%r&r'r*r*zr(r&r*ceZdZdS)LeakedCallbackErrorNr!r%r&r'r,r,~r(r&r,ceZdZdS) BadYieldErrorNr!r%r&r'r.r.r(r&r.ceZdZdS)ReturnValueIgnoredErrorNr!r%r&r'r0r0r(r&r0eReturnreturnc~ |jS#t$rYnwxYw |jdS#ttf$rYdSwxYw)Nr)valueAttributeErrorargs IndexError)r1s r'_value_from_stopiterationr9sj w      vay J 'tts  '<<ct}t|dd}|r |dd}|tkr|d=nn| |S)N_source_tracebackr%r)rgetattr__file__)futuresource_tracebackfilenames r'_create_futurerBsa XXFv':B?? $B'* x   $$   Mr&f.r7kwc||i|SNr%)rCr7rDs r' _fake_ctx_runrGs 1d>b>>r&func).zGenerator[Any, Any, _T]). Future[_T]cdSrFr%rHs r' coroutinerLs #&#r&cdSrFr%rKs r'rLrLsGJsr&cbtjfd}|_d|_|S)a>Decorator for asynchronous generators. For compatibility with older versions of Python, coroutines may also "return" by raising the special exception `Return(value) `. Functions with this decorator return a `.Future`. .. warning:: When exceptions occur inside a coroutine, the exception information will be stored in the `.Future` object. You must examine the result of the `.Future` object, or the exception may go unnoticed by your code. This means yielding the function if called from another coroutine, using something like `.IOLoop.run_sync` for top-level calls, or passing the `.Future` to `.IOLoop.add_future`. .. versionchanged:: 6.0 The ``callback`` argument was removed. Use the returned awaitable object instead. ct}ttjj}nt} |g|Ri|}t |t r |t|}t||||| fdng#ttf$r'}t|t|Yd}~n4d}~wt$r$t|t!jYnwxYwd} |d}S#d}wxYwne#ttf$r}t|}Yd}~n@d}~wt$r0t|t!j |d}cYS#d}wxYwwxYwt|||S)NcSrFr%)_runners r'z,coroutine..wrapper..svr&)rB contextvars copy_contextrunrG isinstancernextRunneradd_done_callback StopIterationr2r r9 Exceptionr sysexc_info) r7kwargsr?ctx_runresultyieldedr1rRrHs @r'wrapperzcoroutine..wrappers  !!  "!.004GG#G1 "WT3D333F33F&),,% " ?%gdF33G $GVVWEEF,,-=-=-=-=>>>>!&v.6 9! < <!@@@' ?????@ "!"FFTFMMMMK% " & 2 2 2.q11FFFFFF      7 7 7   \ +66::: sY D BC;(C  .C;:C;DD  E/D22.E/!E'"E/'E++E/T) functoolswraps __wrapped____tornado_coroutine__)rHrcs` r'rLrLsK8_T<<<<<|G$(G! Nr&c$t|ddS)zReturn whether *func* is a coroutine function, i.e. a function wrapped with `~.gen.coroutine`. .. versionadded:: 4.5 rgF)r=rKs r'is_coroutine_functionris 40% 8 88r&c.eZdZdZddeddffd ZxZS)r2a&Special exception to return a value from a `coroutine`. This exception exists for compatibility with older versions of Python (before 3.3). In newer code use the ``return`` statement instead. If this exception is raised, its value argument is used as the result of the coroutine:: @gen.coroutine def fetch_json(url): response = yield AsyncHTTPClient().fetch(url) raise gen.Return(json_decode(response.body)) By analogy with the return statement, the value argument is optional. Nr5r3cft||_|f|_dSrF)super__init__r5r7)selfr5 __class__s r'rmzReturn.__init__1s-  H r&rF)r"r#r$__doc__rrm __classcell__)ros@r'r2r2sZ"cTr&ceZdZdZiZdededdfdZdefdZdefdZ d eddfd Z d edefd Z de j fd Zdefd ZdS) WaitIteratoraProvides an iterator to yield the results of awaitables as they finish. Yielding a set of awaitables like this: ``results = yield [awaitable1, awaitable2]`` pauses the coroutine until both ``awaitable1`` and ``awaitable2`` return, and then restarts the coroutine with the results of both awaitables. If either awaitable raises an exception, the expression will raise that exception and all the results will be lost. If you need to get the result of each awaitable as soon as possible, or if you need the result of some awaitables even if others produce errors, you can use ``WaitIterator``:: wait_iterator = gen.WaitIterator(awaitable1, awaitable2) while not wait_iterator.done(): try: result = yield wait_iterator.next() except Exception as e: print("Error {} from {}".format(e, wait_iterator.current_future)) else: print("Result {} received from {} at {}".format( result, wait_iterator.current_future, wait_iterator.current_index)) Because results are returned as soon as they are available the output from the iterator *will not be in the same order as the input arguments*. If you need to know which future produced the current result, you can use the attributes ``WaitIterator.current_future``, or ``WaitIterator.current_index`` to get the index of the awaitable from the input list. (if keyword arguments were used in the construction of the `WaitIterator`, ``current_index`` will use the corresponding keyword). `WaitIterator` implements the async iterator protocol, so it can be used with the ``async for`` statement (note that in this version the entire iteration is aborted if any value raises an exception, while the previous example can continue past individual errors):: async for result in gen.WaitIterator(future1, future2): print("Result {} received from {} at {}".format( result, wait_iterator.current_future, wait_iterator.current_index)) .. versionadded:: 4.1 .. versionchanged:: 4.3 Added ``async for`` support in Python 3.5. r7r_r3Nc|r|rtd|rEd|D|_t|}n dt |D|_|}t j|_d|_ d|_ d|_ |D]}t||j dS)Nz)You must provide args or kwargs, not bothci|]\}}|| Sr%r%).0krCs r' z)WaitIterator.__init__..vsBBB!Q1BBBr&ci|]\}}|| Sr%r%)rvirCs r'rxz)WaitIterator.__init__..ysCCC!Q1CCCr&) ValueErroritems _unfinishedlistvalues enumerate collectionsdeque _finished current_indexcurrent_future_running_futurer _done_callback)rnr7r_futuresr?s r'rmzWaitIterator.__init__qs  JF JHII I  BB6<<>>BBBD 6==??++GGCC9T??CCCD G$*,,!"# B BF $VT-@ A A A A B Br&cB|js|jrdSdx|_|_dS)z2Returns True if this iterator has no more results.FNT)rr}rrrns r'donezWaitIterator.dones0 > T- 5377T0tr&ct|_|jr,||jS|jS)zReturns a `.Future` that will yield the next available result. Note that this `.Future` will not be the same object as any of the inputs. )rrr_return_resultpopleftrs r'rXzWaitIterator.nextsF &xx > A&&t~'='='?'?@@ @##r&rc|jr0|js||dS|j|dSrF)rrrrappend)rnrs r'rzWaitIterator._done_callbacksY   ((<(A(A(C(C (    % % % % % N ! !$ ' ' ' ' 'r&c|jtdt||j|j}d|_||_|j||_|S)zCalled set the returned future's state that of the future we yielded, and set the current future for the iterator. Nzno future is running)rr\rrr}popr)rnrress r'rzWaitIterator._return_resultse   '233 3T4/000"#"!-11$77 r&c|SrFr%rs r' __aiter__zWaitIterator.__aiter__s r&c|rttd|S)NStopAsyncIteration)rr=builtinsrXrs r' __anext__zWaitIterator.__anext__s9 99;; <9'($899;; ;yy{{r&)r"r#r$rpr}rrmboolrrXrrtyping AsyncIteratorrrr%r&r'rsrs8s 44lKBfBB4BBBB&d $f $ $ $ $(6(d(((( 6 f    6/6r&rsr%childrenquiet_exceptionsz3Union[Type[Exception], Tuple[Type[Exception], ...]]z!Union[Future[List], Future[Dict]]c$t||S)aRuns multiple asynchronous operations in parallel. ``children`` may either be a list or a dict whose values are yieldable objects. ``multi()`` returns a new yieldable object that resolves to a parallel structure containing their results. If ``children`` is a list, the result is a list of results in the same order; if it is a dict, the result is a dict with the same keys. That is, ``results = yield multi(list_of_futures)`` is equivalent to:: results = [] for future in list_of_futures: results.append(yield future) If any children raise exceptions, ``multi()`` will raise the first one. All others will be logged, unless they are of types contained in the ``quiet_exceptions`` argument. In a ``yield``-based coroutine, it is not normally necessary to call this function directly, since the coroutine runner will do it automatically when a list or dict is yielded. However, it is necessary in ``await``-based coroutines, or to pass the ``quiet_exceptions`` argument. This function is available under the names ``multi()`` and ``Multi()`` for historical reasons. Cancelling a `.Future` returned by ``multi()`` does not cancel its children. `asyncio.gather` is similar to ``multi()``, but it does cancel its children. .. versionchanged:: 4.2 If multiple yieldables fail, any exceptions after the first (which is raised) will be logged. Added the ``quiet_exceptions`` argument to suppress this logging for selected exception types. .. versionchanged:: 4.3 Replaced the class ``Multi`` and the function ``multi_future`` with a unified function ``multi``. Added support for yieldables other than ``YieldPoint`` and `.Future`. )r) multi_future)rrs r'multirs` 3C D D DDr&c, t|tr6t||}nd|}tt t |tdDsJt tstingdtddf fd }t}D]+}||vr%| |t||,S)aWait for multiple asynchronous futures in parallel. Since Tornado 6.0, this function is exactly the same as `multi`. .. versionadded:: 4.0 .. versionchanged:: 4.2 If multiple ``Futures`` fail, any exceptions after the first (which is raised) will be logged. Added the ``quiet_exceptions`` argument to suppress this logging for selected exception types. .. deprecated:: 4.3 Use `multi` instead. Nc3^K|](}t|pt|tV)dSrF)rrW _NullFuture)rvrzs r' zmulti_future..s7QQay||9z![99QQQQQQr&futr3c (|sg}D]} ||+#t$rf}r't |st jddn!ttj Yd}~d}~wwxYwsC-ttt|dSt|dSdSdS)Nz!Multiple exceptions in yield listTr^)removerrar\rrWr errorr r]r^r dictzip) r result_listrCr1 children_futsr?keysrunfinished_childrens r'callbackzmulti_future..callbacksZ""3'''" LK" D D D&&qxxzz2222 DDD{{}}D)!-=>>#M Cd,FCLNNCCCD;;== L#6S{%;%; < <7v{KKKKK' L L L Ls'A B8AB33B8)rWrr~rrmapconvert_yieldedallsetrBr raddr ) rr children_seqr listeningrCrr?rrs ` @@@@r'rrsY$(D!! HMMOO$$((  _l;;<.error_callbackqs  MMOOOOO%    DD   a!122  :FT       sA, A,'A''A,cs"tdtdS)NTimeout)r set_exceptionrr )rfuture_convertedrasr'timeout_callbackz&with_timeout..timeout_callback|sF{{}} :  i!8!8 9 9 9 !1>BBBBBr&c.SrFremove_timeoutr?io_looptimeout_handles r'rSzwith_timeout..W-C-CN-S-Sr&c.SrFrrs r'rSzwith_timeout..rr&r3N) rrBrr currentr add_timeoutrWr add_future) rr?rrrrrrars ` @@@@@r' with_timeoutrBs'T'v..   F!6***nG v $      CCCCCCCC ((2BCCN"F++   ! SSSSS     SSSSS    Mr&durationz Future[None]cxttj|fdS)aReturn a `.Future` that resolves after the given number of seconds. When used with ``yield`` in a coroutine, this is a non-blocking analogue to `time.sleep` (which should not be used in coroutines because it is blocking):: yield gen.sleep(0.5) Note that calling this function on its own does nothing; you must wait on the `.Future` it returns (usually by yielding it). .. versionadded:: 4.1 c$tdSrF)r )rCsr'rSzsleep..s#$7888{{}}V!DLLLU# $ & & # %55545 5"& $&*hnnS&9&9G!$GGGG"&(--"6"6%v.$(DM".DK6*,Ea,H,H*.D&FFF!DLLL!$(DM".DK'(:CLNNKKK)-D& !DLLL ((11!DLLL]. `!DL s4F+F+A0-B 0 B:B<B BB C BCB20C2B55CF+F$.inner8s" TX&&&&&r&T)rr?r.rr r]r^momentr add_callbackr`rVr\rrr)rnrbrs` r'rzRunner.handle_yield*s  =)'22DKK = = = ((DK  S\^^ < < < < < = ;& L % %dlDH = = =5 [ /00 0!!##  ' ' ' ' ' ' ' ' L # #DK 7 7 75tsAAAtypr5tbc|jsN|jsGt|_t |j|||f||jdSdS)NTF)rrrr?r r`rV)rnrr5rs r'handle_exceptionzRunner.handle_exceptionAsY| DM  ((DK  c5"-= > > > LL " " "45r&r)r"r#r$rpr _YieldablermrVrrrr\types TracebackTyperr%r&r'rYrYs##.#$ # " #  ####$8!8!8!8!tJ4.  ? +4 :?:M        r&rY awaitablectj|}tj||fd|S)Nc.|SrF)_unregister_task)rCloops r'rSz!_wrap_awaitable..VsD$9$9!$<$<r&)r ensure_futurer r_register_taskrZ)rrrs @r'_wrap_awaitablerMsY   * *C >  D<<<<=== Jr&rbcN| |turtS|turtSt|ttfrt |St |rtjt|St|rt|Std|)a?Convert a yielded object into a `.Future`. The default implementation accepts lists, dictionaries, and Futures. This has the side effect of starting any coroutines that did not start themselves, similar to `asyncio.ensure_future`. If the `~functools.singledispatch` library is available, this function may be extended to support additional types. For example:: @convert_yielded.register(asyncio.Future) def _(asyncio_future): return tornado.platform.asyncio.to_tornado_future(asyncio_future) .. versionadded:: 4.1 Nzyielded unknown object ) rrrWr~rrrrcastrrrr.)rbs r'rrZs"'V++ L  GdD\ * *CW~~ 7  C{67+++ W  Cw'''AgAABBBr&)r%)Qrprrrcollections.abcrconcurrent.futures concurrentdatetimerdrinspectrr]rtornado.concurrentrrrr r r tornado.ioloopr tornado.logr tornado.utilrrT ImportErrorrrrrrrrrrrrr TYPE_CHECKINGrrrrTypeVarrrrr\r r*r,r.r0r[r9rBrGrLrrir2rsrMultirrfloat timedeltarrrrrrrYrrr%r&r'rs#==~%%%%%%$$$$$$ "!!!!!%%%%%%KKK                            6555555555555V^D )T)_d3 >&:J!? C         Xc2g&s#" & 1 2&  &&& &  JHS"W%J(3D*EJJJ J] 78(37:KK L]  ]]]]@999999Y2}}}}}}}}DOQ0E0EHZ('#z/*BBC0EK0E)0E0E0E0Ef  OQ<<HZ('#z/*BBC<K<)<<<<~CF0OQNN 5(,, -N NLN NNNNb E n    *.v{6;;==11 V[[]] + +&uuuuuuuup y V    CZCFCCCC>!.11sAA'&A'