ó ¨œž[c@`sDdZddlmZmZmZddlZddlZddlZddlZddl Z ddl Z ddl m Z ddl mZmZddlmZmZmZyddlmZWnek rÙdZnXyddlZWnek rdZnXyddlZWnek r-dZnXejƒdkoLe jdkZd efd „ƒYZd efd„ƒYZ defd„ƒYZ!edk r©ej!Z!nedkr¾e!Z"nej!e!fZ"d„Z#defd„ƒYZ$e$ƒZ%d„Z&eƒZ'd„Z(e)d„Z*d„Z+d„Z,d„Z-d„Z.dS(siUtilities for working with ``Future`` objects. ``Futures`` are a pattern for concurrent programming introduced in Python 3.2 in the `concurrent.futures` package, and also adopted (in a slightly different form) in Python 3.4's `asyncio` package. This package defines a ``Future`` class that is an alias for `asyncio.Future` when available, and a compatible implementation for older versions of Python. It also includes some utility functions for interacting with ``Future`` objects. While this package is an important part of Tornado's internal implementation, applications rarely need to interact with it directly. i(tabsolute_importtdivisiontprint_functionN(tapp_log(tExceptionStackContexttwrap(traise_exc_infot ArgReplacert is_finalizing(tfuturestCPythoniitReturnValueIgnoredErrorcB`seZRS((t__name__t __module__(((s1lib/python2.7/site-packages/tornado/concurrent.pyR @st_TracebackLoggercB`s;eZdZdZd„Zd„Zd„Zed„ZRS(s Helper to log a traceback upon destruction if not cleared. This solves a nasty problem with Futures and Tasks that have an exception set: if nobody asks for the exception, the exception is never logged. This violates the Zen of Python: 'Errors should never pass silently. Unless explicitly silenced.' However, we don't want to log the exception as soon as set_exception() is called: if the calling code is written properly, it will get the exception and handle it properly. But we *do* want to log it if result() or exception() was never called -- otherwise developers waste a lot of time wondering why their buggy code fails silently. An earlier attempt added a __del__() method to the Future class itself, but this backfired because the presence of __del__() prevents garbage collection from breaking cycles. A way out of this catch-22 is to avoid having a __del__() method on the Future class itself, but instead to have a reference to a helper object with a __del__() method that logs the traceback, where we ensure that the helper object doesn't participate in cycles, and only the Future has a reference to it. The helper object is added when set_exception() is called. When the Future is collected, and the helper is present, the helper object is also collected, and its __del__() method will log the traceback. When the Future's result() or exception() method is called (and a helper object is present), it removes the the helper object, after calling its clear() method to prevent it from logging. One downside is that we do a fair amount of work to extract the traceback from the exception, even when it is never logged. It would seem cheaper to just store the exception object, but that references the traceback, which references stack frames, which may reference the Future, which references the _TracebackLogger, and then the _TracebackLogger would be included in a cycle, which is what we're trying to avoid! As an optimization, we don't immediately format the exception; we only do the work when activate() is called, which call is delayed until after all the Future's callbacks have run. Since usually a Future has at least one callback (typically set by 'yield From') and usually that callback extracts the callback, thereby removing the need to format the exception. PS. I don't claim credit for this solution. I first heard of it in a discussion about closing files when they are collected. texc_infot formatted_tbcC`s||_d|_dS(N(RtNoneR(tselfR((s1lib/python2.7/site-packages/tornado/concurrent.pyt__init__{s cC`s7|j}|dk r3d|_tj|Œ|_ndS(N(RRt tracebacktformat_exceptionR(RR((s1lib/python2.7/site-packages/tornado/concurrent.pytactivates   cC`sd|_d|_dS(N(RRR(R((s1lib/python2.7/site-packages/tornado/concurrent.pytclear…s cC`s<|ƒ r8|jr8tjddj|jƒjƒƒndS(Ns(Future exception was never retrieved: %st(RRterrortjointrstrip(RR((s1lib/python2.7/site-packages/tornado/concurrent.pyt__del__‰s (RR( R R t__doc__t __slots__RRRRR(((s1lib/python2.7/site-packages/tornado/concurrent.pyRGs 0   tFuturecB`sÜeZdZd„Zejdkr8ejdƒdUn d„Zd„Z d„Z d„Z d „Z d „Z dd „Zdd „Zd „Zd„Zd„Zd„Zd„Zd„Zd„ZerÚed„ZnRS(s¼Placeholder for an asynchronous result. A ``Future`` encapsulates the result of an asynchronous operation. In synchronous applications ``Futures`` are used to wait for the result from a thread or process pool; in Tornado they are normally used with `.IOLoop.add_future` or by yielding them in a `.gen.coroutine`. `tornado.concurrent.Future` is an alias for `asyncio.Future` when that package is available (Python 3.4+). Unlike `concurrent.futures.Future`, the ``Futures`` used by Tornado and `asyncio` are not thread-safe (and therefore faster for use with single-threaded event loops). In addition to ``exception`` and ``set_exception``, Tornado's ``Future`` implementation supports storing an ``exc_info`` triple to support better tracebacks on Python 2. To set an ``exc_info`` triple, use `future_set_exc_info`, and to retrieve one, call `result()` (which will raise it). .. versionchanged:: 4.0 `tornado.concurrent.Future` is always a thread-unsafe ``Future`` with support for the ``exc_info`` methods. Previously it would be an alias for the thread-safe `concurrent.futures.Future` if that package was available and fall back to the thread-unsafe implementation if it was not. .. versionchanged:: 4.1 If a `.Future` contains an error but that error is never observed (by calling ``result()``, ``exception()``, or ``exc_info()``), a stack trace will be logged when the `.Future` is garbage collected. This normally indicates an error in the application, but in cases where it results in undesired logging it may be necessary to suppress the logging by ensuring that the exception is observed: ``f.add_done_callback(lambda f: f.exception())``. .. versionchanged:: 5.0 This class was previoiusly available under the name ``TracebackFuture``. This name, which was deprecated since version 4.0, has been removed. When `asyncio` is available ``tornado.concurrent.Future`` is now an alias for `asyncio.Future`. Like `asyncio.Future`, callbacks are now always scheduled on the `.IOLoop` and are never run synchronously. cC`s:t|_d|_d|_t|_d|_g|_dS(N(tFalset_doneRt_resultt _exc_infot_log_tracebackt _tb_loggert _callbacks(R((s1lib/python2.7/site-packages/tornado/concurrent.pyR¿s      isF def __await__(self): return (yield self) Ncc`s&|V}tƒ}|f|_|‚dS(N(t StopIterationtargs(Rtresultte((s1lib/python2.7/site-packages/tornado/concurrent.pyt __await__Òs  cC`stS(s’Cancel the operation, if possible. Tornado ``Futures`` do not support cancellation, so this method always returns False. (R (R((s1lib/python2.7/site-packages/tornado/concurrent.pytcancelÚscC`stS(s¡Returns True if the operation has been cancelled. Tornado ``Futures`` do not support cancellation, so this method always returns False. (R (R((s1lib/python2.7/site-packages/tornado/concurrent.pyt cancelledâscC`s|j S(s4Returns True if this operation is currently running.(R!(R((s1lib/python2.7/site-packages/tornado/concurrent.pytrunningêscC`s|jS(s0Returns True if the future has finished running.(R!(R((s1lib/python2.7/site-packages/tornado/concurrent.pytdoneîscC`s5t|_|jdk r1|jjƒd|_ndS(N(R R$R%RR(R((s1lib/python2.7/site-packages/tornado/concurrent.pyt _clear_tb_logòs  cC`s^|jƒ|jdk r |jS|jdk rMzt|jƒWdd}Xn|jƒ|jS(s8If the operation succeeded, return its result. If it failed, re-raise its exception. This method takes a ``timeout`` argument for compatibility with `concurrent.futures.Future` but it is an error to call it before the `Future` is done, so the ``timeout`` is never used. N(R0R"RR#Rt _check_done(Rttimeout((s1lib/python2.7/site-packages/tornado/concurrent.pyR)øs   cC`s6|jƒ|jdk r$|jdS|jƒdSdS(s@If the operation raised an exception, return the `Exception` object. Otherwise returns None. This method takes a ``timeout`` argument for compatibility with `concurrent.futures.Future` but it is an error to call it before the `Future` is done, so the ``timeout`` is never used. iN(R0R#RR1(RR2((s1lib/python2.7/site-packages/tornado/concurrent.pyt exception s    cC`sF|jr2ddlm}|jƒj||ƒn|jj|ƒdS(s.Attaches the given callback to the `Future`. It will be invoked with the `Future` as its argument when the Future has finished running and its result is available. In Tornado consider using `.IOLoop.add_future` instead of calling `add_done_callback` directly. i(tIOLoopN(R!ttornado.ioloopR4tcurrentt add_callbackR&tappend(RtfnR4((s1lib/python2.7/site-packages/tornado/concurrent.pytadd_done_callbacks cC`s||_|jƒdS(sSets the result of a ``Future``. It is undefined to call any of the ``set`` methods more than once on the same object. N(R"t _set_done(RR)((s1lib/python2.7/site-packages/tornado/concurrent.pyt set_result(s cC`s)|j|j|t|ddƒfƒdS(s#Sets the exception of a ``Future.``t __traceback__N(t set_exc_infot __class__tgetattrR(RR3((s1lib/python2.7/site-packages/tornado/concurrent.pyt set_exception1scC`s|jƒ|jS(seReturns a tuple in the same format as `sys.exc_info` or None. .. versionadded:: 4.0 (R0R#(R((s1lib/python2.7/site-packages/tornado/concurrent.pyR8s cC`sq||_t|_ts*t|ƒ|_nz|jƒWd|jrc|jdk rc|jjƒnX||_dS(s‚Sets the exception information of a ``Future.`` Preserves tracebacks on Python 2. .. versionadded:: 4.0 N( R#tTrueR$t_GC_CYCLE_FINALIZERSRR%R;RR(RR((s1lib/python2.7/site-packages/tornado/concurrent.pyR>@s  cC`s|jstdƒ‚ndS(Ns1DummyFuture does not support blocking for results(R!t Exception(R((s1lib/python2.7/site-packages/tornado/concurrent.pyR1Us cC`sbt|_|jr^ddlm}|jƒ}x!|jD]}|j||ƒq8Wd|_ndS(Ni(R4(RBR!R&R5R4R6R7R(RR4tlooptcb((s1lib/python2.7/site-packages/tornado/concurrent.pyR;Ys   cC`sO|ƒs|j rdStj|jŒ}tjd|dj|ƒjƒƒdS(Ns+Future %r exception was never retrieved: %sR(R$RRR#RRRR(RRttb((s1lib/python2.7/site-packages/tornado/concurrent.pyRfs  (ii(R R RRtsyst version_infottextwraptdedentR+R,R-R.R/R0RR)R3R:R<RARR>R1R;RCRR(((s1lib/python2.7/site-packages/tornado/concurrent.pyRs,/               cC`s t|tƒS(N(t isinstancetFUTURES(tx((s1lib/python2.7/site-packages/tornado/concurrent.pyt is_future{st DummyExecutorcB`seZd„Zed„ZRS(cO`sNtƒ}yt||||ŽƒWn$tk rIt|tjƒƒnX|S(N(Rt"future_set_result_unless_cancelledRDtfuture_set_exc_infoRHR(RR9R(tkwargstfuture((s1lib/python2.7/site-packages/tornado/concurrent.pytsubmit€s   cC`sdS(N((Rtwait((s1lib/python2.7/site-packages/tornado/concurrent.pytshutdownˆs(R R RURBRW(((s1lib/python2.7/site-packages/tornado/concurrent.pyRPs c`sx‡fd†}|r*ˆr*tdƒ‚nt|ƒdkrJ||dƒSt|ƒdkrttdt|ƒƒ‚n|S(sIDecorator to run a synchronous method asynchronously on an executor. The decorated method may be called with a ``callback`` keyword argument and returns a future. The executor to be used is determined by the ``executor`` attributes of ``self``. To use a different attribute name, pass a keyword argument to the decorator:: @run_on_executor(executor='_thread_pool') def foo(self): pass This decorator should not be confused with the similarly-named `.IOLoop.run_in_executor`. In general, using ``run_in_executor`` when *calling* a blocking method is recommended instead of using this decorator when *defining* a method. If compatibility with older versions of Tornado is required, consider defining an executor and using ``executor.submit()`` at the call site. .. versionchanged:: 4.2 Added keyword arguments to use alternative attributes. .. versionchanged:: 5.0 Always uses the current IOLoop instead of ``self.io_loop``. .. versionchanged:: 5.1 Returns a `.Future` compatible with ``await`` instead of a `concurrent.futures.Future`. .. deprecated:: 5.1 The ``callback`` argument is deprecated and will be removed in 6.0. The decorator itself is discouraged in new code but will not be removed in 6.0. c`s7ˆjddƒ‰tjˆƒ‡‡fd†ƒ}|S(Ntexecutorc`s•|jddƒ‰tƒ}t|ˆƒjˆ|||Ž}t||ƒˆr‘tjdtƒddl m }|j ƒj |‡fd†ƒn|S(NtcallbacksBcallback arguments are deprecated, use the returned Future insteadi(R4c`sˆ|jƒƒS(N(R)(RT(RY(s1lib/python2.7/site-packages/tornado/concurrent.pytÂs( tpopRRR@RUt chain_futuretwarningstwarntDeprecationWarningR5R4R6t add_future(RR(RSt async_futuret conc_futureR4(RXR9(RYs1lib/python2.7/site-packages/tornado/concurrent.pytwrapper·s !   (tgett functoolstwraps(R9Rc(RS(RXR9s1lib/python2.7/site-packages/tornado/concurrent.pytrun_on_executor_decorator´s! s*cannot combine positional and keyword argsiisexpected 1 argument, got %d(t ValueErrortlen(R(RSRg((RSs1lib/python2.7/site-packages/tornado/concurrent.pytrun_on_executors% cC`s tjdtƒt|dtƒS(sôDecorator to make a function that returns via callback return a `Future`. This decorator was provided to ease the transition from callback-oriented code to coroutines. It is not recommended for new code. The wrapped function should take a ``callback`` keyword argument and invoke it with one argument when it has finished. To signal failure, the function can simply raise an exception (which will be captured by the `.StackContext` and passed along to the ``Future``). From the caller's perspective, the callback argument is optional. If one is given, it will be invoked when the function is complete with ``Future.result()`` as an argument. If the function fails, the callback will not be run and an exception will be raised into the surrounding `.StackContext`. If no callback is given, the caller should use the ``Future`` to wait for the function to complete (perhaps by yielding it in a coroutine, or passing it to `.IOLoop.add_future`). Usage: .. testcode:: @return_future def future_func(arg1, arg2, callback): # Do stuff (possibly asynchronous) callback(result) async def caller(): await future_func(arg1, arg2) .. Note that ``@return_future`` and ``@gen.engine`` can be applied to the same function, provided ``@return_future`` appears first. However, consider using ``@gen.coroutine`` instead of this combination. .. versionchanged:: 5.1 Now raises a `.DeprecationWarning` if a callback argument is passed to the decorated function and deprecation warnings are enabled. .. deprecated:: 5.1 This decorator will be removed in Tornado 6.0. New code should use coroutines directly instead of wrapping callback-based code with this decorator. Interactions with non-Tornado callback-based code should be managed explicitly to avoid relying on the `.ExceptionStackContext` built into this decorator. s4@return_future is deprecated, use coroutines insteadR^(R]R^R_t_non_deprecated_return_futureRB(tf((s1lib/python2.7/site-packages/tornado/concurrent.pyt return_futureÑs7 c`s7tˆdƒ‰tjˆƒ‡‡‡fd†ƒ}|S(NRYc`stƒ‰ˆjt‡fd†||ƒ\‰}}‡fd†}d}t|dtƒ}|^ˆsst|_ny.ˆ||Ž}|dk r tdƒ‚nWnt j ƒ}‚nXWdQX|dk rÙˆj ƒnˆdk rt j dtƒ‡fd†}tˆt|ƒƒnˆS(Nc`s tˆ|ƒS(N(RQ(tvalue(RT(s1lib/python2.7/site-packages/tornado/concurrent.pyRZsc`stˆ|||fƒtS(N(RRRB(ttypRnRG(RT(s1lib/python2.7/site-packages/tornado/concurrent.pyt handle_errorst delay_warningsC@return_future should not be used with functions that return valuessBcallback arguments are deprecated, use the returned Future insteadc`s6|jƒ}|tkr"ˆƒnˆ|jƒƒdS(N(R)t _NO_RESULT(RTR)(RY(s1lib/python2.7/site-packages/tornado/concurrent.pyt run_callback@s   (RtreplaceRrRRRBR RqR RHRR)R]R^R_tfuture_add_done_callbackR(R(RSRpRtescR)Rs(RltreplacerR^(RYRTs1lib/python2.7/site-packages/tornado/concurrent.pyRcs4         (RReRf(RlR^Rc((RlRwR^s1lib/python2.7/site-packages/tornado/concurrent.pyRk s$5c`s[‡‡fd†}tˆtƒr1tˆ|ƒn&ddlm}|jƒjˆ|ƒdS(sjChain two futures together so that when one completes, so does the other. The result (success or failure) of ``a`` will be copied to ``b``, unless ``b`` has already been completed or cancelled by the time ``a`` finishes. .. versionchanged:: 5.0 Now accepts both Tornado/asyncio `Future` objects and `concurrent.futures.Future`. c`s˜|ˆkst‚ˆjƒr"dStˆdƒrYˆjƒdk rYtˆˆjƒƒn;ˆjƒdk rˆjˆjƒƒnˆjˆj ƒƒdS(NR( tAssertionErrorR/thasattrRRRRR3RAR<R)(RT(tatb(s1lib/python2.7/site-packages/tornado/concurrent.pytcopyWs i(R4N(RLRRuR5R4R6R`(RzR{R|R4((RzR{s1lib/python2.7/site-packages/tornado/concurrent.pyR\Ks  cC`s |jƒs|j|ƒndS(sÈSet the given ``value`` as the `Future`'s result, if not cancelled. Avoids asyncio.InvalidStateError when calling set_result() on a cancelled `asyncio.Future`. .. versionadded:: 5.0 N(R-R<(RTRn((s1lib/python2.7/site-packages/tornado/concurrent.pyRQjs cC`s4t|dƒr|j|ƒn|j|dƒdS(sÄSet the given ``exc_info`` as the `Future`'s exception. Understands both `asyncio.Future` and Tornado's extensions to enable better tracebacks on Python 2. .. versionadded:: 5.0 R>iN(RyR>RA(RTR((s1lib/python2.7/site-packages/tornado/concurrent.pyRRvscC`s*|jƒr||ƒn |j|ƒdS(sLArrange to call ``callback`` when ``future`` is complete. ``callback`` is invoked with one argument, the ``future``. If ``future`` is already done, ``callback`` is invoked immediately. This may differ from the behavior of ``Future.add_done_callback``, which makes no such guarantee. .. versionadded:: 5.0 N(R/R:(RTRY((s1lib/python2.7/site-packages/tornado/concurrent.pyRu†s  (ii(/Rt __future__RRRRetplatformRJRRHR]t tornado.logRttornado.stack_contextRRt tornado.utilRRRt concurrentR t ImportErrorRtasynciottypingtpython_implementationRIRCRDR tobjectRRRMRORPtdummy_executorRjRrRmR RkR\RQRRRu(((s1lib/python2.7/site-packages/tornado/concurrent.pytsV            Hã       ?  < >