tornado.gen — Simplify asynchronous code¶

For example, the following asynchronous handler:

could be written with gen as:

class GenAsyncHandler(RequestHandler):
    def get(self):
        http_client = AsyncHTTPClient()
        response = yield http_client.fetch("http://example.com")
        do_something_with_response(response)

Most asynchronous functions in Tornado return a Future;yielding this object returns its .

@gen.coroutine
def get(self):
    http_client = AsyncHTTPClient()
    response1, response2 = yield [http_client.fetch(url1),
                                  http_client.fetch(url2)]
    response_dict = yield dict(response3=http_client.fetch(url3),
                               response4=http_client.fetch(url4))
    response3 = response_dict['response3']
    response4 = response_dict['response4']

If the library is available (standard inPython 3.4, available via the singledispatch package on olderversions), additional types of objects may be yielded. Tornado includessupport for asyncio.Future and Twisted’s Deferred class whentornado.platform.asyncio and tornado.platform.twisted are imported.See the function to extend this mechanism.

在 4.1 版更改: Support added for yielding asyncio Futures and Twisted Deferredsvia singledispatch.

tornado.gen.coroutine(func, replace_callback=True)[源代码]

Decorator for asynchronous generators.

Any generator that yields objects from this module must be wrappedin either this decorator or engine.

Coroutines may “return” by raising the special exception. In Python 3.3+, it is also possible forthe function to simply use the return value statement (prior toPython 3.3 generators were not allowed to also return values).In all versions of Python a coroutine that simply wishes to exitearly 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, whichwill be invoked with the future’s result when it resolves. If thecoroutine fails, the callback will not be run and an exceptionwill be raised into the surrounding . Thecallback argument is not visible inside the decoratedfunction; it is handled by the decorator itself.

From the caller’s perspective, @gen.coroutine is similar tothe combination of @returnfuture and @gen.engine.


警告

When exceptions occur inside a coroutine, the exceptioninformation will be stored in the Future object. You mustexamine the result of the object, or the exceptionmay go unnoticed by your code. This means yielding the functionif called from another coroutine, using something likeIOLoop.run_sync for top-level calls, or passing the to IOLoop.add_future.

tornado.gen.engine(_func)¶

Callback-oriented decorator for asynchronous generators.

This is an older interface; for new code that does not need to becompatible with versions of Tornado older than 3.0 the decorator is recommended instead.

This decorator is similar to coroutine, except it does notreturn a and the callback argument is not treatedspecially.

In most cases, functions decorated with engine should takea callback argument and invoke it with their result whenthey are finished. One notable exception is theHTTP verb methods,which use self.finish() in place of a callback argument.

exception tornado.gen.Return(value=None)¶

Special exception to return a value from a .

If this exception is raised, its value argument is used as theresult of the coroutine:







In Python 3.3, this exception is no longer necessary: the returnstatement can be used directly to return a value (previouslyyield and return with a value could not be combined in thesame function).

By analogy with the return statement, the value argument is optional,but it is never necessary to raise gen.Return(). The returnstatement can be used with no arguments instead.

tornado.gen.with_timeout(_timeout, future, io_loop=None, quiet_exceptions=())[源代码]

Wraps a Future (or other yieldable object) in a timeout.

Raises if the input future does not complete beforetimeout, which may be specified in any form allowed byIOLoop.add_timeout (i.e. a or an absolute timerelative to IOLoop.time)

If the wrapped fails after it has timed out, the exceptionwill be logged unless it is of a type contained in quietexceptions(which may be an exception type or a sequence of types).

Does not support YieldPoint subclasses.


4.0 新版功能.



在 4.1 版更改: Added the quiet_exceptions argument and the logging of unhandledexceptions.



在 4.4 版更改: Added support for yieldable objects other than .

_exception tornado.gen.TimeoutError[源代码]

Exception raised by .

tornado.gen.sleep(_duration)[源代码]

Return a Future that resolves after the given number of seconds.

When used with yield in a coroutine, this is a non-blockinganalogue to (which should not be used in coroutinesbecause it is blocking):

yield gen.sleep(0.5)

Note that calling this function on its own does nothing; you mustwait on the Future it returns (usually by yielding it).


4.1 新版功能.

tornado.gen.moment

A special object which may be yielded to allow the IOLoop to run forone iteration.

This is not needed in normal use but it can be helpful in long-runningcoroutines that are likely to yield Futures that are ready instantly.

Usage: yield gen.moment


4.0 新版功能.

class tornado.gen.WaitIterator(*args, **kwargs)[源代码]

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 future2return, and then restarts the coroutine with the results of bothfutures. If either future is an exception, the expression willraise 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 produceerrors, you can use WaitIterator:

waititerator = 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 theoutput from the iterator _will not be in the same order as theinput arguments. If you need to know which future produced thecurrent result, you can use the attributesWaitIterator.currentfuture, or WaitIterator.current_indexto get the index of the future from the input list. (if keywordarguments were used in the construction of the WaitIterator,current_index will use the corresponding keyword).

On Python 3.5, implements the async iteratorprotocol, so it can be used with the async for statement (notethat in this version the entire iteration is aborted if any valueraises an exception, while the previous example can continue pastindividual errors):








4.1 新版功能.



在 4.3 版更改: Added async for support in Python 3.5.

done()[源代码]

Returns True if this iterator has no more results.

next()[源代码]

Returns a Future that will yield the next available result.

Note that this will not be the same object as any ofthe inputs.

tornado.gen.multi(_children, quiet_exceptions=())[源代码]

Runs multiple asynchronous operations in parallel.

children may either be a list or a dict whose values areyieldable objects. multi() returns a new yieldableobject that resolves to a parallel structure containing theirresults. If children is a list, the result is a list ofresults in the same order; if it is a dict, the result is a dictwith the same keys.

That is, results = yield multi(listof_futures) is equivalentto:

results = []
for future in list_of_futures:
    results.append(yield future)

If any children raise exceptions, multi() will raise the firstone. All others will be logged, unless they are of typescontained in the quiet_exceptions argument.

If any of the inputs are YieldPoints, the returnedyieldable object is a . Otherwise, returns a Future.This means that the result of can be used in a nativecoroutine if and only if all of its children can be.

In a yield-based coroutine, it is not normally necessary tocall this function directly, since the coroutine runner willdo it automatically when a list or dict is yielded. However,it is necessary in await-based coroutines, or to passthe quiet_exceptions argument.

This function is available under the names multi() and Multi()for historical reasons.


在 4.2 版更改: If multiple yieldables fail, any exceptions after the first(which is raised) will be logged. Added the quiet_exceptionsargument to suppress this logging for selected exception types.



在 4.3 版更改: Replaced the class Multi and the function multi_futurewith a unified function multi. Added support for yieldablesother than YieldPoint and .

tornado.gen.multi_future(_children, quiet_exceptions=())[源代码]

Wait for multiple asynchronous futures in parallel.

This function is similar to multi, but does not support.


4.0 新版功能.



在 4.2 版更改: If multiple Futures fail, any exceptions after the first (which israised) will be logged. Added the quietexceptionsargument to suppress this logging for selected exception types.



4.3 版后已移除: Use multi instead.

tornado.gen.Task(_func, *args, **kwargs)¶

Adapts a callback-based asynchronous function for use in coroutines.

Takes a function (and optional additional arguments) and runs it withthose arguments plus a callback keyword argument. The argument passedto the callback is returned as the result of the yield expression.


在 4.0 版更改: gen.Task is now a function that returns a , instead ofa subclass of YieldPoint. It still behaves the same way whenyielded.

class tornado.gen.Arguments

The result of a or whose callback had more than oneargument (or keyword arguments).

The Arguments object is a and can beused either as a tuple (args, kwargs) or an object with attributesargs and kwargs.

tornado.gen.convertyielded(args, *kw)[源代码]

Convert a yielded object into a Future.

The default implementation accepts lists, dictionaries, and Futures.

If the library is available, this functionmay be extended to support additional types. For example:

4.1 新版功能.

tornado.gen.maybe_future(_x)[源代码]

Converts x into a Future.

If x is already a , it is simply returned; otherwiseit is wrapped in a new Future. This is suitable for use asresult = yield gen.maybe_future(f()) when you don’t know whetherf() returns a or not.


4.3 版后已移除: This function only handles Futures, not other yieldable objects.Instead of maybe_future, check for the non-future result typesyou expect (often just None), and yield anything unknown.

Before support for was introduced in Tornado 3.0,coroutines used subclasses of YieldPoint in their yield expressions.These classes are still supported but should generally not be usedexcept for compatibility with older interfaces. None of these classesare compatible with native (await-based) coroutines.

class tornado.gen.YieldPoint¶

Base class for objects that may be yielded from the generator.


4.0 版后已移除: Use instead.

start(runner)[源代码]

Called by the runner after the generator has yielded.

No other methods will be called on this object before start.

isready()[源代码]

Called by the runner to determine whether to resume the generator.

Returns a boolean; may be called more than once.

get_result()[源代码]

Returns the value to use as the result of the yield expression.

This method will only be called once, and only after is_readyhas returned true.

_class tornado.gen.Callback(key)¶

Returns a callable object that will allow a matching to proceed.

The key may be any value suitable for use as a dictionary key, and isused to match Callbacks to their corresponding Waits. The keymust be unique among outstanding callbacks within a single run of thegenerator function, but may be reused across different runs of the samefunction (so constants generally work fine).

The callback may be called with zero or one arguments; if an argumentis given it will be returned by Wait.


4.0 版后已移除: Use instead.

class tornado.gen.Wait(key)[源代码]

Returns the argument passed to the result of a previous Callback.


4.0 版后已移除: Use instead.

class tornado.gen.WaitAll(keys)[源代码]

Returns the results of multiple previous Callbacks.

The argument is a sequence of keys, and the result isa list of results in the same order.

WaitAll is equivalent to yielding a list of objects.


4.0 版后已移除: Use Futures instead.

class tornado.gen.MultiYieldPoint(children, quiet_exceptions=())¶

Runs multiple asynchronous operations in parallel.

This class is similar to , but it always creates a stackcontext even when no children require it. It is not compatible withnative coroutines.


在 4.2 版更改: If multiple YieldPoints fail, any exceptions after the first(which is raised) will be logged. Added the quiet_exceptionsargument to suppress this logging for selected exception types.



在 4.3 版更改: Renamed from Multi to MultiYieldPoint. The name Multiremains as an alias for the equivalent multi function.



4.3 版后已移除: Use instead.

原文: