ó ¨œž[c@`sÇdZddlmZmZmZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl m Z mZmZmZmZmZddlmZddlmZddlmZddlmZmZmZy<ydd lmZWn!ek r*dd lmZnXWn,ek rZd ejkrQ‚ndZnXytydd l!m"Z#Wn!ek r•dd l$m"Z#nXydd l%m&Z&Wn!ek rÍdd l$m&Z&nXWn?ek rd ejkrô‚ndd l m#Z#d„Z&nXer&ddl'Z'n ddl(Z'de)fd„ƒYZ*de)fd„ƒYZ+de)fd„ƒYZ,de)fd„ƒYZ-de)fd„ƒYZ.d„Z/d„Z0d„Z1d„Z2d„Z3d„Z4de)fd „ƒYZ5d!e6fd"„ƒYZ7d#e6fd$„ƒYZ8d%e8fd&„ƒYZ9d'e8fd(„ƒYZ:d)e8fd*„ƒYZ;d+„Z<d,e8fd-„ƒYZ=d.„Z>dBd/„Z?e?Z@d0e8fd1„ƒYZAdCd2„ZBd3„ZCdDd4„ZDd5„ZEd6e6fd7„ƒYZFeFƒZGeFƒZHd8eH_d9e6fd:„ƒYZIejJd;d<d=gƒZKd>„ZLyddlMZMWn ek rne2d?„ƒZNn1Xy eMjOZNWn ePk ržeQeMd@ƒZNnXdA„ZRedk rÃeeRƒZRndS(Es@ ``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, the following callback-based asynchronous handler: .. testcode:: class AsyncHandler(RequestHandler): @asynchronous def get(self): http_client = AsyncHTTPClient() http_client.fetch("http://example.com", callback=self.on_fetch) def on_fetch(self, response): do_something_with_response(response) self.render("template.html") .. testoutput:: :hide: could be written with ``gen`` as: .. 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") .. testoutput:: :hide: Most asynchronous functions in Tornado return a `.Future`; yielding this object returns its ``Future.result``. You can also yield a list or dict of ``Futures``, 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'] .. testoutput:: :hide: If the `~functools.singledispatch` library is available (standard in Python 3.4, available via the `singledispatch `_ package on older versions), additional types of objects may be yielded. Tornado includes support for ``asyncio.Future`` and Twisted's ``Deferred`` class when ``tornado.platform.asyncio`` and ``tornado.platform.twisted`` are imported. 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``. i(tabsolute_importtdivisiontprint_functionN(tFuturet is_futuret chain_futuretfuture_set_exc_infotfuture_add_done_callbackt"future_set_result_unless_cancelled(tIOLoop(tapp_log(t stack_context(tPY3traise_exc_infot TimeoutError(tsingledispatchtAPPENGINE_RUNTIME(t Generator(t isawaitable(t GeneratorTypecC`stS(N(tFalse(tx((s*lib/python2.7/site-packages/tornado/gen.pyRŽst KeyReuseErrorcB`seZRS((t__name__t __module__(((s*lib/python2.7/site-packages/tornado/gen.pyR—stUnknownKeyErrorcB`seZRS((RR(((s*lib/python2.7/site-packages/tornado/gen.pyR›stLeakedCallbackErrorcB`seZRS((RR(((s*lib/python2.7/site-packages/tornado/gen.pyRŸst BadYieldErrorcB`seZRS((RR(((s*lib/python2.7/site-packages/tornado/gen.pyR£stReturnValueIgnoredErrorcB`seZRS((RR(((s*lib/python2.7/site-packages/tornado/gen.pyR§scC`sMy |jSWntk rnXy|jdSWnttfk rHdSXdS(Ni(tvaluetAttributeErrortargst IndexErrortNone(te((s*lib/python2.7/site-packages/tornado/gen.pyt_value_from_stopiteration«s  cC`sQtƒ}t|ddƒ}x/|rL|dd}|tkrH|d=qPqW|S(Nt_source_tracebackiÿÿÿÿi((Rtgetattrt__file__(tfuturetsource_tracebacktfilename((s*lib/python2.7/site-packages/tornado/gen.pyt_create_futureºs    c`sDtjdtƒtˆdtƒ‰tjˆƒ‡fd†ƒ}|S(s<Callback-oriented decorator for asynchronous generators. This is an older interface; for new code that does not need to be compatible with versions of Tornado older than 3.0 the `coroutine` decorator is recommended instead. This decorator is similar to `coroutine`, except it does not return a `.Future` and the ``callback`` argument is not treated specially. In most cases, functions decorated with `engine` should take a ``callback`` argument and invoke it with their result when they are finished. One notable exception is the `~tornado.web.RequestHandler` :ref:`HTTP verb methods `, which use ``self.finish()`` in place of a callback argument. .. deprecated:: 5.1 This decorator will be removed in 6.0. Use `coroutine` or ``async def`` instead. s@gen.engine is deprecated, use gen.coroutine or async def insteadtreplace_callbackc`s2ˆ||Ž}d„}t|tj|ƒƒdS(NcS`s2|jƒdk r.td|jƒfƒ‚ndS(Ns.@gen.engine functions cannot return values: %r(tresultR!R(R'((s*lib/python2.7/site-packages/tornado/gen.pytfinal_callbackçs(RR twrap(RtkwargsR'R-(tfunc(s*lib/python2.7/site-packages/tornado/gen.pytwrapperãs (twarningstwarntDeprecationWarningt_make_coroutine_wrapperRt functoolstwraps(R0R1((R0s*lib/python2.7/site-packages/tornado/gen.pytengineÉs   cC`st|dtƒS(sPDecorator for asynchronous generators. Any generator that yields objects from this module must be wrapped in either this decorator or `engine`. Coroutines may "return" by raising the special exception `Return(value) `. In Python 3.3+, it is also possible for the function to simply use the ``return value`` statement (prior to Python 3.3 generators were not allowed to also return values). In all versions of Python a coroutine that simply wishes to exit early may use the ``return`` statement without a value. Functions with this decorator return a `.Future`. Additionally, they may be called with a ``callback`` keyword argument, which will be invoked with the future's result when it resolves. If the coroutine fails, the callback will not be run and an exception will be raised into the surrounding `.StackContext`. The ``callback`` argument is not visible inside the decorated function; it is handled by the decorator itself. .. 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`. .. deprecated:: 5.1 The ``callback`` argument is deprecated and will be removed in 6.0. Use the returned awaitable object instead. R+(R5tTrue(R0((s*lib/python2.7/site-packages/tornado/gen.pyt coroutineós$c`s^ˆ}ttdƒr'tjˆƒ‰ntj|ƒ‡‡fd†ƒ}||_t|_|S(sàThe inner workings of ``@gen.coroutine`` and ``@gen.engine``. The two decorators differ in their treatment of the ``callback`` argument, so we cannot simply implement ``@engine`` in terms of ``@coroutine``. R:c`s×tƒ}ˆrbd|krbtjdtddƒ|jdƒ‰tjƒj|‡fd†ƒnyˆ||Ž}WnZtt fk rœ}t |ƒ}n*t k rÑt |t jƒƒz|SWdd}XnõXt|tƒrÆyPtjj}t|ƒ}tjj|k r0tƒ}|jtjdƒƒnWnOt tfk r_}t|t |ƒƒnLt k r‚t |t jƒƒn)Xt|||ƒ‰|j‡fd†ƒd}z|SWdd}Xnt||ƒ|S(NtcallbacksBcallback arguments are deprecated, use the returned Future insteadt stacklevelic`sˆ|jƒƒS(N(R,(R'(R;(s*lib/python2.7/site-packages/tornado/gen.pyt0ssYstack_context inconsistency (probably caused by yield within a "with StackContext" block)c`sˆS(N((t_(trunner(s*lib/python2.7/site-packages/tornado/gen.pyR=[s(R*R2R3R4tpopR tcurrentt add_futuretReturnt StopIterationR#t ExceptionRtsystexc_infoR!t isinstanceRR t_statetcontextstnextt set_exceptiontStackContextInconsistentErrorRtRunnertadd_done_callback(RR/R'R,R"torig_stack_contextstyielded(R0R+(R;R?s*lib/python2.7/site-packages/tornado/gen.pyR1'sJ             (thasattrttypesR:R6R7t __wrapped__R9t__tornado_coroutine__(R0R+twrappedR1((R0R+s*lib/python2.7/site-packages/tornado/gen.pyR5s !E  cC`st|dtƒS(s‚Return whether *func* is a coroutine function, i.e. a function wrapped with `~.gen.coroutine`. .. versionadded:: 4.5 RU(R%R(R0((s*lib/python2.7/site-packages/tornado/gen.pytis_coroutine_functionqsRCcB`seZdZdd„ZRS(sõSpecial exception to return a value from a `coroutine`. 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)) In Python 3.3, this exception is no longer necessary: the ``return`` statement can be used directly to return a value (previously ``yield`` and ``return`` with a value could not be combined in the same function). By analogy with the return statement, the value argument is optional, but it is never necessary to ``raise gen.Return()``. The ``return`` statement can be used with no arguments instead. cC`s,tt|ƒjƒ||_|f|_dS(N(tsuperRCt__init__RR(tselfR((s*lib/python2.7/site-packages/tornado/gen.pyRYŽs N(RRt__doc__R!RY(((s*lib/python2.7/site-packages/tornado/gen.pyRCzst WaitIteratorcB`sMeZdZd„Zd„Zd„Zd„Zd„Zd„Zd„Z RS(s˜Provides an iterator to yield the results of futures as they finish. Yielding a set of futures like this: ``results = yield [future1, future2]`` pauses the coroutine until both ``future1`` and ``future2`` return, and then restarts the coroutine with the results of both futures. If either future is an exception, the expression will raise that exception and all the results will be lost. If you need to get the result of each future as soon as possible, or if you need the result of some futures even if others produce errors, you can use ``WaitIterator``:: wait_iterator = gen.WaitIterator(future1, future2) 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 future from the input list. (if keyword arguments were used in the construction of the `WaitIterator`, ``current_index`` will use the corresponding keyword). On Python 3.5, `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. cO`sÇ|r|rtdƒ‚n|rUtd„|jƒDƒƒ|_t|jƒƒ}n%td„t|ƒDƒƒ|_|}tjƒ|_ d|_ |_ d|_ x|D]}t||jƒq©WdS(Ns)You must provide args or kwargs, not bothcs`s!|]\}}||fVqdS(N((t.0tktf((s*lib/python2.7/site-packages/tornado/gen.pys Ðscs`s!|]\}}||fVqdS(N((R]tiR_((s*lib/python2.7/site-packages/tornado/gen.pys Ós(t ValueErrortdicttitemst _unfinishedtlisttvaluest enumeratet collectionstdequet _finishedR!t current_indextcurrent_futuret_running_futureRt_done_callback(RZRR/tfuturesR'((s*lib/python2.7/site-packages/tornado/gen.pyRYÊs    cC`s*|js|jrtSd|_|_tS(s2Returns True if this iterator has no more results.N(RjRdRR!RkRlR9(RZ((s*lib/python2.7/site-packages/tornado/gen.pytdoneÝscC`s5tƒ|_|jr.|j|jjƒƒn|jS(s£Returns a `.Future` that will yield the next available result. Note that this `.Future` will not be the same object as any of the inputs. (RRmRjt_return_resulttpopleft(RZ((s*lib/python2.7/site-packages/tornado/gen.pyRKås  cC`s=|jr)|jjƒ r)|j|ƒn|jj|ƒdS(N(RmRpRqRjtappend(RZRp((s*lib/python2.7/site-packages/tornado/gen.pyRnòscC`s2t||jƒ||_|jj|ƒ|_dS(sƒCalled set the returned future's state that of the future we yielded, and set the current future for the iterator. N(RRmRlRdR@Rk(RZRp((s*lib/python2.7/site-packages/tornado/gen.pyRqøs cC`s|S(N((RZ((s*lib/python2.7/site-packages/tornado/gen.pyt __aiter__scC`s+|jƒr!ttdƒƒ‚n|jƒS(NtStopAsyncIteration(RpR%tbuiltinsRK(RZ((s*lib/python2.7/site-packages/tornado/gen.pyt __anext__s ( RRR[RYRpRKRnRqRtRw(((s*lib/python2.7/site-packages/tornado/gen.pyR\•s4    t YieldPointcB`s2eZdZd„Zd„Zd„Zd„ZRS(sÄBase class for objects that may be yielded from the generator. .. deprecated:: 4.0 Use `Futures <.Future>` instead. This class and all its subclasses will be removed in 6.0 cC`stjdtƒdS(Ns-YieldPoint is deprecated, use Futures instead(R2R3R4(RZ((s*lib/python2.7/site-packages/tornado/gen.pyRYs cC`s tƒ‚dS(sˆCalled by the runner after the generator has yielded. No other methods will be called on this object before ``start``. N(tNotImplementedError(RZR?((s*lib/python2.7/site-packages/tornado/gen.pytstartscC`s tƒ‚dS(s…Called by the runner to determine whether to resume the generator. Returns a boolean; may be called more than once. N(Ry(RZ((s*lib/python2.7/site-packages/tornado/gen.pytis_readyscC`s tƒ‚dS(s¬Returns the value to use as the result of the yield expression. This method will only be called once, and only after `is_ready` has returned true. N(Ry(RZ((s*lib/python2.7/site-packages/tornado/gen.pyt get_result$s(RRR[RYRzR{R|(((s*lib/python2.7/site-packages/tornado/gen.pyRx s    tCallbackcB`s2eZdZd„Zd„Zd„Zd„ZRS(s„Returns a callable object that will allow a matching `Wait` to proceed. The key may be any value suitable for use as a dictionary key, and is used to match ``Callbacks`` to their corresponding ``Waits``. The key must be unique among outstanding callbacks within a single run of the generator function, but may be reused across different runs of the same function (so constants generally work fine). The callback may be called with zero or one arguments; if an argument is given it will be returned by `Wait`. .. deprecated:: 4.0 Use `Futures <.Future>` instead. This class will be removed in 6.0. cC`stjdtƒ||_dS(Ns/gen.Callback is deprecated, use Futures instead(R2R3R4tkey(RZR~((s*lib/python2.7/site-packages/tornado/gen.pyRY<s cC`s||_|j|jƒdS(N(R?tregister_callbackR~(RZR?((s*lib/python2.7/site-packages/tornado/gen.pyRzAs cC`stS(N(R9(RZ((s*lib/python2.7/site-packages/tornado/gen.pyR{EscC`s|jj|jƒS(N(R?tresult_callbackR~(RZ((s*lib/python2.7/site-packages/tornado/gen.pyR|Hs(RRR[RYRzR{R|(((s*lib/python2.7/site-packages/tornado/gen.pyR}-s    tWaitcB`s2eZdZd„Zd„Zd„Zd„ZRS(s¬Returns the argument passed to the result of a previous `Callback`. .. deprecated:: 4.0 Use `Futures <.Future>` instead. This class will be removed in 6.0. cC`stjdtƒ||_dS(Ns+gen.Wait is deprecated, use Futures instead(R2R3R4R~(RZR~((s*lib/python2.7/site-packages/tornado/gen.pyRYRs cC`s ||_dS(N(R?(RZR?((s*lib/python2.7/site-packages/tornado/gen.pyRzWscC`s|jj|jƒS(N(R?R{R~(RZ((s*lib/python2.7/site-packages/tornado/gen.pyR{ZscC`s|jj|jƒS(N(R?t pop_resultR~(RZ((s*lib/python2.7/site-packages/tornado/gen.pyR|]s(RRR[RYRzR{R|(((s*lib/python2.7/site-packages/tornado/gen.pyRLs    tWaitAllcB`s2eZdZd„Zd„Zd„Zd„ZRS(s[Returns the results of multiple previous `Callbacks `. The argument is a sequence of `Callback` keys, and the result is a list of results in the same order. `WaitAll` is equivalent to yielding a list of `Wait` objects. .. deprecated:: 4.0 Use `Futures <.Future>` instead. This class will be removed in 6.0. cC`stjdtƒ||_dS(Ns0gen.WaitAll is deprecated, use gen.multi instead(R2R3R4tkeys(RZR„((s*lib/python2.7/site-packages/tornado/gen.pyRYls cC`s ||_dS(N(R?(RZR?((s*lib/python2.7/site-packages/tornado/gen.pyRzqsc`st‡fd†ˆjDƒƒS(Nc3`s!|]}ˆjj|ƒVqdS(N(R?R{(R]R~(RZ(s*lib/python2.7/site-packages/tornado/gen.pys us(tallR„(RZ((RZs*lib/python2.7/site-packages/tornado/gen.pyR{tscC`s&g|jD]}|jj|ƒ^q S(N(R„R?R‚(RZR~((s*lib/python2.7/site-packages/tornado/gen.pyR|ws(RRR[RYRzR{R|(((s*lib/python2.7/site-packages/tornado/gen.pyRƒas     c `sjtjdtƒtƒ‰‡fd†}‡fd†}tj|ƒ|dt|ƒ||ŽWdQXˆS(sAAdapts a callback-based asynchronous function for use in coroutines. Takes a function (and optional additional arguments) and runs it with those arguments plus a ``callback`` keyword argument. The argument passed to the callback is returned as the result of the yield expression. .. versionchanged:: 4.0 ``gen.Task`` is now a function that returns a `.Future`, instead of a subclass of `YieldPoint`. It still behaves the same way when yielded. .. deprecated:: 5.1 This function is deprecated and will be removed in 6.0. s+gen.Task is deprecated, use Futures insteadc`s*ˆjƒrtStˆ|||fƒtS(N(RpRRR9(ttypRttb(R'(s*lib/python2.7/site-packages/tornado/gen.pythandle_exceptionŽs c`s!ˆjƒrdStˆ|ƒdS(N(RpR(R,(R'(s*lib/python2.7/site-packages/tornado/gen.pyt set_result”s R;N(R2R3R4R*R tExceptionStackContextt_argument_adapter(R0RR/RˆR‰((R's*lib/python2.7/site-packages/tornado/gen.pytTask{s  t YieldFuturecB`s,eZd„Zd„Zd„Zd„ZRS(cC`s,tjdtƒ||_tjƒ|_dS(sûAdapts a `.Future` to the `YieldPoint` interface. .. versionchanged:: 5.0 The ``io_loop`` argument (deprecated since version 4.1) has been removed. .. deprecated:: 5.1 This class will be removed in 6.0. s.YieldFuture is deprecated, use Futures insteadN(R2R3R4R'R RAtio_loop(RZR'((s*lib/python2.7/site-packages/tornado/gen.pyRYžs  cC`su|jjƒsY||_tƒ|_|j|jƒ|jj|j|j|jƒƒnd|_|jj |_ dS(N( R'RpR?tobjectR~RRŽRBR€R!R,t result_fn(RZR?((s*lib/python2.7/site-packages/tornado/gen.pyRz¬s  % cC`s*|jdk r"|jj|jƒStSdS(N(R?R!R{R~R9(RZ((s*lib/python2.7/site-packages/tornado/gen.pyR{¶scC`s6|jdk r(|jj|jƒjƒS|jƒSdS(N(R?R!R‚R~R,R(RZ((s*lib/python2.7/site-packages/tornado/gen.pyR|¼s(RRRYRzR{R|(((s*lib/python2.7/site-packages/tornado/gen.pyRs  cC`sPt|tƒr)td„|jƒDƒƒSt|tƒrLtd„|DƒƒStS(s›Returns True if ``children`` contains any YieldPoints. ``children`` may be a dict or a list, as used by `MultiYieldPoint` and `multi_future`. cs`s|]}t|tƒVqdS(N(RHRx(R]R`((s*lib/python2.7/site-packages/tornado/gen.pys Êscs`s|]}t|tƒVqdS(N(RHRx(R]R`((s*lib/python2.7/site-packages/tornado/gen.pys Ìs(RHRbtanyRfReR(tchildren((s*lib/python2.7/site-packages/tornado/gen.pyt_contains_yieldpointÃs cC`s0t|ƒrt|d|ƒSt|d|ƒSdS(sRuns 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. If any of the inputs are `YieldPoints `, the returned yieldable object is a `YieldPoint`. Otherwise, returns a `.Future`. This means that the result of `multi` can be used in a native coroutine if and only if all of its children can be. 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`. tquiet_exceptionsN(R“tMultiYieldPointt multi_future(R’R”((s*lib/python2.7/site-packages/tornado/gen.pytmultiÐs2 R•cB`s5eZdZdd„Zd„Zd„Zd„ZRS(sÍRuns multiple asynchronous operations in parallel. This class is similar to `multi`, but it always creates a stack context even when no children require it. It is not compatible with native coroutines. .. versionchanged:: 4.2 If multiple ``YieldPoints`` 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 Renamed from ``Multi`` to ``MultiYieldPoint``. The name ``Multi`` remains as an alias for the equivalent `multi` function. .. deprecated:: 4.3 Use `multi` instead. This class will be removed in 6.0. cC`sítjdtƒd|_t|tƒrLt|jƒƒ|_|jƒ}ng|_ xW|D]O}t|t ƒs€t |ƒ}nt |ƒr›t |ƒ}n|j j|ƒq\Wtd„|j DƒƒsÎt‚t|j ƒ|_||_dS(Ns2MultiYieldPoint is deprecated, use Futures insteadcs`s|]}t|tƒVqdS(N(RHRx(R]R`((s*lib/python2.7/site-packages/tornado/gen.pys ,s(R2R3R4R!R„RHRbReRfR’Rxtconvert_yieldedRRRsR…tAssertionErrortsettunfinished_childrenR”(RZR’R”R`((s*lib/python2.7/site-packages/tornado/gen.pyRYs      cC`s%x|jD]}|j|ƒq WdS(N(R’Rz(RZR?R`((s*lib/python2.7/site-packages/tornado/gen.pyRz0scC`s6ttjd„|jƒƒ}|jj|ƒ|j S(NcS`s |jƒS(N(R{(R`((s*lib/python2.7/site-packages/tornado/gen.pyR=6s(Ret itertoolst takewhileR›tdifference_update(RZtfinished((s*lib/python2.7/site-packages/tornado/gen.pyR{4s cC`sÜg}d}x|jD]v}y|j|jƒƒWqtk r‹}|dkr`tjƒ}qŒt||jƒsŒt j ddt ƒqŒqXqW|dk r©t |ƒn|j dk rÎtt|j |ƒƒSt|ƒSdS(Ns!Multiple exceptions in yield listRG(R!R’RsR|RERFRGRHR”R terrorR9R R„RbtzipRe(RZt result_listRGR_R"((s*lib/python2.7/site-packages/tornado/gen.pyR|:s     ((RRR[RYRzR{R|(((s*lib/python2.7/site-packages/tornado/gen.pyR• s    c`stˆtƒr0tˆjƒƒ‰ˆjƒ‰nd‰tttˆƒƒ‰td„ˆDƒƒsgt ‚t ˆƒ‰t ƒ‰ˆs¤t ˆˆdk ršingƒn‡‡‡‡‡fd†}t ƒ}x7ˆD]/}||krÏ|j |ƒt||ƒqÏqÏWˆS(s×Wait for multiple asynchronous futures in parallel. This function is similar to `multi`, but does not support `YieldPoints `. .. 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. cs`s*|] }t|ƒp!t|tƒVqdS(N(RRHt _NullFuture(R]R`((s*lib/python2.7/site-packages/tornado/gen.pys esc`sìˆj|ƒˆsèg}x‚ˆD]z}y|j|jƒƒWq tk r™}ˆjƒrƒt|ˆƒs–tjddtƒq–qšt ˆt j ƒƒq Xq Wˆjƒsèˆdk rÕt ˆttˆ|ƒƒƒqåt ˆ|ƒqèndS(Ns!Multiple exceptions in yield listRG(tremoveRsR,RERpRHR R R9RRFRGR!RRbR¡(R_R¢R"(R’R'R„R”R›(s*lib/python2.7/site-packages/tornado/gen.pyR;ms"       N(RHRbReR„RfR!tmapR˜R…R™RšR*RtaddR(R’R”R;t listeningR_((R’R'R„R”R›s*lib/python2.7/site-packages/tornado/gen.pyR–Os$      cC`s.t|ƒr|Stƒ}|j|ƒ|SdS(sConverts ``x`` into a `.Future`. If ``x`` is already a `.Future`, it is simply returned; otherwise it is wrapped in a new `.Future`. This is suitable for use as ``result = yield gen.maybe_future(f())`` when you don't know whether ``f()`` returns a `.Future` or not. .. deprecated:: 4.3 This function only handles ``Futures``, not other yieldable objects. Instead of `maybe_future`, check for the non-future result types you expect (often just ``None``), and ``yield`` anything unknown. N(RR*R‰(Rtfut((s*lib/python2.7/site-packages/tornado/gen.pyt maybe_futureŠs   c`s¯tˆƒ‰tƒ‰tˆˆƒtjƒ‰‡fd†‰‡‡‡fd†}ˆj||ƒ‰tˆtƒrtˆ‡‡fd†ƒnˆj ˆ‡‡fd†ƒˆS(sWraps a `.Future` (or other yieldable object) in a timeout. Raises `tornado.util.TimeoutError` if the input future does not complete before ``timeout``, which may be specified in any form allowed by `.IOLoop.add_timeout` (i.e. a `datetime.timedelta` or an absolute time relative to `.IOLoop.time`) If the wrapped `.Future` fails after it has timed out, the exception will be logged unless it is of a type contained in ``quiet_exceptions`` (which may be an exception type or a sequence of types). Does not support `YieldPoint` subclasses. The wrapped `.Future` is not canceled when the timeout expires, permitting it to be reused. `asyncio.wait_for` is similar to this function but it does cancel the wrapped `.Future` on timeout. .. versionadded:: 4.0 .. versionchanged:: 4.1 Added the ``quiet_exceptions`` argument and the logging of unhandled exceptions. .. versionchanged:: 4.4 Added support for yieldable objects other than `.Future`. c`sPy|jƒWn;tk rK}t|ˆƒsLtjd|dtƒqLnXdS(Ns$Exception in Future %r after timeoutRG(R,RERHR R R9(R'R"(R”(s*lib/python2.7/site-packages/tornado/gen.pyterror_callbackÈs  c`s3ˆjƒs"ˆjtdƒƒntˆˆƒdS(NtTimeout(RpRLRR((RªR'R,(s*lib/python2.7/site-packages/tornado/gen.pyttimeout_callbackÐs c`s ˆjˆƒS(N(tremove_timeout(R'(RŽttimeout_handle(s*lib/python2.7/site-packages/tornado/gen.pyR=Üsc`s ˆjˆƒS(N(R­(R'(RŽR®(s*lib/python2.7/site-packages/tornado/gen.pyR=ás( R˜R*RR RAt add_timeoutRHRRRB(ttimeoutR'R”R¬((RªR'RŽR”R,R®s*lib/python2.7/site-packages/tornado/gen.pyt with_timeoutŸs$     c`s,tƒ‰tjƒj|‡fd†ƒˆS(s¯Return 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`s tˆdƒS(N(RR!((R_(s*lib/python2.7/site-packages/tornado/gen.pyR=õs(R*R RAt call_later(tduration((R_s*lib/python2.7/site-packages/tornado/gen.pytsleepås R£cB`s eZdZd„Zd„ZRS(sÐ_NullFuture resembles a Future that finished with a result of None. It's not actually a `Future` to avoid depending on a particular event loop. Handled as a special case in the coroutine runner. cC`sdS(N(R!(RZ((s*lib/python2.7/site-packages/tornado/gen.pyR,ÿscC`stS(N(R9(RZ((s*lib/python2.7/site-packages/tornado/gen.pyRps(RRR[R,Rp(((s*lib/python2.7/site-packages/tornado/gen.pyR£ùs sŒA special object which may be yielded to allow the IOLoop to run for one iteration. This is not needed in normal use but it can be helpful in long-running coroutines that are likely to yield Futures that are ready instantly. Usage: ``yield gen.moment`` .. versionadded:: 4.0 .. deprecated:: 4.5 ``yield None`` (or ``yield`` with no argument) is now equivalent to ``yield gen.moment``. RNcB`sheZdZd„Zd„Zd„Zd„Zd„Zd„Zd„Z d„Z d „Z d „Z RS( sÏInternal implementation of `tornado.gen.engine`. Maintains information about pending callbacks and their results. The results of the generator are stored in ``result_future`` (a `.Future`) cC`s—||_||_t|_d|_d|_d|_t|_ t|_ t|_ t j ƒ|_d|_|j|ƒr“d}}}|jƒndS(N(tgent result_futuret _null_futureR'R!t yield_pointtpending_callbackstresultsRtrunningRŸt had_exceptionR RARŽtstack_context_deactivatet handle_yieldtrun(RZRµR¶t first_yielded((s*lib/python2.7/site-packages/tornado/gen.pyRY%s          cC`s`|jdkr'tƒ|_i|_n||jkrLtd|fƒ‚n|jj|ƒdS(s&Adds ``key`` to the list of callbacks.skey %r is already pendingN(R¹R!RšRºRR¦(RZR~((s*lib/python2.7/site-packages/tornado/gen.pyR:s   cC`sA|jdks||jkr4td|fƒ‚n||jkS(s2Returns true if a result is available for ``key``.skey %r is not pendingN(R¹R!RRº(RZR~((s*lib/python2.7/site-packages/tornado/gen.pyR{DscC`s‚||j|<|jdk r~|jjƒr~yt|j|jjƒƒWnt|jtj ƒƒnXd|_|j ƒndS(sASets the result for ``key`` and attempts to resume the generator.N( RºR¸R!R{RR'R|RRFRGR¿(RZR~R,((s*lib/python2.7/site-packages/tornado/gen.pyR‰Js   cC`s |jj|ƒ|jj|ƒS(s2Returns the result for ``key`` and unregisters it.(R¹R¤RºR@(RZR~((s*lib/python2.7/site-packages/tornado/gen.pyR‚VscC`s |js|jrdSzæt|_xÖtrú|j}|jƒsDdSd|_yÄtjj}d}y|j ƒ}Wn&t k ršt|_ t j ƒ}nXd}|dk rÐz|jj|Œ}Wdd}Xn|jj|ƒ}tjj|k r|jjtjdƒƒnWnÊttfk r‘}t|_t|_|jrd|j rdtd|jƒ‚nt|jt|ƒƒd|_|jƒdSt k rÝt|_t|_t|jt j ƒƒd|_|jƒdSX|j|ƒsñdSd}q%WWdt|_XdS(skStarts or resumes the generator, running until it reaches a yield point that is not ready. NsYstack_context inconsistency (probably caused by yield within a "with StackContext" block)s)finished without waiting for callbacks %r(R»RŸR9R'RpR!R RIRJR,RER¼RFRGRµtthrowtsendRMRDRCR·R¹RRR¶R#t_deactivate_stack_contextRR¾R(RZR'RPRGRRQR"((s*lib/python2.7/site-packages/tornado/gen.pyR¿[sd                      c`sYtˆƒrtˆƒ‰ntˆtƒr®tƒˆ_‡‡fd†‰ˆjdkr¤tj ˆj ƒ6}|ˆ_‡‡fd†}ˆj j |ƒt SWdQXq÷ˆƒnIytˆƒˆ_Wn3tk rötƒˆ_tˆjtjƒƒnXˆjtkrˆj j ˆjƒt SˆjjƒsU‡fd†}ˆj jˆj|ƒt StS(Nc`syy?ˆjˆƒˆjƒr5tˆjˆjƒƒn ˆˆ_Wn3tk rttƒˆ_tˆjt j ƒƒnXdS(N( RzR{RR'R|R¸RERRRFRG((RZRQ(s*lib/python2.7/site-packages/tornado/gen.pytstart_yield_pointªs     c`sˆƒˆjƒdS(N(R¿((RZRÄ(s*lib/python2.7/site-packages/tornado/gen.pytcb¼sc`sd}ˆjƒdS(N(R!R¿(R_(RZ(s*lib/python2.7/site-packages/tornado/gen.pytinnerÎs(R“R—RHRxRR'R½R!R RŠRˆRŽt add_callbackRR˜RRRFRGtmomentR¿RpRBR9(RZRQt deactivateRÅRÆ((RZRÄRQs*lib/python2.7/site-packages/tornado/gen.pyR¾Ÿs6          cC`s"tjttj|j|ƒƒƒS(N(R R.R‹R6tpartialR‰(RZR~((s*lib/python2.7/site-packages/tornado/gen.pyR€×s cC`sO|j rG|j rGtƒ|_t|j|||fƒ|jƒtStSdS(N(R»RŸRR'RR¿R9R(RZR†RR‡((s*lib/python2.7/site-packages/tornado/gen.pyRˆÛs   cC`s)|jdk r%|jƒd|_ndS(N(R½R!(RZ((s*lib/python2.7/site-packages/tornado/gen.pyRÃäs ( RRR[RYRR{R‰R‚R¿R¾R€RˆRÃ(((s*lib/python2.7/site-packages/tornado/gen.pyRNs    D 8  t ArgumentsRR/c`s‡fd†}|S(sReturns a function that when invoked runs ``callback`` with one arg. If the function returned by this function is called with exactly one argument, that argument is passed to ``callback``. Otherwise the args tuple and kwargs dict are wrapped in an `Arguments` object. c`sS|st|ƒdkr.ˆt||ƒƒn!|rEˆ|dƒn ˆdƒdS(Nii(tlenRËR!(RR/(R;(s*lib/python2.7/site-packages/tornado/gen.pyR1ôs ((R;R1((R;s*lib/python2.7/site-packages/tornado/gen.pyR‹íscc`s‹t|dƒr|jƒ}n t|ƒ}yt|ƒ}Wntk r[}t|ƒ}n Xxy |V}Wn¹tk r­}y |j}Wntk rœnX|ƒ|‚q_t k r%}t j ƒ}y |j }Wntk rî|‚qwXy||Œ}Wqwtk r!}t|ƒ}PqwXq_Xy.|dkrDt|ƒ}n|j|ƒ}Wq_tk rv}t|ƒ}Pq_Xq_Wt|ƒ‚dS(Nt __await__(RRRÍtiterRKRDR#t GeneratorExittcloseRt BaseExceptionRFRGRÁR!RÂRC(Rt_it_yt_et_rt_st_mt_x((s*lib/python2.7/site-packages/tornado/gen.pyt_wrap_awaitablesH              tasynccC`sˆ|dks|tkrtS|tkr,tSt|ttfƒrKt|ƒSt|ƒr[|St|ƒrqt |ƒSt d|fƒ‚dS(s¿Convert a yielded object into a `.Future`. The default implementation accepts lists, dictionaries, and Futures. 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 syielded unknown object %rN( R!RÈR·RHReRbR—RRRÙR(RQ((s*lib/python2.7/site-packages/tornado/gen.pyR˜9s     ((((SR[t __future__RRRRhR6RœtosRFRSR2ttornado.concurrentRRRRRRttornado.ioloopR t tornado.logR ttornadoR t tornado.utilR R RRt ImportErrortenvironR!tcollections.abcRRt backports_abctinspectRRvt __builtin__RERRRRRR#R*R8R:R5RWRCRR\RxR}RRƒRŒRR“R—tMultiR•R–R©R±R´R£R·RÈRNt namedtupleRËR‹tasyncioRÙt ensure_futureRR%R˜(((s*lib/python2.7/site-packages/tornado/gen.pytZs¨       .           * ' W v" "& 8D ;  F    Í  -