2013-12-20 15:37:39 -04:00
|
|
|
.. currentmodule:: asyncio
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
|
|
|
|
====================
|
|
|
|
Coroutines and Tasks
|
2013-12-02 20:08:00 -04:00
|
|
|
====================
|
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
This section outlines high-level asyncio APIs to work with coroutines
|
|
|
|
and Tasks.
|
|
|
|
|
|
|
|
.. contents::
|
|
|
|
:depth: 1
|
|
|
|
:local:
|
2017-07-25 20:03:51 -03:00
|
|
|
|
|
|
|
|
2013-12-02 20:08:00 -04:00
|
|
|
.. _coroutine:
|
|
|
|
|
|
|
|
Coroutines
|
2018-09-14 17:32:07 -03:00
|
|
|
==========
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2019-10-10 20:18:46 -03:00
|
|
|
:term:`Coroutines <coroutine>` declared with the async/await syntax is the
|
|
|
|
preferred way of writing asyncio applications. For example, the following
|
|
|
|
snippet of code (requires Python 3.7+) prints "hello", waits 1 second,
|
2018-09-18 03:47:54 -03:00
|
|
|
and then prints "world"::
|
2015-06-24 12:04:15 -03:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
>>> import asyncio
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
>>> async def main():
|
|
|
|
... print('hello')
|
|
|
|
... await asyncio.sleep(1)
|
|
|
|
... print('world')
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
>>> asyncio.run(main())
|
|
|
|
hello
|
|
|
|
world
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
Note that simply calling a coroutine will not schedule it to
|
|
|
|
be executed::
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
>>> main()
|
|
|
|
<coroutine object main at 0x1053bb7c8>
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2019-05-19 06:01:36 -03:00
|
|
|
To actually run a coroutine, asyncio provides three main mechanisms:
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-09-17 20:16:44 -03:00
|
|
|
* The :func:`asyncio.run` function to run the top-level
|
2018-09-14 17:32:07 -03:00
|
|
|
entry point "main()" function (see the above example.)
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-09-17 20:16:44 -03:00
|
|
|
* Awaiting on a coroutine. The following snippet of code will
|
2018-09-14 17:32:07 -03:00
|
|
|
print "hello" after waiting for 1 second, and then print "world"
|
|
|
|
after waiting for *another* 2 seconds::
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
import asyncio
|
|
|
|
import time
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
async def say_after(delay, what):
|
|
|
|
await asyncio.sleep(delay)
|
|
|
|
print(what)
|
2014-08-10 20:11:13 -03:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
async def main():
|
2018-10-24 19:37:12 -03:00
|
|
|
print(f"started at {time.strftime('%X')}")
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
await say_after(1, 'hello')
|
|
|
|
await say_after(2, 'world')
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-10-24 19:37:12 -03:00
|
|
|
print(f"finished at {time.strftime('%X')}")
|
2014-01-16 13:58:01 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
asyncio.run(main())
|
2015-06-24 12:04:15 -03:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
Expected output::
|
2014-01-16 13:58:01 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
started at 17:13:52
|
|
|
|
hello
|
|
|
|
world
|
|
|
|
finished at 17:13:55
|
2014-01-16 13:58:01 -04:00
|
|
|
|
2018-09-17 20:16:44 -03:00
|
|
|
* The :func:`asyncio.create_task` function to run coroutines
|
2018-09-14 17:32:07 -03:00
|
|
|
concurrently as asyncio :class:`Tasks <Task>`.
|
|
|
|
|
2018-09-18 01:49:21 -03:00
|
|
|
Let's modify the above example and run two ``say_after`` coroutines
|
2018-09-14 17:32:07 -03:00
|
|
|
*concurrently*::
|
|
|
|
|
|
|
|
async def main():
|
|
|
|
task1 = asyncio.create_task(
|
|
|
|
say_after(1, 'hello'))
|
|
|
|
|
|
|
|
task2 = asyncio.create_task(
|
|
|
|
say_after(2, 'world'))
|
|
|
|
|
2018-10-24 19:37:12 -03:00
|
|
|
print(f"started at {time.strftime('%X')}")
|
2014-02-20 17:20:44 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
# Wait until both tasks are completed (should take
|
|
|
|
# around 2 seconds.)
|
|
|
|
await task1
|
|
|
|
await task2
|
2014-02-20 17:20:44 -04:00
|
|
|
|
2018-10-24 19:37:12 -03:00
|
|
|
print(f"finished at {time.strftime('%X')}")
|
2018-09-14 17:32:07 -03:00
|
|
|
|
|
|
|
Note that expected output now shows that the snippet runs
|
|
|
|
1 second faster than before::
|
|
|
|
|
|
|
|
started at 17:14:32
|
|
|
|
hello
|
|
|
|
world
|
|
|
|
finished at 17:14:34
|
|
|
|
|
2018-09-18 18:55:44 -03:00
|
|
|
|
|
|
|
.. _asyncio-awaitables:
|
|
|
|
|
|
|
|
Awaitables
|
|
|
|
==========
|
|
|
|
|
2018-09-20 13:43:59 -03:00
|
|
|
We say that an object is an **awaitable** object if it can be used
|
|
|
|
in an :keyword:`await` expression. Many asyncio APIs are designed to
|
|
|
|
accept awaitables.
|
2018-09-18 18:55:44 -03:00
|
|
|
|
2018-09-20 13:43:59 -03:00
|
|
|
There are three main types of *awaitable* objects:
|
|
|
|
**coroutines**, **Tasks**, and **Futures**.
|
2018-09-18 18:55:44 -03:00
|
|
|
|
|
|
|
|
2018-09-20 13:43:59 -03:00
|
|
|
.. rubric:: Coroutines
|
|
|
|
|
|
|
|
Python coroutines are *awaitables* and therefore can be awaited from
|
|
|
|
other coroutines::
|
|
|
|
|
|
|
|
import asyncio
|
2018-09-18 18:55:44 -03:00
|
|
|
|
|
|
|
async def nested():
|
|
|
|
return 42
|
|
|
|
|
|
|
|
async def main():
|
2018-09-20 13:43:59 -03:00
|
|
|
# Nothing happens if we just call "nested()".
|
2018-09-21 17:23:15 -03:00
|
|
|
# A coroutine object is created but not awaited,
|
|
|
|
# so it *won't run at all*.
|
2018-09-20 13:43:59 -03:00
|
|
|
nested()
|
|
|
|
|
|
|
|
# Let's do it differently now and await it:
|
|
|
|
print(await nested()) # will print "42".
|
|
|
|
|
|
|
|
asyncio.run(main())
|
|
|
|
|
|
|
|
.. important::
|
|
|
|
|
|
|
|
In this documentation the term "coroutine" can be used for
|
|
|
|
two closely related concepts:
|
|
|
|
|
|
|
|
* a *coroutine function*: an :keyword:`async def` function;
|
|
|
|
|
|
|
|
* a *coroutine object*: an object returned by calling a
|
|
|
|
*coroutine function*.
|
|
|
|
|
|
|
|
asyncio also supports legacy :ref:`generator-based
|
|
|
|
<asyncio_generator_based_coro>` coroutines.
|
|
|
|
|
|
|
|
|
|
|
|
.. rubric:: Tasks
|
2018-09-18 18:55:44 -03:00
|
|
|
|
|
|
|
*Tasks* are used to schedule coroutines *concurrently*.
|
|
|
|
|
2018-09-20 13:43:59 -03:00
|
|
|
When a coroutine is wrapped into a *Task* with functions like
|
|
|
|
:func:`asyncio.create_task` the coroutine is automatically
|
|
|
|
scheduled to run soon::
|
|
|
|
|
|
|
|
import asyncio
|
|
|
|
|
|
|
|
async def nested():
|
|
|
|
return 42
|
2018-09-14 17:32:07 -03:00
|
|
|
|
2018-09-20 13:43:59 -03:00
|
|
|
async def main():
|
|
|
|
# Schedule nested() to run soon concurrently
|
|
|
|
# with "main()".
|
|
|
|
task = asyncio.create_task(nested())
|
2018-09-14 17:32:07 -03:00
|
|
|
|
2018-09-20 13:43:59 -03:00
|
|
|
# "task" can now be used to cancel "nested()", or
|
|
|
|
# can simply be awaited to wait until it is complete:
|
|
|
|
await task
|
|
|
|
|
|
|
|
asyncio.run(main())
|
2018-09-14 17:32:07 -03:00
|
|
|
|
|
|
|
|
2018-09-18 18:55:44 -03:00
|
|
|
.. rubric:: Futures
|
|
|
|
|
2018-09-20 13:43:59 -03:00
|
|
|
A :class:`Future` is a special **low-level** awaitable object that
|
|
|
|
represents an **eventual result** of an asynchronous operation.
|
|
|
|
|
|
|
|
When a Future object is *awaited* it means that the coroutine will
|
|
|
|
wait until the Future is resolved in some other place.
|
2018-09-18 18:55:44 -03:00
|
|
|
|
|
|
|
Future objects in asyncio are needed to allow callback-based code
|
|
|
|
to be used with async/await.
|
|
|
|
|
2018-09-20 13:43:59 -03:00
|
|
|
Normally **there is no need** to create Future objects at the
|
2018-09-18 18:55:44 -03:00
|
|
|
application level code.
|
|
|
|
|
|
|
|
Future objects, sometimes exposed by libraries and some asyncio
|
2018-09-20 13:43:59 -03:00
|
|
|
APIs, can be awaited::
|
2018-09-18 18:55:44 -03:00
|
|
|
|
|
|
|
async def main():
|
|
|
|
await function_that_returns_a_future_object()
|
|
|
|
|
|
|
|
# this is also valid:
|
|
|
|
await asyncio.gather(
|
|
|
|
function_that_returns_a_future_object(),
|
|
|
|
some_python_coroutine()
|
|
|
|
)
|
|
|
|
|
2018-09-20 13:43:59 -03:00
|
|
|
A good example of a low-level function that returns a Future object
|
|
|
|
is :meth:`loop.run_in_executor`.
|
|
|
|
|
2018-09-18 18:55:44 -03:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
Running an asyncio Program
|
|
|
|
==========================
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-05-20 00:15:06 -03:00
|
|
|
.. function:: run(coro, \*, debug=False)
|
2017-12-14 10:42:21 -04:00
|
|
|
|
2019-09-30 21:12:21 -03:00
|
|
|
Execute the :term:`coroutine` *coro* and return the result.
|
|
|
|
|
2017-12-14 10:42:21 -04:00
|
|
|
This function runs the passed coroutine, taking care of
|
2019-09-19 09:47:22 -03:00
|
|
|
managing the asyncio event loop, *finalizing asynchronous
|
|
|
|
generators*, and closing the threadpool.
|
2017-12-14 10:42:21 -04:00
|
|
|
|
|
|
|
This function cannot be called when another asyncio event loop is
|
|
|
|
running in the same thread.
|
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
If *debug* is ``True``, the event loop will be run in debug mode.
|
2017-12-14 10:42:21 -04:00
|
|
|
|
|
|
|
This function always creates a new event loop and closes it at
|
|
|
|
the end. It should be used as a main entry point for asyncio
|
|
|
|
programs, and should ideally only be called once.
|
|
|
|
|
2019-09-25 05:53:49 -03:00
|
|
|
Example::
|
|
|
|
|
|
|
|
async def main():
|
|
|
|
await asyncio.sleep(1)
|
|
|
|
print('hello')
|
|
|
|
|
|
|
|
asyncio.run(main())
|
|
|
|
|
2017-12-14 10:42:21 -04:00
|
|
|
.. versionadded:: 3.7
|
|
|
|
|
2019-09-19 09:47:22 -03:00
|
|
|
.. versionchanged:: 3.9
|
|
|
|
Updated to use :meth:`loop.shutdown_default_executor`.
|
2017-12-14 10:42:21 -04:00
|
|
|
|
2019-10-10 20:18:46 -03:00
|
|
|
.. note::
|
|
|
|
The source code for ``asyncio.run()`` can be found in
|
|
|
|
:source:`Lib/asyncio/runners.py`.
|
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
Creating Tasks
|
|
|
|
==============
|
2013-12-09 21:09:46 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
.. function:: create_task(coro, \*, name=None)
|
2013-12-09 21:09:46 -04:00
|
|
|
|
2018-09-20 13:43:59 -03:00
|
|
|
Wrap the *coro* :ref:`coroutine <coroutine>` into a :class:`Task`
|
|
|
|
and schedule its execution. Return the Task object.
|
2013-12-09 21:09:46 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
If *name* is not ``None``, it is set as the name of the task using
|
|
|
|
:meth:`Task.set_name`.
|
|
|
|
|
2018-09-17 20:16:44 -03:00
|
|
|
The task is executed in the loop returned by :func:`get_running_loop`,
|
2018-09-14 17:32:07 -03:00
|
|
|
:exc:`RuntimeError` is raised if there is no running loop in
|
|
|
|
current thread.
|
|
|
|
|
2018-09-18 18:55:44 -03:00
|
|
|
This function has been **added in Python 3.7**. Prior to
|
|
|
|
Python 3.7, the low-level :func:`asyncio.ensure_future` function
|
|
|
|
can be used instead::
|
|
|
|
|
|
|
|
async def coro():
|
|
|
|
...
|
|
|
|
|
|
|
|
# In Python 3.7+
|
|
|
|
task = asyncio.create_task(coro())
|
|
|
|
...
|
|
|
|
|
|
|
|
# This works in all Python versions but is less readable
|
|
|
|
task = asyncio.ensure_future(coro())
|
|
|
|
...
|
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
.. versionadded:: 3.7
|
2013-12-09 21:09:46 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
.. versionchanged:: 3.8
|
|
|
|
Added the ``name`` parameter.
|
2014-10-15 13:49:16 -03:00
|
|
|
|
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
Sleeping
|
|
|
|
========
|
2014-10-15 13:49:16 -03:00
|
|
|
|
2020-11-29 08:50:57 -04:00
|
|
|
.. coroutinefunction:: sleep(delay, result=None)
|
2014-10-15 13:49:16 -03:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
Block for *delay* seconds.
|
2014-10-15 13:49:16 -03:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
If *result* is provided, it is returned to the caller
|
|
|
|
when the coroutine completes.
|
2014-10-15 13:49:16 -03:00
|
|
|
|
2018-10-01 07:09:38 -03:00
|
|
|
``sleep()`` always suspends the current task, allowing other tasks
|
|
|
|
to run.
|
|
|
|
|
2018-09-14 19:11:24 -03:00
|
|
|
.. _asyncio_example_sleep:
|
2014-10-15 13:49:16 -03:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
Example of coroutine displaying the current date every second
|
2018-09-17 20:16:44 -03:00
|
|
|
for 5 seconds::
|
2014-10-15 13:49:16 -03:00
|
|
|
|
|
|
|
import asyncio
|
|
|
|
import datetime
|
|
|
|
|
2017-12-14 10:42:21 -04:00
|
|
|
async def display_date():
|
|
|
|
loop = asyncio.get_running_loop()
|
2014-10-15 13:49:16 -03:00
|
|
|
end_time = loop.time() + 5.0
|
2013-12-09 21:09:46 -04:00
|
|
|
while True:
|
2014-10-15 13:49:16 -03:00
|
|
|
print(datetime.datetime.now())
|
|
|
|
if (loop.time() + 1.0) >= end_time:
|
|
|
|
break
|
2015-06-24 12:04:15 -03:00
|
|
|
await asyncio.sleep(1)
|
2013-12-09 21:09:46 -04:00
|
|
|
|
2017-12-14 10:42:21 -04:00
|
|
|
asyncio.run(display_date())
|
2013-12-09 21:09:46 -04:00
|
|
|
|
2013-12-03 14:17:25 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
Running Tasks Concurrently
|
|
|
|
==========================
|
2013-12-03 14:17:25 -04:00
|
|
|
|
2020-11-29 08:50:57 -04:00
|
|
|
.. awaitablefunction:: gather(\*aws, return_exceptions=False)
|
2013-12-03 14:17:25 -04:00
|
|
|
|
2018-09-20 13:43:59 -03:00
|
|
|
Run :ref:`awaitable objects <asyncio-awaitables>` in the *aws*
|
2018-09-18 18:55:44 -03:00
|
|
|
sequence *concurrently*.
|
2013-12-03 14:17:25 -04:00
|
|
|
|
2018-09-20 13:43:59 -03:00
|
|
|
If any awaitable in *aws* is a coroutine, it is automatically
|
2018-09-18 18:55:44 -03:00
|
|
|
scheduled as a Task.
|
2013-12-03 14:17:25 -04:00
|
|
|
|
2018-09-18 18:55:44 -03:00
|
|
|
If all awaitables are completed successfully, the result is an
|
|
|
|
aggregate list of returned values. The order of result values
|
2018-09-20 13:43:59 -03:00
|
|
|
corresponds to the order of awaitables in *aws*.
|
2013-12-03 14:17:25 -04:00
|
|
|
|
2018-09-21 17:23:15 -03:00
|
|
|
If *return_exceptions* is ``False`` (default), the first
|
|
|
|
raised exception is immediately propagated to the task that
|
|
|
|
awaits on ``gather()``. Other awaitables in the *aws* sequence
|
|
|
|
**won't be cancelled** and will continue to run.
|
|
|
|
|
2018-09-18 18:55:44 -03:00
|
|
|
If *return_exceptions* is ``True``, exceptions are treated the
|
|
|
|
same as successful results, and aggregated in the result list.
|
2013-12-03 14:17:25 -04:00
|
|
|
|
2018-09-21 17:23:15 -03:00
|
|
|
If ``gather()`` is *cancelled*, all submitted awaitables
|
2018-09-14 17:32:07 -03:00
|
|
|
(that have not completed yet) are also *cancelled*.
|
2013-12-03 14:17:25 -04:00
|
|
|
|
2018-09-20 13:43:59 -03:00
|
|
|
If any Task or Future from the *aws* sequence is *cancelled*, it is
|
2018-09-18 18:55:44 -03:00
|
|
|
treated as if it raised :exc:`CancelledError` -- the ``gather()``
|
|
|
|
call is **not** cancelled in this case. This is to prevent the
|
|
|
|
cancellation of one submitted Task/Future to cause other
|
|
|
|
Tasks/Futures to be cancelled.
|
2017-12-23 16:04:15 -04:00
|
|
|
|
2018-09-14 19:11:24 -03:00
|
|
|
.. _asyncio_example_gather:
|
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
Example::
|
2017-12-23 16:04:15 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
import asyncio
|
2013-12-03 14:17:25 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
async def factorial(name, number):
|
|
|
|
f = 1
|
|
|
|
for i in range(2, number + 1):
|
|
|
|
print(f"Task {name}: Compute factorial({i})...")
|
|
|
|
await asyncio.sleep(1)
|
|
|
|
f *= i
|
|
|
|
print(f"Task {name}: factorial({number}) = {f}")
|
2013-12-09 21:09:46 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
async def main():
|
2018-09-18 18:55:44 -03:00
|
|
|
# Schedule three calls *concurrently*:
|
2018-09-14 17:32:07 -03:00
|
|
|
await asyncio.gather(
|
|
|
|
factorial("A", 2),
|
|
|
|
factorial("B", 3),
|
|
|
|
factorial("C", 4),
|
2018-09-18 03:01:26 -03:00
|
|
|
)
|
2013-12-09 21:09:46 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
asyncio.run(main())
|
2013-12-09 21:09:46 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
# Expected output:
|
|
|
|
#
|
|
|
|
# Task A: Compute factorial(2)...
|
|
|
|
# Task B: Compute factorial(2)...
|
|
|
|
# Task C: Compute factorial(2)...
|
|
|
|
# Task A: factorial(2) = 2
|
|
|
|
# Task B: Compute factorial(3)...
|
|
|
|
# Task C: Compute factorial(3)...
|
|
|
|
# Task B: factorial(3) = 6
|
|
|
|
# Task C: Compute factorial(4)...
|
|
|
|
# Task C: factorial(4) = 24
|
2013-12-09 21:09:46 -04:00
|
|
|
|
2020-07-20 05:42:57 -03:00
|
|
|
.. note::
|
|
|
|
If *return_exceptions* is False, cancelling gather() after it
|
|
|
|
has been marked done won't cancel any submitted awaitables.
|
|
|
|
For instance, gather can be marked done after propagating an
|
|
|
|
exception to the caller, therefore, calling ``gather.cancel()``
|
|
|
|
after catching an exception (raised by one of the awaitables) from
|
|
|
|
gather won't cancel any other awaitables.
|
|
|
|
|
2018-09-18 18:55:44 -03:00
|
|
|
.. versionchanged:: 3.7
|
|
|
|
If the *gather* itself is cancelled, the cancellation is
|
|
|
|
propagated regardless of *return_exceptions*.
|
|
|
|
|
2013-12-09 21:09:46 -04:00
|
|
|
|
2018-09-21 17:23:15 -03:00
|
|
|
Shielding From Cancellation
|
|
|
|
===========================
|
2013-12-09 21:09:46 -04:00
|
|
|
|
2020-11-29 08:50:57 -04:00
|
|
|
.. awaitablefunction:: shield(aw)
|
2013-12-09 21:09:46 -04:00
|
|
|
|
2018-09-18 18:55:44 -03:00
|
|
|
Protect an :ref:`awaitable object <asyncio-awaitables>`
|
|
|
|
from being :meth:`cancelled <Task.cancel>`.
|
2013-12-09 21:09:46 -04:00
|
|
|
|
2018-09-21 17:23:15 -03:00
|
|
|
If *aw* is a coroutine it is automatically scheduled as a Task.
|
2013-12-09 21:09:46 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
The statement::
|
2013-12-09 21:09:46 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
res = await shield(something())
|
2013-12-09 21:09:46 -04:00
|
|
|
|
2018-09-17 20:16:44 -03:00
|
|
|
is equivalent to::
|
2013-12-09 21:09:46 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
res = await something()
|
2013-12-09 21:09:46 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
*except* that if the coroutine containing it is cancelled, the
|
|
|
|
Task running in ``something()`` is not cancelled. From the point
|
|
|
|
of view of ``something()``, the cancellation did not happen.
|
|
|
|
Although its caller is still cancelled, so the "await" expression
|
2018-09-17 20:16:44 -03:00
|
|
|
still raises a :exc:`CancelledError`.
|
2013-12-09 21:09:46 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
If ``something()`` is cancelled by other means (i.e. from within
|
|
|
|
itself) that would also cancel ``shield()``.
|
2013-12-09 21:09:46 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
If it is desired to completely ignore cancellation (not recommended)
|
|
|
|
the ``shield()`` function should be combined with a try/except
|
|
|
|
clause, as follows::
|
2013-12-09 21:09:46 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
try:
|
|
|
|
res = await shield(something())
|
|
|
|
except CancelledError:
|
|
|
|
res = None
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2017-12-15 01:04:38 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
Timeouts
|
|
|
|
========
|
2018-08-08 18:06:47 -03:00
|
|
|
|
2020-11-29 08:50:57 -04:00
|
|
|
.. coroutinefunction:: wait_for(aw, timeout)
|
2017-12-15 01:04:38 -04:00
|
|
|
|
2018-09-20 13:43:59 -03:00
|
|
|
Wait for the *aw* :ref:`awaitable <asyncio-awaitables>`
|
2018-09-18 18:55:44 -03:00
|
|
|
to complete with a timeout.
|
2017-12-15 01:04:38 -04:00
|
|
|
|
2018-09-20 13:43:59 -03:00
|
|
|
If *aw* is a coroutine it is automatically scheduled as a Task.
|
2017-12-15 01:04:38 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
*timeout* can either be ``None`` or a float or int number of seconds
|
|
|
|
to wait for. If *timeout* is ``None``, block until the future
|
|
|
|
completes.
|
2018-08-08 18:06:47 -03:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
If a timeout occurs, it cancels the task and raises
|
|
|
|
:exc:`asyncio.TimeoutError`.
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-09-18 18:55:44 -03:00
|
|
|
To avoid the task :meth:`cancellation <Task.cancel>`,
|
|
|
|
wrap it in :func:`shield`.
|
2014-07-08 07:39:10 -03:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
The function will wait until the future is actually cancelled,
|
2020-05-15 17:12:05 -03:00
|
|
|
so the total wait time may exceed the *timeout*. If an exception
|
|
|
|
happens during cancellation, it is propagated.
|
2014-07-08 07:39:10 -03:00
|
|
|
|
2018-09-20 13:43:59 -03:00
|
|
|
If the wait is cancelled, the future *aw* is also cancelled.
|
2014-07-08 07:39:10 -03:00
|
|
|
|
2018-09-14 19:11:24 -03:00
|
|
|
.. _asyncio_example_waitfor:
|
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
Example::
|
2014-07-08 07:39:10 -03:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
async def eternity():
|
|
|
|
# Sleep for one hour
|
|
|
|
await asyncio.sleep(3600)
|
|
|
|
print('yay!')
|
2014-07-08 07:39:10 -03:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
async def main():
|
|
|
|
# Wait for at most 1 second
|
|
|
|
try:
|
|
|
|
await asyncio.wait_for(eternity(), timeout=1.0)
|
|
|
|
except asyncio.TimeoutError:
|
|
|
|
print('timeout!')
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
asyncio.run(main())
|
2018-05-23 14:35:04 -03:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
# Expected output:
|
|
|
|
#
|
|
|
|
# timeout!
|
2015-02-25 09:24:15 -04:00
|
|
|
|
2018-05-23 14:35:04 -03:00
|
|
|
.. versionchanged:: 3.7
|
2018-09-20 13:43:59 -03:00
|
|
|
When *aw* is cancelled due to a timeout, ``wait_for`` waits
|
|
|
|
for *aw* to be cancelled. Previously, it raised
|
2018-09-14 17:32:07 -03:00
|
|
|
:exc:`asyncio.TimeoutError` immediately.
|
2018-08-08 18:06:47 -03:00
|
|
|
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
Waiting Primitives
|
|
|
|
==================
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2020-11-29 08:50:57 -04:00
|
|
|
.. coroutinefunction:: wait(aws, \*, timeout=None, return_when=ALL_COMPLETED)
|
2014-06-02 18:06:46 -03:00
|
|
|
|
2018-09-20 13:43:59 -03:00
|
|
|
Run :ref:`awaitable objects <asyncio-awaitables>` in the *aws*
|
2020-11-02 06:56:35 -04:00
|
|
|
iterable concurrently and block until the condition specified
|
2018-09-18 18:55:44 -03:00
|
|
|
by *return_when*.
|
2014-06-02 18:06:46 -03:00
|
|
|
|
2020-11-02 06:56:35 -04:00
|
|
|
The *aws* iterable must not be empty.
|
2020-05-04 18:56:00 -03:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
Returns two sets of Tasks/Futures: ``(done, pending)``.
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-09-25 15:51:21 -03:00
|
|
|
Usage::
|
|
|
|
|
|
|
|
done, pending = await asyncio.wait(aws)
|
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
*timeout* (a float or int), if specified, can be used to control
|
|
|
|
the maximum number of seconds to wait before returning.
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
Note that this function does not raise :exc:`asyncio.TimeoutError`.
|
2018-09-17 20:16:44 -03:00
|
|
|
Futures or Tasks that aren't done when the timeout occurs are simply
|
2018-09-14 17:32:07 -03:00
|
|
|
returned in the second set.
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
*return_when* indicates when this function should return. It must
|
|
|
|
be one of the following constants:
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
.. tabularcolumns:: |l|L|
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
+-----------------------------+----------------------------------------+
|
|
|
|
| Constant | Description |
|
|
|
|
+=============================+========================================+
|
|
|
|
| :const:`FIRST_COMPLETED` | The function will return when any |
|
|
|
|
| | future finishes or is cancelled. |
|
|
|
|
+-----------------------------+----------------------------------------+
|
|
|
|
| :const:`FIRST_EXCEPTION` | The function will return when any |
|
|
|
|
| | future finishes by raising an |
|
|
|
|
| | exception. If no future raises an |
|
|
|
|
| | exception then it is equivalent to |
|
|
|
|
| | :const:`ALL_COMPLETED`. |
|
|
|
|
+-----------------------------+----------------------------------------+
|
|
|
|
| :const:`ALL_COMPLETED` | The function will return when all |
|
|
|
|
| | futures finish or are cancelled. |
|
|
|
|
+-----------------------------+----------------------------------------+
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
Unlike :func:`~asyncio.wait_for`, ``wait()`` does not cancel the
|
|
|
|
futures when a timeout occurs.
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2019-09-12 09:40:40 -03:00
|
|
|
.. deprecated:: 3.8
|
|
|
|
|
|
|
|
If any awaitable in *aws* is a coroutine, it is automatically
|
|
|
|
scheduled as a Task. Passing coroutines objects to
|
|
|
|
``wait()`` directly is deprecated as it leads to
|
|
|
|
:ref:`confusing behavior <asyncio_example_wait_coroutine>`.
|
|
|
|
|
2018-09-25 15:51:21 -03:00
|
|
|
.. _asyncio_example_wait_coroutine:
|
|
|
|
.. note::
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-09-25 15:51:21 -03:00
|
|
|
``wait()`` schedules coroutines as Tasks automatically and later
|
|
|
|
returns those implicitly created Task objects in ``(done, pending)``
|
|
|
|
sets. Therefore the following code won't work as expected::
|
|
|
|
|
|
|
|
async def foo():
|
|
|
|
return 42
|
|
|
|
|
|
|
|
coro = foo()
|
|
|
|
done, pending = await asyncio.wait({coro})
|
|
|
|
|
|
|
|
if coro in done:
|
|
|
|
# This branch will never be run!
|
|
|
|
|
|
|
|
Here is how the above snippet can be fixed::
|
|
|
|
|
|
|
|
async def foo():
|
|
|
|
return 42
|
|
|
|
|
|
|
|
task = asyncio.create_task(foo())
|
|
|
|
done, pending = await asyncio.wait({task})
|
|
|
|
|
|
|
|
if task in done:
|
|
|
|
# Everything will work as expected now.
|
|
|
|
|
2020-05-13 15:55:12 -03:00
|
|
|
.. deprecated-removed:: 3.8 3.11
|
2019-05-21 03:20:10 -03:00
|
|
|
|
2018-09-25 15:51:21 -03:00
|
|
|
Passing coroutine objects to ``wait()`` directly is
|
|
|
|
deprecated.
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-08-08 18:06:47 -03:00
|
|
|
|
2020-11-29 08:50:57 -04:00
|
|
|
.. function:: as_completed(aws, \*, timeout=None)
|
2018-08-08 18:06:47 -03:00
|
|
|
|
2018-09-20 13:43:59 -03:00
|
|
|
Run :ref:`awaitable objects <asyncio-awaitables>` in the *aws*
|
2020-11-02 06:56:35 -04:00
|
|
|
iterable concurrently. Return an iterator of coroutines.
|
2020-05-23 20:14:31 -03:00
|
|
|
Each coroutine returned can be awaited to get the earliest next
|
2020-11-02 06:56:35 -04:00
|
|
|
result from the iterable of the remaining awaitables.
|
2018-08-08 18:06:47 -03:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
Raises :exc:`asyncio.TimeoutError` if the timeout occurs before
|
|
|
|
all Futures are done.
|
2018-08-08 18:06:47 -03:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
Example::
|
2018-08-08 18:06:47 -03:00
|
|
|
|
2020-05-23 20:14:31 -03:00
|
|
|
for coro in as_completed(aws):
|
|
|
|
earliest_result = await coro
|
2018-09-14 17:32:07 -03:00
|
|
|
# ...
|
2018-08-08 18:06:47 -03:00
|
|
|
|
|
|
|
|
2020-05-19 00:03:28 -03:00
|
|
|
Running in Threads
|
|
|
|
==================
|
|
|
|
|
|
|
|
.. coroutinefunction:: to_thread(func, /, \*args, \*\*kwargs)
|
|
|
|
|
|
|
|
Asynchronously run function *func* in a separate thread.
|
|
|
|
|
|
|
|
Any \*args and \*\*kwargs supplied for this function are directly passed
|
2020-11-23 19:56:30 -04:00
|
|
|
to *func*. Also, the current :class:`contextvars.Context` is propagated,
|
2020-05-21 02:20:43 -03:00
|
|
|
allowing context variables from the event loop thread to be accessed in the
|
|
|
|
separate thread.
|
2020-05-19 00:03:28 -03:00
|
|
|
|
2020-05-31 04:07:04 -03:00
|
|
|
Return a coroutine that can be awaited to get the eventual result of *func*.
|
2020-05-19 00:03:28 -03:00
|
|
|
|
|
|
|
This coroutine function is primarily intended to be used for executing
|
|
|
|
IO-bound functions/methods that would otherwise block the event loop if
|
|
|
|
they were ran in the main thread. For example::
|
|
|
|
|
|
|
|
def blocking_io():
|
|
|
|
print(f"start blocking_io at {time.strftime('%X')}")
|
|
|
|
# Note that time.sleep() can be replaced with any blocking
|
|
|
|
# IO-bound operation, such as file operations.
|
|
|
|
time.sleep(1)
|
|
|
|
print(f"blocking_io complete at {time.strftime('%X')}")
|
|
|
|
|
|
|
|
async def main():
|
|
|
|
print(f"started main at {time.strftime('%X')}")
|
|
|
|
|
|
|
|
await asyncio.gather(
|
|
|
|
asyncio.to_thread(blocking_io),
|
|
|
|
asyncio.sleep(1))
|
|
|
|
|
|
|
|
print(f"finished main at {time.strftime('%X')}")
|
|
|
|
|
|
|
|
|
|
|
|
asyncio.run(main())
|
|
|
|
|
|
|
|
# Expected output:
|
|
|
|
#
|
|
|
|
# started main at 19:50:53
|
|
|
|
# start blocking_io at 19:50:53
|
|
|
|
# blocking_io complete at 19:50:54
|
|
|
|
# finished main at 19:50:54
|
|
|
|
|
|
|
|
Directly calling `blocking_io()` in any coroutine would block the event loop
|
|
|
|
for its duration, resulting in an additional 1 second of run time. Instead,
|
|
|
|
by using `asyncio.to_thread()`, we can run it in a separate thread without
|
|
|
|
blocking the event loop.
|
|
|
|
|
|
|
|
.. note::
|
|
|
|
|
|
|
|
Due to the :term:`GIL`, `asyncio.to_thread()` can typically only be used
|
|
|
|
to make IO-bound functions non-blocking. However, for extension modules
|
|
|
|
that release the GIL or alternative Python implementations that don't
|
|
|
|
have one, `asyncio.to_thread()` can also be used for CPU-bound functions.
|
|
|
|
|
2020-05-21 02:20:43 -03:00
|
|
|
.. versionadded:: 3.9
|
|
|
|
|
2020-05-19 00:03:28 -03:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
Scheduling From Other Threads
|
|
|
|
=============================
|
2018-08-08 18:06:47 -03:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
.. function:: run_coroutine_threadsafe(coro, loop)
|
2018-08-08 18:06:47 -03:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
Submit a coroutine to the given event loop. Thread-safe.
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-09-18 18:55:44 -03:00
|
|
|
Return a :class:`concurrent.futures.Future` to wait for the result
|
|
|
|
from another OS thread.
|
2013-12-09 21:09:46 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
This function is meant to be called from a different OS thread
|
|
|
|
than the one where the event loop is running. Example::
|
2013-12-09 21:09:46 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
# Create a coroutine
|
|
|
|
coro = asyncio.sleep(1, result=3)
|
2013-12-09 21:09:46 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
# Submit the coroutine to a given loop
|
|
|
|
future = asyncio.run_coroutine_threadsafe(coro, loop)
|
2013-12-09 21:09:46 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
# Wait for the result with an optional timeout argument
|
|
|
|
assert future.result(timeout) == 3
|
2013-12-09 21:09:46 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
If an exception is raised in the coroutine, the returned Future
|
|
|
|
will be notified. It can also be used to cancel the task in
|
|
|
|
the event loop::
|
2013-12-09 21:09:46 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
try:
|
|
|
|
result = future.result(timeout)
|
|
|
|
except asyncio.TimeoutError:
|
|
|
|
print('The coroutine took too long, cancelling the task...')
|
|
|
|
future.cancel()
|
|
|
|
except Exception as exc:
|
2018-10-24 19:37:12 -03:00
|
|
|
print(f'The coroutine raised an exception: {exc!r}')
|
2018-09-14 17:32:07 -03:00
|
|
|
else:
|
2018-10-24 19:37:12 -03:00
|
|
|
print(f'The coroutine returned: {result!r}')
|
2013-12-09 21:51:05 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
See the :ref:`concurrency and multithreading <asyncio-multithreading>`
|
|
|
|
section of the documentation.
|
2013-12-09 21:09:46 -04:00
|
|
|
|
2018-12-26 10:47:17 -04:00
|
|
|
Unlike other asyncio functions this function requires the *loop*
|
2018-09-14 17:32:07 -03:00
|
|
|
argument to be passed explicitly.
|
2013-12-09 21:09:46 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
.. versionadded:: 3.5.1
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2014-01-20 11:02:22 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
Introspection
|
|
|
|
=============
|
2014-01-20 11:02:22 -04:00
|
|
|
|
2017-12-16 15:58:38 -04:00
|
|
|
|
2018-03-12 15:50:50 -03:00
|
|
|
.. function:: current_task(loop=None)
|
2017-12-16 15:58:38 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
Return the currently running :class:`Task` instance, or ``None`` if
|
2017-12-16 15:58:38 -04:00
|
|
|
no task is running.
|
|
|
|
|
|
|
|
If *loop* is ``None`` :func:`get_running_loop` is used to get
|
|
|
|
the current loop.
|
|
|
|
|
|
|
|
.. versionadded:: 3.7
|
|
|
|
|
|
|
|
|
2018-03-12 15:50:50 -03:00
|
|
|
.. function:: all_tasks(loop=None)
|
2017-12-16 15:58:38 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
Return a set of not yet finished :class:`Task` objects run by
|
|
|
|
the loop.
|
2017-12-16 15:58:38 -04:00
|
|
|
|
2018-05-28 18:54:02 -03:00
|
|
|
If *loop* is ``None``, :func:`get_running_loop` is used for getting
|
2018-09-14 17:32:07 -03:00
|
|
|
current loop.
|
2017-12-16 15:58:38 -04:00
|
|
|
|
|
|
|
.. versionadded:: 3.7
|
|
|
|
|
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
Task Object
|
|
|
|
===========
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
.. class:: Task(coro, \*, loop=None, name=None)
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-09-21 17:23:15 -03:00
|
|
|
A :class:`Future-like <Future>` object that runs a Python
|
2018-09-14 17:32:07 -03:00
|
|
|
:ref:`coroutine <coroutine>`. Not thread-safe.
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
Tasks are used to run coroutines in event loops.
|
|
|
|
If a coroutine awaits on a Future, the Task suspends
|
|
|
|
the execution of the coroutine and waits for the completion
|
|
|
|
of the Future. When the Future is *done*, the execution of
|
|
|
|
the wrapped coroutine resumes.
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
Event loops use cooperative scheduling: an event loop runs
|
|
|
|
one Task at a time. While a Task awaits for the completion of a
|
|
|
|
Future, the event loop runs other Tasks, callbacks, or performs
|
|
|
|
IO operations.
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
Use the high-level :func:`asyncio.create_task` function to create
|
2018-09-17 20:16:44 -03:00
|
|
|
Tasks, or the low-level :meth:`loop.create_task` or
|
|
|
|
:func:`ensure_future` functions. Manual instantiation of Tasks
|
|
|
|
is discouraged.
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
To cancel a running Task use the :meth:`cancel` method. Calling it
|
|
|
|
will cause the Task to throw a :exc:`CancelledError` exception into
|
|
|
|
the wrapped coroutine. If a coroutine is awaiting on a Future
|
|
|
|
object during cancellation, the Future object will be cancelled.
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
:meth:`cancelled` can be used to check if the Task was cancelled.
|
|
|
|
The method returns ``True`` if the wrapped coroutine did not
|
|
|
|
suppress the :exc:`CancelledError` exception and was actually
|
|
|
|
cancelled.
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
:class:`asyncio.Task` inherits from :class:`Future` all of its
|
|
|
|
APIs except :meth:`Future.set_result` and
|
|
|
|
:meth:`Future.set_exception`.
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
Tasks support the :mod:`contextvars` module. When a Task
|
|
|
|
is created it copies the current context and later runs its
|
|
|
|
coroutine in the copied context.
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
.. versionchanged:: 3.7
|
|
|
|
Added support for the :mod:`contextvars` module.
|
2015-05-11 17:33:41 -03:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
.. versionchanged:: 3.8
|
|
|
|
Added the ``name`` parameter.
|
2015-12-15 01:45:24 -04:00
|
|
|
|
2019-09-12 09:40:40 -03:00
|
|
|
.. deprecated-removed:: 3.8 3.10
|
|
|
|
The *loop* parameter.
|
|
|
|
|
2020-05-15 20:55:50 -03:00
|
|
|
.. method:: cancel(msg=None)
|
2017-12-15 01:04:38 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
Request the Task to be cancelled.
|
2017-12-15 01:04:38 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
This arranges for a :exc:`CancelledError` exception to be thrown
|
|
|
|
into the wrapped coroutine on the next cycle of the event loop.
|
2014-08-10 20:11:13 -03:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
The coroutine then has a chance to clean up or even deny the
|
|
|
|
request by suppressing the exception with a :keyword:`try` ...
|
|
|
|
... ``except CancelledError`` ... :keyword:`finally` block.
|
|
|
|
Therefore, unlike :meth:`Future.cancel`, :meth:`Task.cancel` does
|
|
|
|
not guarantee that the Task will be cancelled, although
|
|
|
|
suppressing cancellation completely is not common and is actively
|
|
|
|
discouraged.
|
2014-08-10 20:11:13 -03:00
|
|
|
|
2020-05-15 20:55:50 -03:00
|
|
|
.. versionchanged:: 3.9
|
|
|
|
Added the ``msg`` parameter.
|
|
|
|
|
2018-09-14 19:11:24 -03:00
|
|
|
.. _asyncio_example_task_cancel:
|
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
The following example illustrates how coroutines can intercept
|
|
|
|
the cancellation request::
|
2017-06-09 03:28:59 -03:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
async def cancel_me():
|
|
|
|
print('cancel_me(): before sleep')
|
2017-06-09 03:28:59 -03:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
try:
|
|
|
|
# Wait for 1 hour
|
|
|
|
await asyncio.sleep(3600)
|
|
|
|
except asyncio.CancelledError:
|
|
|
|
print('cancel_me(): cancel sleep')
|
|
|
|
raise
|
|
|
|
finally:
|
|
|
|
print('cancel_me(): after sleep')
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
async def main():
|
|
|
|
# Create a "cancel_me" Task
|
|
|
|
task = asyncio.create_task(cancel_me())
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
# Wait for 1 second
|
|
|
|
await asyncio.sleep(1)
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
task.cancel()
|
|
|
|
try:
|
|
|
|
await task
|
|
|
|
except asyncio.CancelledError:
|
|
|
|
print("main(): cancel_me is cancelled now")
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
asyncio.run(main())
|
2018-05-29 18:20:02 -03:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
# Expected output:
|
|
|
|
#
|
|
|
|
# cancel_me(): before sleep
|
|
|
|
# cancel_me(): cancel sleep
|
|
|
|
# cancel_me(): after sleep
|
|
|
|
# main(): cancel_me is cancelled now
|
2014-01-29 19:18:50 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
.. method:: cancelled()
|
2014-01-29 19:18:50 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
Return ``True`` if the Task is *cancelled*.
|
2014-01-29 19:18:50 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
The Task is *cancelled* when the cancellation was requested with
|
|
|
|
:meth:`cancel` and the wrapped coroutine propagated the
|
|
|
|
:exc:`CancelledError` exception thrown into it.
|
2014-01-29 19:18:50 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
.. method:: done()
|
2016-01-11 08:40:35 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
Return ``True`` if the Task is *done*.
|
2016-01-11 08:40:35 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
A Task is *done* when the wrapped coroutine either returned
|
|
|
|
a value, raised an exception, or the Task was cancelled.
|
2016-01-11 08:40:35 -04:00
|
|
|
|
2018-09-20 13:43:59 -03:00
|
|
|
.. method:: result()
|
|
|
|
|
|
|
|
Return the result of the Task.
|
|
|
|
|
|
|
|
If the Task is *done*, the result of the wrapped coroutine
|
|
|
|
is returned (or if the coroutine raised an exception, that
|
|
|
|
exception is re-raised.)
|
|
|
|
|
|
|
|
If the Task has been *cancelled*, this method raises
|
|
|
|
a :exc:`CancelledError` exception.
|
|
|
|
|
|
|
|
If the Task's result isn't yet available, this method raises
|
|
|
|
a :exc:`InvalidStateError` exception.
|
|
|
|
|
|
|
|
.. method:: exception()
|
|
|
|
|
|
|
|
Return the exception of the Task.
|
|
|
|
|
|
|
|
If the wrapped coroutine raised an exception that exception
|
|
|
|
is returned. If the wrapped coroutine returned normally
|
|
|
|
this method returns ``None``.
|
|
|
|
|
|
|
|
If the Task has been *cancelled*, this method raises a
|
|
|
|
:exc:`CancelledError` exception.
|
|
|
|
|
|
|
|
If the Task isn't *done* yet, this method raises an
|
|
|
|
:exc:`InvalidStateError` exception.
|
|
|
|
|
|
|
|
.. method:: add_done_callback(callback, *, context=None)
|
|
|
|
|
|
|
|
Add a callback to be run when the Task is *done*.
|
|
|
|
|
|
|
|
This method should only be used in low-level callback-based code.
|
|
|
|
|
|
|
|
See the documentation of :meth:`Future.add_done_callback`
|
|
|
|
for more details.
|
|
|
|
|
|
|
|
.. method:: remove_done_callback(callback)
|
|
|
|
|
|
|
|
Remove *callback* from the callbacks list.
|
|
|
|
|
|
|
|
This method should only be used in low-level callback-based code.
|
|
|
|
|
|
|
|
See the documentation of :meth:`Future.remove_done_callback`
|
|
|
|
for more details.
|
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
.. method:: get_stack(\*, limit=None)
|
2016-01-11 08:40:35 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
Return the list of stack frames for this Task.
|
2016-01-11 08:40:35 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
If the wrapped coroutine is not done, this returns the stack
|
|
|
|
where it is suspended. If the coroutine has completed
|
|
|
|
successfully or was cancelled, this returns an empty list.
|
|
|
|
If the coroutine was terminated by an exception, this returns
|
|
|
|
the list of traceback frames.
|
2016-01-11 08:40:35 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
The frames are always ordered from oldest to newest.
|
2016-01-11 08:40:35 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
Only one stack frame is returned for a suspended coroutine.
|
2016-01-11 08:40:35 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
The optional *limit* argument sets the maximum number of frames
|
|
|
|
to return; by default all available frames are returned.
|
|
|
|
The ordering of the returned list differs depending on whether
|
|
|
|
a stack or a traceback is returned: the newest frames of a
|
|
|
|
stack are returned, but the oldest frames of a traceback are
|
|
|
|
returned. (This matches the behavior of the traceback module.)
|
2016-01-11 08:40:35 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
.. method:: print_stack(\*, limit=None, file=None)
|
2016-01-11 08:40:35 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
Print the stack or traceback for this Task.
|
2016-01-11 08:40:35 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
This produces output similar to that of the traceback module
|
|
|
|
for the frames retrieved by :meth:`get_stack`.
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
The *limit* argument is passed to :meth:`get_stack` directly.
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
The *file* argument is an I/O stream to which the output
|
|
|
|
is written; by default output is written to :data:`sys.stderr`.
|
2014-01-31 21:36:43 -04:00
|
|
|
|
2019-05-30 12:30:09 -03:00
|
|
|
.. method:: get_coro()
|
|
|
|
|
|
|
|
Return the coroutine object wrapped by the :class:`Task`.
|
|
|
|
|
|
|
|
.. versionadded:: 3.8
|
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
.. method:: get_name()
|
2015-02-12 17:49:18 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
Return the name of the Task.
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
If no name has been explicitly assigned to the Task, the default
|
|
|
|
asyncio Task implementation generates a default name during
|
|
|
|
instantiation.
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
.. versionadded:: 3.8
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
.. method:: set_name(value)
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
Set the name of the Task.
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
The *value* argument can be any object, which is then
|
|
|
|
converted to a string.
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
In the default Task implementation, the name will be visible
|
|
|
|
in the :func:`repr` output of a task object.
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
.. versionadded:: 3.8
|
2013-12-02 20:08:00 -04:00
|
|
|
|
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
.. _asyncio_generator_based_coro:
|
2018-05-29 19:21:44 -03:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
Generator-based Coroutines
|
|
|
|
==========================
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
.. note::
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
Support for generator-based coroutines is **deprecated** and
|
2018-09-25 18:44:52 -03:00
|
|
|
is scheduled for removal in Python 3.10.
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
Generator-based coroutines predate async/await syntax. They are
|
2018-09-17 20:16:44 -03:00
|
|
|
Python generators that use ``yield from`` expressions to await
|
2018-09-14 17:32:07 -03:00
|
|
|
on Futures and other coroutines.
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
Generator-based coroutines should be decorated with
|
|
|
|
:func:`@asyncio.coroutine <asyncio.coroutine>`, although this is not
|
|
|
|
enforced.
|
2013-12-02 20:08:00 -04:00
|
|
|
|
2013-12-02 20:22:06 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
.. decorator:: coroutine
|
2014-01-29 19:18:50 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
Decorator to mark generator-based coroutines.
|
2014-01-29 19:18:50 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
This decorator enables legacy generator-based coroutines to be
|
|
|
|
compatible with async/await code::
|
2014-01-29 19:18:50 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
@asyncio.coroutine
|
|
|
|
def old_style_coroutine():
|
|
|
|
yield from asyncio.sleep(1)
|
2014-01-29 19:18:50 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
async def main():
|
|
|
|
await old_style_coroutine()
|
|
|
|
|
|
|
|
This decorator should not be used for :keyword:`async def`
|
|
|
|
coroutines.
|
2014-01-29 19:18:50 -04:00
|
|
|
|
2019-05-16 11:52:10 -03:00
|
|
|
.. deprecated-removed:: 3.8 3.10
|
|
|
|
|
|
|
|
Use :keyword:`async def` instead.
|
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
.. function:: iscoroutine(obj)
|
2014-01-29 19:18:50 -04:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
Return ``True`` if *obj* is a :ref:`coroutine object <coroutine>`.
|
2018-05-29 18:31:01 -03:00
|
|
|
|
2018-09-14 17:32:07 -03:00
|
|
|
This method is different from :func:`inspect.iscoroutine` because
|
2018-09-27 16:48:30 -03:00
|
|
|
it returns ``True`` for generator-based coroutines.
|
2018-09-14 17:32:07 -03:00
|
|
|
|
|
|
|
.. function:: iscoroutinefunction(func)
|
|
|
|
|
|
|
|
Return ``True`` if *func* is a :ref:`coroutine function
|
|
|
|
<coroutine>`.
|
|
|
|
|
|
|
|
This method is different from :func:`inspect.iscoroutinefunction`
|
|
|
|
because it returns ``True`` for generator-based coroutine functions
|
|
|
|
decorated with :func:`@coroutine <coroutine>`.
|