codekingpro/portable-devtools
114k
1�
2 ��j� � 3 � � S r SSKrSSKrSSKrSSKJr SSKrSSKrSSK r SSK J4r5 SSK J r SSK
r
SSKrSSKJrJrJrJrJrJr SSKJr SSKJr SS KJr SSK r SSK r SS6K J r J r J!r!J"r"J#r#J$r$J%r%J&r&J'r'J(r(J)r) \ RT ( a SS K J+r+J,r,J-r-J.r. \ R^ " S 5 r0\ S\&\#\& \'\!\&4 \Rb R 4 r2 " S
S\35 r4 " S S\35 r5 " S S\35 r6 " S S\35 r7 " S S\35 r8S\ \9S4 S\!4S jr:S\4S jr;S \"S \04 S \!S \!S\04S jr<\)S!\"S" S\"S# 4S$ j5 r=\)S!\"S \04 S\"S# 4S% j5 r=S!\ \"S" \"S \04 4 S\"S# 4S& jr=S!\!S\>4S' jr? " S( S\35 r@ " S) S*5 rA\) SDS+\(\2 S,\ \$\3 \%\$\3 S 4 4 S\\# 4S- jj5 rB\) SDS+\ \!\24 S,\ \$\3 \%\$\3 S 4 4 S\\' 4S. jj5 rB SDS+\ \(\2 \ \!\24 4 S,S/SS04S1 jjrB\BrC SDS+\ \(\2 \ \!\24 4 S,S/SS04S2 jjrDS3\!S\4S4 jrE SDS5\ \F\R� 4 S6\2S,S/S\4S7 jjrHS8\FSS94S: jrI " S; S<5 rJ\ R� " \\J" 5 5 rL\ R� " \\J" 5 5 rMS=\Ml " S> S?5 rNS@\&S\4SA jrOSB\2S\4SC jrP\7" \P5 rPg! \ a Sr GN`f = f)Ea* ``tornado.gen`` implements generator-based coroutines.8 9.. note::10 11 The "decorator and generator" approach in this module is a12 precursor to native coroutines (using ``async def`` and ``await``)13 which were introduced in Python 3.5. Applications that do not14 require compatibility with older versions of Python should use15 native coroutines instead. Some parts of this module are still16 useful with native coroutines, notably `multi`, `sleep`,17 `WaitIterator`, and `with_timeout`. Some of these functions have18 counterparts in the `asyncio` module which may be used as well,19 although the two may not necessarily be 100% compatible.20 21Coroutines provide an easier way to work in an asynchronous22environment than chaining callbacks. Code using coroutines is23technically asynchronous, but it is written as a single generator24instead of a collection of separate functions.25 26For example, here's a coroutine-based handler:27 28.. testcode::29 30 class GenAsyncHandler(RequestHandler):31 @gen.coroutine32 def get(self):33 http_client = AsyncHTTPClient()34 response = yield http_client.fetch("http://example.com")35 do_something_with_response(response)36 self.render("template.html")37 38Asynchronous functions in Tornado return an ``Awaitable`` or `.Future`;39yielding this object returns its result.40 41You can also yield a list or dict of other yieldable objects, which42will be started at the same time and run in parallel; a list or dict43of results will be returned when they are all finished:44 45.. testcode::46 47 @gen.coroutine48 def get(self):49 http_client = AsyncHTTPClient()50 response1, response2 = yield [http_client.fetch(url1),51 http_client.fetch(url2)]52 response_dict = yield dict(response3=http_client.fetch(url3),53 response4=http_client.fetch(url4))54 response3 = response_dict['response3']55 response4 = response_dict['response4']56 57If ``tornado.platform.twisted`` is imported, it is also possible to58yield Twisted's ``Deferred`` objects. See the `convert_yielded`59function to extend this mechanism.60 61.. versionchanged:: 3.262 Dict support added.63 64.. versionchanged:: 4.165 Support added for yielding ``asyncio`` Futures and Twisted Deferreds66 via ``singledispatch``.67 68� N)� Generator)�singledispatch)� isawaitable)�Future� is_future� chain_future�future_set_exc_info�future_add_done_callback�"future_set_result_unless_cancelled)�IOLoop)�app_log)� TimeoutError) �Mapping�Union�Any�Callable�List�Type�Tuple� Awaitable�Dict�Sequence�overload)�Deque�Optional�Set�Iterable�_Tc � � \ rS rSrSrg)�
KeyReuseError�v � N��__name__�69__module__� __qualname__�__firstlineno__�__static_attributes__r" � �QD:\code\apps\devtools\python\user_packages\Python313\site-packages\tornado/gen.pyr r v � � �r) r c � � \ rS rSrSrg)�UnknownKeyError�z r" Nr# r" r) r* r- r- z r+ r) r- c � � \ rS rSrSrg)�LeakedCallbackError�~ r" Nr# r" r) r* r0 r0 ~ r+ r) r0 c � � \ rS rSrSrg)�
BadYieldError� r" Nr# r" r) r* r3 r3 � r+ r) r3 c � � \ rS rSrSrg)�ReturnValueIgnoredError� r" Nr# r" r) r* r6 r6 � r+ r) r6 �e�Return�returnc � � U R $ ! [ a Of = f U R S $ ! [ [ 4 a g f = f)Nr )�value�AttributeError�args�70IndexError)r8 s r* �_value_from_stopiterationr@ � sP � �
� �w�w��� �
� �
��� �v�v�a�y��� �J� '� ���s � �71��. �A� Ac � � [ 5 n [ U SS5 nU( a" US S nU[ :X a US O U $ U( a M" U $ )N�_source_tracebackr" �����r )r �getattr�__file__)�future�source_traceback�filenames r* �_create_futurerI � sT � �
�X�F� �v�':�B�?��72� $�B�'��*�� �x� � ��$� � �M� �73� �Mr) �f.r> �kwc � � U " U0 UD6$ �Nr" )rJ r> rK s r* �
_fake_ctx_runrN � s � � �d�>�b�>�r) �func).zGenerator[Any, Any, _T]).�74Future[_T]c � � g rM r" �rO s r* � coroutinerS � s � � #&r) c � � g rM r" rR s r* rS rS � s � �GJr) c �b ^ � [ R " T 5 U 4S j5 nT Ul SUl U$ )a� Decorator for asynchronous generators.75 76For compatibility with older versions of Python, coroutines may77also "return" by raising the special exception `Return(value)78<Return>`.79 80Functions with this decorator return a `.Future`.81 82.. warning::83 84 When exceptions occur inside a coroutine, the exception85 information will be stored in the `.Future` object. You must86 examine the result of the `.Future` object, or the exception87 may go unnoticed by your code. This means yielding the function88 if called from another coroutine, using something like89 `.IOLoop.run_sync` for top-level calls, or passing the `.Future`90 to `.IOLoop.add_future`.91 92.. versionchanged:: 6.093 94 The ``callback`` argument was removed. Use the returned95 awaitable object instead.96 97c �� >^� [ 5 n[ b [ R " 5 R nO[ n U" T/U Q70 UD6n[ U[ 5 ( a6 U" [ U5 n[ X4X%5 mUR U4S j5 S n US n$ [ X$5 U$ ! [ [ 4 a n[ U[ U5 5 S nAN?S nAf[ a" [ U[ R" " 5 5 Nmf = f! S nf = f! [ [ 4 a n[ U5 n S nAN�S nAf[ a. [ U[ R" " 5 5 US ns $ ! S nf = ff = f)Nc � >� T$ rM r" )�_�runners �r* �<lambda>�,coroutine.<locals>.wrapper.<locals>.<lambda> s �� �vr) )rI � contextvars� copy_context�runrN �98isinstancer �next�Runner�add_done_callback�
StopIterationr9 r r@ � Exceptionr �sys�exc_info) r> �kwargsrF �ctx_run�result�yieldedr8 rY rO s @�r* �wrapper�coroutine.<locals>.wrapper� sM �� �99 �!�� � "�!�.�.�0�4�4�G�#�G�1 "� �T�3�D�3�F�3�F� �&�)�,�,� ?� %�d�F� 3�G� $�G�V� E�F��,�,�-=�>� �� "�!� "�F�K -�L +�6�:��
��? &�v�.� �6� � 9�!� <�� �� !� @�'��� � ��?�@��2 "�F��_ �
�&� 2�.�q�1�F��� � ��� � �� 7�
� � ������
�sY � D �
B �C< � C9�0C100�101,C9�8C9�<D �E � D#�#,E �E�E �E�E T)� functools�wraps� __wrapped__�__tornado_coroutine__)rO rk s ` r* rS rS � s8 �� �8 �_�_�T��<� �<�| �G��$(�G�!� �Nr) c � � [ U SS5 $ )zvReturn whether *func* is a coroutine function, i.e. a function102wrapped with `~.gen.coroutine`.103 104.. versionadded:: 4.5105rp F)rD rR s r* �is_coroutine_functionrr s � � �4�0�%� 8�8r) c �< ^ � \ rS rSrSrSS\SS4U 4S jjjrSrU =r$ ) r9 i a� Special exception to return a value from a `coroutine`.106 107This exception exists for compatibility with older versions of108Python (before 3.3). In newer code use the ``return`` statement109instead.110 111If this exception is raised, its value argument is used as the112result of the coroutine::113 114 @gen.coroutine115 def fetch_json(url):116 response = yield AsyncHTTPClient().fetch(url)117 raise gen.Return(json_decode(response.body))118 119By analogy with the return statement, the value argument is optional.120Nr< r: c �> >� [ TU ] 5 Xl U4U l g rM )�super�__init__r< r> )�selfr< � __class__s �r* rv �Return.__init__1 s �� �
�����121��H�� r) )r> r< rM ) r$ r% r& r' �__doc__r rv r( �
__classcell__)rx s @r* r9 r9 s �� ��" �c� �T� � r) c � � \ rS rSrSr0 rS\S\SS4S jrS\4S jr S\4S jr122S123\SS4S jr S124\S\4S jr S\
R 4S
jrS\4S jrSrg)� WaitIteratori8 a Provides an iterator to yield the results of awaitables as they finish.125 126Yielding a set of awaitables like this:127 128``results = yield [awaitable1, awaitable2]``129 130pauses the coroutine until both ``awaitable1`` and ``awaitable2``131return, and then restarts the coroutine with the results of both132awaitables. If either awaitable raises an exception, the133expression will raise that exception and all the results will be134lost.135 136If you need to get the result of each awaitable as soon as possible,137or if you need the result of some awaitables even if others produce138errors, you can use ``WaitIterator``::139 140 wait_iterator = gen.WaitIterator(awaitable1, awaitable2)141 while not wait_iterator.done():142 try:143 result = yield wait_iterator.next()144 except Exception as e:145 print("Error {} from {}".format(e, wait_iterator.current_future))146 else:147 print("Result {} received from {} at {}".format(148 result, wait_iterator.current_future,149 wait_iterator.current_index))150 151Because results are returned as soon as they are available the152output from the iterator *will not be in the same order as the153input arguments*. If you need to know which future produced the154current result, you can use the attributes155``WaitIterator.current_future``, or ``WaitIterator.current_index``156to get the index of the awaitable from the input list. (if keyword157arguments were used in the construction of the `WaitIterator`,158``current_index`` will use the corresponding keyword).159 160`WaitIterator` implements the async iterator161protocol, so it can be used with the ``async for`` statement (note162that in this version the entire iteration is aborted if any value163raises an exception, while the previous example can continue past164individual errors)::165 166 async for result in gen.WaitIterator(future1, future2):167 print("Result {} received from {} at {}".format(168 result, wait_iterator.current_future,169 wait_iterator.current_index))170 171.. versionadded:: 4.1172 173.. versionchanged:: 4.3174 Added ``async for`` support in Python 3.5.175 176r> rg r: Nc �� � U( a U( a [ S5 eU( aD UR 5 VVs0 s H u p4XC_M snnU l [ UR 5 5 nO'[ U5 VVs0 s H u pdXF_M snnU l Un[ R " 5 U l S U l S U l177 S U l U H n[ XpR 5 M g s snnf s snnf )Nz)You must provide args or kwargs, not both)�178ValueError�items� _unfinished�list�values� enumerate� collections�deque� _finished�
current_index�current_future�_running_futurer179 �_done_callback)rw r> rg �krJ �futures�irF s r* rv �WaitIterator.__init__q s� � � �F� � H�I� I� �39�<�<�>� B�>��!���>� B�D� ��6�=�=�?�+�G�3<�T�?� C�?��!���?� C�D� ��G�$�*�*�,��� !��� "��� #�� � �F� $�V�-@�-@� A� �� C�� Ds �C�3C c �f � U R ( d U R ( a gS=U l U l g)z2Returns True if this iterator has no more results.FNT)r� r� r� r� �rw s r* �done�WaitIterator.done� s' � � �>�>�T� -� -��37�7���T� 0�r) c � � [ 5 U l U R ( a) U R U R R 5 5 $ U R $ )z�Returns a `.Future` that will yield the next available result.180 181Note that this `.Future` will not be the same object as any of182the inputs.183)r r� r� �_return_result�popleftr� s r* r` �WaitIterator.next� s? � � &�x�� � �>�>��&�&�t�~�~�'=�'=�'?�@� @��#�#�#r) r� c � � U R ( a1 U R R 5 ( d U R U5 g U R R U5 g rM )r� r� r� r� �append)rw r� s r* r� �WaitIterator._done_callback� s? � � � � ��(<�(<�(A�(A�(C�(C� � � �� %� �N�N� !� !�$� 'r) c �� � U R c [ S5 e[ XR 5 U R nSU l Xl U R R U5 U l U$ )zsCalled set the returned future's state that of the future184we yielded, and set the current future for the iterator.185Nzno future is running)r� rd r r� r� �popr� )rw r� �ress r* r� �WaitIterator._return_result� sa � � � � � '�� 2�3� 3��T�/�/�0��"�"�� #�� � "�� !� -� -� 1� 1�$� 7����186r) c � � U $ rM r" r� s r* � __aiter__�WaitIterator.__aiter__� s � �� r) c �v � U R 5 ( a [ [ S5 " 5 eU R 5 $ )N�StopAsyncIteration)r� rD �builtinsr` r� s r* � __anext__�WaitIterator.__anext__� s* � � �9�9�;�;��(�$8�9�;� ;��y�y�{�r) )r� r� r� r� r� )r$ r% r& r' rz r� r rv �boolr� r` r� r� �typing�
AsyncIteratorr� r� r( r" r) r* r} r} 8 s� � �4�l �K�B�f� B�� B�4� B�&�d� � $�f� $�(�6� (�d� (�
�6�
�f�
� �6�/�/� ��6� r) r} �children�quiet_exceptionsc � � g rM r" �r� r� s r* �multir� � � � � r) c � � g rM r" r� s r* r� r� � r� r) z3Union[Type[Exception], Tuple[Type[Exception], ...]]z!Union[Future[List], Future[Dict]]c � � [ XS9$ )a� Runs multiple asynchronous operations in parallel.187 188``children`` may either be a list or a dict whose values are189yieldable objects. ``multi()`` returns a new yieldable190object that resolves to a parallel structure containing their191results. If ``children`` is a list, the result is a list of192results in the same order; if it is a dict, the result is a dict193with the same keys.194 195That is, ``results = yield multi(list_of_futures)`` is equivalent196to::197 198 results = []199 for future in list_of_futures:200 results.append(yield future)201 202If any children raise exceptions, ``multi()`` will raise the first203one. All others will be logged, unless they are of types204contained in the ``quiet_exceptions`` argument.205 206In a ``yield``-based coroutine, it is not normally necessary to207call this function directly, since the coroutine runner will208do it automatically when a list or dict is yielded. However,209it is necessary in ``await``-based coroutines, or to pass210the ``quiet_exceptions`` argument.211 212This function is available under the names ``multi()`` and ``Multi()``213for historical reasons.214 215Cancelling a `.Future` returned by ``multi()`` does not cancel its216children. `asyncio.gather` is similar to ``multi()``, but it does217cancel its children.218 219.. versionchanged:: 4.2220 If multiple yieldables fail, any exceptions after the first221 (which is raised) will be logged. Added the ``quiet_exceptions``222 argument to suppress this logging for selected exception types.223 224.. versionchanged:: 4.3225 Replaced the class ``Multi`` and the function ``multi_future``226 with a unified function ``multi``. Added support for yieldables227 other than ``YieldPoint`` and `.Future`.228 229)r� )� multi_futurer� s r* r� r� � s � �` �� D�Dr) c �� ^^^^^ � [ U [ 5 ( a* [ U R 5 5 mU R 5 nOSmU n[ [ [ U5 5 m[ S T 5 5 ( d e[ T5 m [ 5 mT( d [ TTb 0 O/ 5 S[ SS4UUUUU 4S jjn[ 5 nT H& nXT; d M230 UR U5 [ XS5 M( T$ )a� Wait for multiple asynchronous futures in parallel.231 232Since Tornado 6.0, this function is exactly the same as `multi`.233 234.. versionadded:: 4.0235 236.. versionchanged:: 4.2237 If multiple ``Futures`` fail, any exceptions after the first (which is238 raised) will be logged. Added the ``quiet_exceptions``239 argument to suppress this logging for selected exception types.240 241.. deprecated:: 4.3242 Use `multi` instead.243Nc 3 �f # � U H' n[ U5 =( d [ U[ 5 v � M) g 7frM )r r_ � _NullFuture)�.0r� s r* � <genexpr>� multi_future.<locals>.<genexpr> s# � � �Q�=�a�y��|�9�z�!�[� 9�9�=�s �/1�futr: c � >� TR U 5 T( dq / nT H# n UR UR 5 5 M% TR 5 ( d0 Tb [ T[ [ TU5 5 5 g [ TU5 g g g ! [ aq nTR 5 ( a2 [ UT5 ( d [ R " SSS9 S nAM� S nAM� [ T[ R " 5 5 S nAM� S nAff = f)Nz!Multiple exceptions in yield listT�rf )�remover� ri rd r� r_ r
�errorr re rf r �dict�zip) r� � result_listrJ r8 �
children_futsrF �keysr� �unfinished_childrens �����r* �callback� multi_future.<locals>.callback s� �� ��"�"�3�'�"� �K�"�� D� �&�&�q�x�x�z�2� #� �;�;�=�=��#�6� ��S��{�%;� <�� 7�v�{�K�
!� #��244 !� D� �{�{�}�}� )�!�-=� >� >� #�M�M� C�d� � � ?�245 ,�F�C�L�L�N�C�C��D�s � B � 246D�;D� D�D)r_ r� r� r� r� �map�convert_yielded�all�setrI r r �addr247 )248r� r� � children_seqr� � listeningrJ r� rF r� r� s249 ` @@@@r* r� r� � s� �� �$ �(�D�!�!��H�M�M�O�$�� ���(� ��� � ���_�l�;�<�M� �Q�=�Q� Q� Q�Q� Q� �m�,��
�
�F� �*�6��9I�2�r�R�L�f� L�� L� L�. ��I�
�� � � �M�M�!� � $�Q� 1� � �Mr) �xc �` � [ U 5 ( a U $ [ 5 nUR U 5 U$ )a� Converts ``x`` into a `.Future`.250 251If ``x`` is already a `.Future`, it is simply returned; otherwise252it is wrapped in a new `.Future`. This is suitable for use as253``result = yield gen.maybe_future(f())`` when you don't know whether254``f()`` returns a `.Future` or not.255 256.. deprecated:: 4.3257 This function only handles ``Futures``, not other yieldable objects.258 Instead of `maybe_future`, check for the non-future result types259 you expect (often just ``None``), and ``yield`` anything unknown.260)r rI �261set_result)r� r� s r* � maybe_futurer� ; s+ � � ��|�|��� � �� ���q���262r) �timeoutrF c �R ^^^^^^� [ U5 m[ 5 m[ TT5 [ R " 5 mS[263 SS4U4S jjmSUUU4S jjnTR
X5 m[ T[264 5 ( a [ TUU4S j5 T$ TR TUU4S j5 T$ ) a| Wraps a `.Future` (or other yieldable object) in a timeout.265 266Raises `tornado.util.TimeoutError` if the input future does not267complete before ``timeout``, which may be specified in any form268allowed by `.IOLoop.add_timeout` (i.e. a `datetime.timedelta` or269an absolute time relative to `.IOLoop.time`)270 271If the wrapped `.Future` fails after it has timed out, the exception272will be logged unless it is either of a type contained in273``quiet_exceptions`` (which may be an exception type or a sequence of274types), or an ``asyncio.CancelledError``.275 276The wrapped `.Future` is not canceled when the timeout expires,277permitting it to be reused. `asyncio.wait_for` is similar to this278function but it does cancel the wrapped `.Future` on timeout.279 280.. versionadded:: 4.0281 282.. versionchanged:: 4.1283 Added the ``quiet_exceptions`` argument and the logging of unhandled284 exceptions.285 286.. versionchanged:: 4.4287 Added support for yieldable objects other than `.Future`.288 289.. versionchanged:: 6.0.3290 ``asyncio.CancelledError`` is now always considered "quiet".291 292.. versionchanged:: 6.2293 ``tornado.util.TimeoutError`` is now an alias to ``asyncio.TimeoutError``.294 295rF r: Nc �� >� U R 5 g ! [ R a g [ a6 n[ UT5 ( d [296 R " SU SS9 S nAg S nAg S nAff = f)Nz$Exception in Future %r after timeoutTr� )ri �asyncio�CancelledErrorrd r_ r
r� )rF r8 r� s �r* �error_callback�$with_timeout.<locals>.error_callback sX �� � � �M�M�O���%�%� � �� � �a�!1�2�2��
�
�:�F�T�� 3�� �s � �A)� A)�'A$�$A)c �| >� TR 5 ( d TR [ S5 5 [ TT 5 g )N�Timeout)r� �
set_exceptionr r297 )r� �future_convertedri s ���r* �timeout_callback�&with_timeout.<locals>.timeout_callback� s, �� ��{�{�}�}� � � � �i�!8� 9� �!1�>�Br) c �& >� TR T5 $ rM ��remove_timeout�rF �io_loop�timeout_handles ��r* rZ � with_timeout.<locals>.<lambda>� � �� �W�-C�-C�N�-Sr) c �& >� TR T5 $ rM r� r� s ��r* rZ r� � r� r) �r: N)298r� rI r r �currentr � add_timeoutr_ r299 �300add_future) r� rF r� r� r� r� r� ri r� s ` @@@@@r* � with_timeoutr� P s� �� �T '�v�.��
�
�F��!�6�*��n�n� �G� �v� �$� �C� C� �(�(��C�N��"�F�+�+� !� � S� 301� �M� ��� � S� 302� �Mr) �durationz Future[None]c �n ^� [ 5 m[ R " 5 R U U4S j5 T$ )a� Return a `.Future` that resolves after the given number of seconds.303 304When used with ``yield`` in a coroutine, this is a non-blocking305analogue to `time.sleep` (which should not be used in coroutines306because it is blocking)::307 308 yield gen.sleep(0.5)309 310Note that calling this function on its own does nothing; you must311wait on the `.Future` it returns (usually by yielding it).312 313.. versionadded:: 4.1314c � >� [ T S 5 $ rM )r )rJ s �r* rZ �sleep.<locals>.<lambda>� s
�� �<�Q��Er) )rI r r� �315call_later)r� rJ s @r* �sleepr� � s/ �� � ��A�316�N�N�� � ��E��
�Hr) c �0 � \ rS rSrSrSS jrS\4S jrSrg) r� i� a� _NullFuture resembles a Future that finished with a result of None.317 318It's not actually a `Future` to avoid depending on a particular event loop.319Handled as a special case in the coroutine runner.320 321We lie and tell the type checker that a _NullFuture is a Future so322we don't have to leak _NullFuture into lots of public APIs. But323this means that the type checker can't warn us when we're passing324a _NullFuture into a code path that doesn't understand what to do325with it.326r: Nc � � g rM r" r� s r* ri �_NullFuture.result� � � �r) c � � g)NTr" r� s r* r� �_NullFuture.done� r� r) r" r� ) r$ r% r& r' rz ri r� r� r( r" r) r* r� r� � s � �327���d� r) r� a� A special object which may be yielded to allow the IOLoop to run for328one iteration.329 330This is not needed in normal use but it can be helpful in long-running331coroutines that are likely to yield Futures that are ready instantly.332 333Usage: ``yield gen.moment``334 335In native coroutines, the equivalent of ``yield gen.moment`` is336``await asyncio.sleep(0)``.337 338.. versionadded:: 4.0339 340.. deprecated:: 4.5341 ``yield None`` (or ``yield`` with no argument) is now equivalent to342 ``yield gen.moment``.343c 344 � � \ rS rSrSrS\SSSSS\S S3454346S jrSS jrS
\S \ 4S jr347S\ \ S\ S\
R S \ 4S jrSrg348)ra i� z�Internal implementation of `tornado.gen.coroutine`.349 350Maintains information about pending callbacks and their results.351 352The results of the generator are stored in ``result_future`` (a353`.Future`)354rh �genz Generator[_Yieldable, Any, _T]�
result_futurerP �
first_yieldedr: Nc � � Xl X l X0l [ U l SU l SU l [ R " 5 U l U R U R U5 ( a! S =n=p4U R U R 5 g g )NF) rh r� r� � _null_futurerF �running�finishedr r� r� � handle_yieldr^ )rw rh r� r� r� s r* rv �Runner.__init__� sp � � � ��� *��"�� � �� � ��
� �~�~�'�� � �<�<��)�)�=� 9� 9�26� 6�C� 6�-� �L�L���� "� :r) c � � U R ( d U R ( a g SU l U R nUc [ S5 eUR 5 ( d SU l gSU l UR 5 nSnSnUb U R R U5 nAO U R R W5 n U R% U5 ( d SU l gSnM� ! [ a nUn SnANsSnAff = f! Snf = f! Af = f! [ [ 4 aI nSU l [ U l [ U R [ U5 5 SU l
SnASU l gSnAf[ aL SU l [ U l [ U R [ R" " 5 5 SU l
SU l gf = f! SU l f = f)z[Starts or resumes the generator, running until it reaches a355yield point that is not ready.356NTzNo pending futureF)r� r� rF rd r� ri r� �throw�sendrc r9 r� r r� r@ r re rf r )rw rF r< �excr8 rj s r* r^ �357Runner.run� s� � � �<�<�4�=�=� �2 !� �D�L�� �����>�#�$7�8�8� �{�{�}�}��V !�D�L�U #�� �$�358&� &�
�
��� #��!%����$�&*�h�h�n�n�S�&9�G� !$�"&�(�(�-�-��"6�� �(�(��1�1�� !�D�L� ��] �� %� 5� 45��� 5�� "&��� !$�� &�v�.� �$(�D�M�".�D�K�6� �*�*�,E�a�,H�� *.�D�&�� !�D�L�� !� �$(�D�M�".�D�K�'��(:�(:�C�L�L�N�K�)-�D�&��359 !�D�L��� !�D�L�s� �7F8 �%F8 �.C" �>C; � D �D �!D �"F8 �#D �>F8 � F8 �"360C8�,C3�.C; �3C8�8C; �;C?�?D �D�D �F5�8E �F8 � AF5�+F8 �4F5�5F8 �8 Grj c � ^ � [ U5 T l T R [ L a1 T R R T R T R 5 gT R c [ S5 eT R R 5 ( d7 S[ SS 4U 4S jjnT R R T R U5 gg! [ a; [ 5 T l [ T R [361 R " 5 5 N�f = f)NFzno pending futurerJ r: c �@ >� S n TR TR 5 g rM )rh r^ )rJ rw s �r* �inner�"Runner.handle_yield.<locals>.innerF s �� ���� � �T�X�X�&r) T)r� rF r3 r r re rf �momentr� � add_callbackrh r^ rd r� r r� )rw rj r s ` r* r �Runner.handle_yield8 s� �� � =�)�'�2�D�K�362 �;�;�&� � �L�L� %� %�d�l�l�D�H�H� =��
�[�[�
�� /�0� 0����!�!�#�#�
'��
'��
'�363
�L�L� #� #�D�K�K�� 7����% � =� �(�D�K� �� � �S�\�\�^� <� =�s �C �AD �364D �typr< �tbc �� � U R ( dT U R ( dC [ 5 U l [ U R XU45 U R U R 5 gg)NTF)r� r� r rF r rh r^ )rw r r< r s r* �handle_exception�Runner.handle_exceptionO sC � � �|�|�D�M�M� �(�D�K� �� � �c�"�-=� >� �L�L���� "��r) )rh r� rF r� r� r� r� r� )r$ r% r& r' rz r �365_Yieldablerv r^ r� r r rd �types�
TracebackTyper r( r" r) r* ra ra � s� � ��#��#� .�#� $� #�366 "� #� 367�
#�$8!�t�J� �4� �. �� �?� �+4� �:?�:M�:M� �
� r) ra � awaitablec � ^� [ R " U 5 n[ R " 5 mTR U5 UR U4S j5 U$ )Nc �& >� TR U 5 $ rM )�_unregister_task)rJ �loops �r* rZ �!_wrap_awaitable.<locals>.<lambda>d s �� �D�$9�$9�!�$<r) )r� �
ensure_futurer r� �_register_taskrb )r r� r s @r* �_wrap_awaitabler [ sC �� �368 �369 �370 � �371*�C� �>�>� �D����� ����<�=� �Jr) rj c �: � U b U [ L a [ $ U [ L a [ $ [ U [ [ 45 ( a [ U 5 $ [
U 5 ( a [ R " [ U 5 $ [ U 5 ( a [ U 5 $ [ SU < 35 e)a Convert a yielded object into a `.Future`.372 373The default implementation accepts lists, dictionaries, and374Futures. This has the side effect of starting any coroutines that375did not start themselves, similar to `asyncio.ensure_future`.376 377If the `~functools.singledispatch` library is available, this function378may be extended to support additional types. For example::379 380 @convert_yielded.register(asyncio.Future)381 def _(asyncio_future):382 return tornado.platform.asyncio.to_tornado_future(asyncio_future)383 384.. versionadded:: 4.1385 386zyielded unknown object )
r r� r_ r� r� r� r r� �castr r r r3 )rj s r* r� r� h s� � �" ��'�V�+��
� �L� ��� �G�d�D�\� *� *��W�~� � �7� � ��{�{�6�7�+�+� �W� � � �w�'�'�� 5�g�[� A�B�Br) )r" )Qrz r� r� r� �collections.abcr �concurrent.futures�387concurrent�datetimerm r �inspectr re r �tornado.concurrentr r r r r388 r �tornado.ioloopr � tornado.logr
� tornado.utilr r\ � ImportErrorr� r r r r r r r r r r r �
TYPE_CHECKINGr r r r �TypeVarr r� r rd r r- r0 r3 r6 rc r@ rI rN rS r� rr r9 r} r� �Multir� r� �float� timedeltar� r� r� r r� r ra r r� r" r) r* �<module>r0 s@ ��=�~ � � � %� � � � $� � 389� �� � "� � %��� � � � � � 390���5�5� �^�^�D���
��)�T�)�_�d�3� �>�&:�J�<N�<N�<U�<U�U��391�392 �I� � �i� � �)� � �I� � �i� � ��}�h�'>�!?� �C� � �� � �X�c�2�g�&� �s� �#� �"� � 393�&�394�1�3952�&�
� � �&� 396�&�397 398� J�H�S�"�W�%� J�(�3D�*E� J� 399� J�]�400��7�8�(�3��7�:K�K�401L�]�
� � �]�@9�� 9�� 9� �Y� �2}� }�@ 402� MO���z�"���D��O�U�4� �?�C�3G�-H� H�I�� �D�\�� 403�� 404� MO���c�:�o�&���D��O�U�4� �?�C�3G�-H� H�I�� �D�\�� 405�� OQ�0E��H�Z�(�'�#�z�/�*B�B�C�0E�K�0E� )�0E�f ��406 OQ�<��H�Z�(�'�#�z�/�*B�B�C�<�K�<� )�<�~�C� �F� �0 OQ�N�
�5�(�,�,�,�
-�N� �N� L�N� � N�b
�E�
�n�
�*� �. �{�{�6�;�=�1� � ���V�[�]� +�����&u� u�p407�y� 408�V� 409� C�Z� C�F� C�> !� �1���[ � ��K��s �J1 �1J=�<J=