Current File : //lib64/python2.7/site-packages/tornado/gen.pyo
�
��L]c @� sO d Z d d l m Z m Z m Z m Z d d l Z d d l Z d d l Z d d l Z d d l
Z
d d l Z d d l m
Z
m Z m Z m Z d d l m Z d d l m Z d d l m Z d d l m Z y d d l m Z WnA e k
r)Z y d d l m Z Wq*e k
r%d Z q*Xn Xd
e f d � � YZ d e f d
� � YZ d e f d � � YZ d e f d � � YZ! d e f d � � YZ" d e f d � � YZ# d � Z$ e% d � Z& d � Z' d � Z( d e f d � � YZ) d e* f d � � YZ+ d e* f d � � YZ, d e, f d! � � YZ- d" e, f d# � � YZ. d$ e, f d% � � YZ/ d& � Z0 d' e, f d( � � YZ1 d) e, f d* � � YZ2 d7 d+ � Z3 d, � Z4 d d8 d- � Z5 d. � Z6 e
� Z7 e7 j8 d � e
� Z9 d/ e9 _ e9 j8 d � d0 e* f d1 � � YZ: e j; d2 d3 d4 g � Z< d5 � Z= d6 � Z> e d k rKe e> � Z> n d S(9 s� ``tornado.gen`` is a generator-based interface to make it easier to
work in an asynchronous environment. Code using the ``gen`` module
is technically asynchronous, but it is written as a single generator
instead of a collection of separate functions.
For example, the following 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
<https://pypi.python.org/pypi/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 ( t absolute_importt divisiont print_functiont with_statementN( t Futuret TracebackFuturet is_futuret chain_future( t IOLoop( t app_log( t
stack_context( t raise_exc_info( t singledispatcht
KeyReuseErrorc B� s e Z RS( ( t __name__t
__module__( ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyR
e s t UnknownKeyErrorc B� s e Z RS( ( R R ( ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyR i s t LeakedCallbackErrorc B� s e Z RS( ( R R ( ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyR m s t
BadYieldErrorc B� s e Z RS( ( R R ( ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyR q s t ReturnValueIgnoredErrorc B� s e Z RS( ( R R ( ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyR u s t TimeoutErrorc B� s e Z d Z RS( s% Exception raised by ``with_timeout``.( R R t __doc__( ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyR y s c � s4 t � d t �� t j � � � f d � � } | 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 <verbs>`,
which use ``self.finish()`` in place of a callback argument.
t replace_callbackc � s2 � | | � } d � } | j t j | � � d S( Nc S� s2 | j � d k r. t d | j � f � � n d S( Ns. @gen.engine functions cannot return values: %r( t resultt NoneR ( t future( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyt final_callback� s ( t add_done_callbackR
t wrap( t argst kwargsR R ( t func( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyt wrapper� s ( t _make_coroutine_wrappert Falset functoolst wraps( R R ( ( R s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyt engine} s
c C� s t | d t �S( s> Decorator 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) <Return>`. 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.
From the caller's perspective, ``@gen.coroutine`` is similar to
the combination of ``@return_future`` and ``@gen.engine``.
.. 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`.
R ( R! t True( R R ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyt coroutine� s #c � s= � } t j | � � � f d � � } | | _ 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``.
c � s� t � } � rL d | k rL | j d � � t j � j | � f d � � n y � | | � } WnO t t f k
r� } t | d d � } nt k
r� | j
t j � � | SXt
| t j � r�yP t j j } t | � } t j j | k rt � } | j t j d � � n WnU t t f k
rG} | j t | d d � � n4 t k
rj| j
t j � � n Xt | | | � z | SWd d } Xn | j | � | S( Nt callbackc � s � | j � � S( N( R ( R ( R( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyt <lambda>� s t valuesY stack_context inconsistency (probably caused by yield within a "with StackContext" block)( R t popR t currentt
add_futuret Returnt
StopIterationt getattrR t Exceptiont set_exc_infot syst exc_infot
isinstancet typest
GeneratorTypeR
t _statet contextst nextt
set_exceptiont StackContextInconsistentErrort
set_resultt Runner( R R R R t et orig_stack_contextst yielded( R R ( R( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyR � s>
( R# R$ t __wrapped__R& t __tornado_coroutine__( R R t wrappedR ( ( R R s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyR! � s
!5 c C� s t | d t � S( sg Return whether *func* is a coroutine function, i.e. a function
wrapped with `~.gen.coroutine`.
RC ( R0 R" ( R ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyt is_coroutine_function s R. c B� s e Z d Z d d � Z RS( 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.
c C� s t t | � j � | | _ d S( N( t superR. t __init__R* ( t selfR* ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyRG $ s N( R R R R RG ( ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyR. s t WaitIteratorc B� s; e Z d Z d � Z d � Z d � Z d � Z d � Z RS( sA 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).
.. versionadded:: 4.1
c O� s� | r | r t d � � n | rU t d � | j � D� � | _ t | j � � } n% t d � t | � D� � | _ | } t j � | _ d | _ | _ d | _
x | D] } | j | j � q� Wd S( Ns) You must provide args or kwargs, not bothc s� s! | ] \ } } | | f Vq d S( N( ( t .0t kt f( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pys <genexpr>U s c s� s! | ] \ } } | | f Vq d S( N( ( RJ t iRL ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pys <genexpr>X s ( t
ValueErrort dictt itemst _unfinishedt listt valuest enumeratet collectionst dequet _finishedR t
current_indext current_futuret _running_futureR t _done_callback( RH R R t futuresR ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyRG O s
c C� s* | j s | j r t Sd | _ | _ t S( s2 Returns True if this iterator has no more results.N( RW RQ R" R RX RY R& ( RH ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyt doneb s c C� s5 t � | _ | j r. | j | j j � � n | j S( 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.
( R RZ RW t _return_resultt popleft( RH ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyR: j s c C� s= | j r) | j j � r) | j | � n | j j | � d S( N( RZ R] R^ RW t append( RH R] ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyR[ w s c C� s2 t | | j � | | _ | j j | � | _ d S( s� Called set the returned future's state that of the future
we yielded, and set the current future for the iterator.
N( R RZ RY RQ R+ RX ( RH R] ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyR^ } s ( R R R RG R] R: R[ R^ ( ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyRI ) s %
t
YieldPointc B� s) e Z d Z d � Z d � Z d � Z RS( s� Base class for objects that may be yielded from the generator.
.. deprecated:: 4.0
Use `Futures <.Future>` instead.
c C� s
t � � d S( s� Called by the runner after the generator has yielded.
No other methods will be called on this object before ``start``.
N( t NotImplementedError( RH t runner( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyt start� s c C� s
t � � d S( s� Called by the runner to determine whether to resume the generator.
Returns a boolean; may be called more than once.
N( Rb ( RH ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyt is_ready� s c C� s
t � � d S( 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( Rb ( RH ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyt
get_result� s ( R R R Rd Re Rf ( ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyRa � s t Callbackc B� s2 e Z d Z d � Z d � Z d � Z d � Z RS( sa 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.
c C� s
| | _ d S( N( t key( RH Rh ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyRG � s c C� s | | _ | j | j � d S( N( Rc t register_callbackRh ( RH Rc ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyRd � s c C� s t S( N( R& ( RH ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyRe � s c C� s | j j | j � S( N( Rc t result_callbackRh ( RH ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyRf � s ( R R R RG Rd Re Rf ( ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyRg � s
t Waitc B� s2 e Z d Z d � Z d � Z d � Z d � Z RS( s� Returns the argument passed to the result of a previous `Callback`.
.. deprecated:: 4.0
Use `Futures <.Future>` instead.
c C� s
| | _ d S( N( Rh ( RH Rh ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyRG � s c C� s
| | _ d S( N( Rc ( RH Rc ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyRd � s c C� s | j j | j � S( N( Rc Re Rh ( RH ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyRe � s c C� s | j j | j � S( N( Rc t
pop_resultRh ( RH ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyRf � s ( R R R RG Rd Re Rf ( ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyRk � s
t WaitAllc B� s2 e Z d Z d � Z d � Z d � Z d � Z RS( s8 Returns the results of multiple previous `Callbacks <Callback>`.
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.
c C� s
| | _ d S( N( t keys( RH Rn ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyRG � s c C� s
| | _ d S( N( Rc ( RH Rc ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyRd � s c � s t � f d � � j D� � S( Nc 3� s! | ] } � j j | � Vq d S( N( Rc Re ( RJ Rh ( RH ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pys <genexpr>� s ( t allRn ( RH ( ( RH s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyRe � s c C� s& g | j D] } | j j | � ^ q
S( N( Rn Rc Rl ( RH Rh ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyRf � s ( R R R RG Rd Re Rf ( ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyRm � s
c � sZ t � � � f d � } � f d � } t j | � � | d t | � | | � Wd QX� S( s� Adapts 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.
c � s* � j � r t S� j | | | f � t S( N( R] R" R2 R& ( t typR* t tb( R ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyt handle_exception� s c � s! � j � r d S� j | � d S( N( R] R= ( R ( R ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyR= s R( N( R R
t ExceptionStackContextt _argument_adapter( R R R Rr R= ( ( R s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyt Task� s t YieldFuturec B� s/ e Z d d � Z d � Z d � Z d � Z RS( c C� s" | | _ | p t j � | _ d S( s� Adapts a `.Future` to the `YieldPoint` interface.
.. versionchanged:: 4.1
The ``io_loop`` argument is deprecated.
N( R R R, t io_loop( RH R Rw ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyRG
s c C� su | j j � sY | | _ t � | _ | j | j � | j j | j | j | j � � n d | _ | j j
| _ d S( N( R R] Rc t objectRh Ri Rw R- Rj R R t result_fn( RH Rc ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyRd s % c C� s* | j d k r" | j j | j � St Sd S( N( Rc R Re Rh R& ( RH ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyRe s c C� s6 | j d k r( | j j | j � j � S| j � Sd S( N( Rc R Rl Rh R Ry ( RH ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyRf # s N( R R R RG Rd Re Rf ( ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyRv s
t Multic B� s5 e Z d Z d d � Z d � Z d � Z d � Z RS( s Runs multiple asynchronous operations in parallel.
Takes a list of ``YieldPoints`` or ``Futures`` and returns a list of
their responses. It is not necessary to call `Multi` explicitly,
since the engine will do so automatically when the generator yields
a list of ``YieldPoints`` or a mixture of ``YieldPoints`` and ``Futures``.
Instead of a list, the argument may also be a dictionary whose values are
Futures, in which case a parallel dictionary is returned mapping the same
keys to their results.
It is not normally necessary to call this class directly, as it
will be created automatically as needed. However, calling it directly
allows you to use the ``quiet_exceptions`` argument to control
the logging of multiple exceptions.
.. 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.
c C� s� d | _ t | t � r< t | j � � | _ | j � } n g | _ x9 | D]1 } t | � rm t | � } n | j j | � qL Wt
| j � | _ | | _ d S( N(
R Rn R5 RO RR RS t childrenR Rv R` t sett unfinished_childrent quiet_exceptions( RH R{ R~ RM ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyRG @ s
c C� s% x | j D] } | j | � q
Wd S( N( R{ Rd ( RH Rc RM ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyRd N s c C� s6 t t j d � | j � � } | j j | � | j S( Nc S� s
| j � S( N( Re ( RM ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyR) T s ( RR t itertoolst takewhileR} t difference_update( RH t finished( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyRe R s c C� s� g } d } x� | j D]v } y | j | j � � Wq t k
r� } | d k r` t j � } q� t | | j � s� t j
d d t �q� q Xq W| d k r� t | � n | j
d k r� t t | j
| � � St | � Sd S( Ns! Multiple exceptions in yield listR4 ( R R{ R` Rf R1 R3 R4 R5 R~ R t errorR& R Rn RO t zipRR ( RH t result_listR4 RL R? ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyRf X s
( ( R R R RG Rd Re Rf ( ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyRz * s
c � s� t � t � r0 t � j � � � � j � � n d � t � � � t � � � ss � j � d k ri i n g � n � � � � � f d � } t � } x7 � D]/ } | | k r� | j | � | j
| � q� q� W� S( s� Wait for multiple asynchronous futures in parallel.
Takes a list of ``Futures`` (but *not* other ``YieldPoints``) and returns
a new Future that resolves when all the other Futures are done.
If all the ``Futures`` succeeded, the returned Future's result is a list
of their results. If any failed, the returned Future raises the exception
of the first one to fail.
Instead of a list, the argument may also be a dictionary whose values are
Futures, in which case a parallel dictionary is returned mapping the same
keys to their results.
It is not normally necessary to call `multi_future` explcitly,
since the engine will do so automatically when the generator
yields a list of ``Futures``. However, calling it directly
allows you to use the ``quiet_exceptions`` argument to control
the logging of multiple exceptions.
This function is faster than the `Multi` `YieldPoint` because it
does not require the creation of a stack context.
.. 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.
c � s� � j | � � s� g } x� � D]z } y | j | j � � Wq t k
r� } � j � r� t | � � s� t j d d t �q� q� � j t
j � � q Xq W� j � s� � d k r� � j
t t � | � � � q� � j
| � q� n d S( Ns! Multiple exceptions in yield listR4 ( t removeR` R R1 R] R5 R R� R& R2 R3 R4 R R= RO R� ( RL R� R? ( R{ R Rn R~ R} ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyR( � s
N( R5 RO RR Rn RS R R| R R= t addR ( R{ R~ R( t listeningRL ( ( R{ R Rn R~ R} s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyt multi_futurem s "
c C� s. t | � r | St � } | j | � | Sd S( s Converts ``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.
N( R R R= ( t xt fut( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyt maybe_future� s
c � s� t � � t � � � � d k r1 t j � � n � f d � � � � � f d � } � j | | � � t � t � r� � j � � f d � � n � j � � � f d � � � S( s� Wraps a `.Future` in a timeout.
Raises `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).
Currently only supports Futures, not other `YieldPoint` classes.
.. versionadded:: 4.0
.. versionchanged:: 4.1
Added the ``quiet_exceptions`` argument and the logging of unhandled
exceptions.
c � sP y | j � Wn; t k
rK } t | � � sL t j d | d t �qL n Xd S( Ns$ Exception in Future %r after timeoutR4 ( R R1 R5 R R� R& ( R R? ( R~ ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyt error_callback� s c � s$ � j t d � � � j � � d S( Nt Timeout( R; R R ( ( R� R R ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyt timeout_callback� s c � s
� j � � S( N( t remove_timeout( R ( Rw t timeout_handle( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyR) � s c � s
� j � � S( N( R� ( R ( Rw R� ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyR) � s N( R R R R R, t add_timeoutR5 R R- ( t timeoutR Rw R~ R� ( ( R� R Rw R~ R R� s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyt with_timeout� s
c � s, t � � t j � j | � f d � � � 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
� j d � S( N( R= R ( ( RL ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyR) s ( R R R, t
call_later( t duration( ( RL s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyt sleep� 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
R> c B� sh e Z d Z d � Z d � Z d � Z d � Z d � Z d � Z d � 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
`.TracebackFuture`)
c C� s� | | _ | | _ t | _ d | _ d | _ d | _ t | _ t | _
t | _ t j
� | _ d | _ | j | � r� | j � n d S( N( t gent
result_futuret _null_futureR R t yield_pointt pending_callbackst resultsR" t runningR� t
had_exceptionR R, Rw t stack_context_deactivatet handle_yieldt run( RH R� R� t
first_yielded( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyRG , s c C� s` | j d k r' t � | _ i | _ n | | j k rL t d | f � � n | j j | � d S( s& Adds ``key`` to the list of callbacks.s key %r is already pendingN( R� R R| R� R
R� ( RH Rh ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyRi @ s c C� sA | j d k s | | j k r4 t d | f � � n | | j k S( s2 Returns true if a result is available for ``key``.s key %r is not pendingN( R� R R R� ( RH Rh ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyRe J s c C� s� | | j | <| j d k r~ | j j � r~ y | j j | j j � � Wn | j j t j � � n Xd | _ | j
� n d S( sA Sets the result for ``key`` and attempts to resume the generator.N( R� R� R Re R R= Rf R2 R3 R4 R� ( RH Rh R ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyR= P s
c C� s | j j | � | j j | � S( s2 Returns the result for ``key`` and unregisters it.( R� R� R� R+ ( RH Rh ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyRl [ s c C� s� | j s | j r d Sz�t | _ x�t r�| j } | j � sD d Sd | _ y� t j j } d } y | j � } Wn& t
k
r� t | _ t j
� } n X| d k r� | j j | � } d } n | j j | � } t j j | k r| j j t j d � � n Wn� t t f k
r�} t | _ t | _ | j rV| j rVt d | j � � n | j j t | d d � � d | _ | j � d St
k
r�t | _ t | _ | j j t j
� � d | _ | j � d SX| j | � s% d Sq% WWd t | _ Xd S( sk Starts or resumes the generator, running until it reaches a
yield point that is not ready.
NsY stack_context inconsistency (probably caused by yield within a "with StackContext" block)s) finished without waiting for callbacks %rR* ( R� R� R& R R] R R
R8 R9 R R1 R� R3 R4 R� t throwt sendR< R/ R. R� R� R R� R= R0 t _deactivate_stack_contextR2 R� R" ( RH R R@ R4 R* RA R? ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyR� ` s\
c � s� t � t � r4 t d � � D� � r4 t � � � n: t � t � rn t d � � j � D� � rn t � � � n t � t � rt � � _ � � f d � � � j d k r� t j � j
� �6 } | � _ � � f d � } � j j | � t SWd QXqJ� � nI y t � � � _ Wn3 t k
rIt � � _ � j j t j � � n X� j j � si� j t k r�� j j � j � f d � � t St S( Nc s� s | ] } t | t � Vq d S( N( R5 Ra ( RJ RL ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pys <genexpr>� s c s� s | ] } t | t � Vq d S( N( R5 Ra ( RJ RL ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pys <genexpr>� s c � sy y? � j � � � j � r5 � j j � j � � n � � _ Wn3 t k
rt t � � _ � j j t j
� � n Xd S( N( Rd Re R R= Rf R� R1 R R2 R3 R4 ( ( RH RA ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyt start_yield_point� s
c � s � � � j � d S( N( R� ( ( RH R� ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyt cb� s c � s
� j � S( N( R� ( RL ( RH ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyR) � s ( R5 RR t anyRz RO RS Ra R R R� R R
Rs Rr Rw t add_callbackR" t convert_yieldedR R2 R3 R4 R] t momentR- R& ( RH RA t
deactivateR� ( ( RH R� RA s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyR� � s6
c C� s" t j t t j | j | � � � S( N( R
R Rt R# t partialR= ( RH Rh ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyRj � s c C� sO | j rG | j rG t � | _ | j j | | | f � | j � t St Sd S( N( R� R� R R R2 R� R& R" ( RH Rp R* Rq ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyRr � s
c C� s) | j d k r% | j � d | _ n d S( N( R� R ( RH ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyR� � s
(
R R R RG Ri Re R= Rl R� R� Rj Rr R� ( ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyR> $ s
= 6 t ArgumentsR R c � s � f d � } | S( s Returns 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 | s t | � d k r. � t | | � � n! | rE � | d � n
� d � d S( Ni i ( t lenR� R ( R R ( R( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyR � s
( ( R( R ( ( R( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyRt � s c C� sF t | t t f � r t | � St | � r/ | St d | f � � d S( 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
s yielded unknown object %rN( R5 RR RO R� R R ( RA ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyR� � s
( ( (? R t
__future__R R R R RU R# R R3 R6 t weakreft tornado.concurrentR R R R t tornado.ioloopR t tornado.logR t tornadoR
t tornado.utilR R t ImportErrorR? R R1 R
R R R R R R% R& R' R! RE R. Rx RI Ra Rg Rk Rm Ru Rv Rz R� R� R� R� R� R= R� R> t
namedtupleR� Rt R� ( ( ( s1 /usr/lib64/python2.7/site-packages/tornado/gen.pyt <module>L sj " "
# & C ^ !C E =
�
Mini Shell