parameters in debug mode, whereas ``lambda`` functions have a poor
representation.
-.. method:: AbstractEventLoop.call_soon(callback, \*args)
+.. method:: AbstractEventLoop.call_soon(callback, *args, context=None)
Arrange for a callback to be called as soon as possible. The callback is
called after :meth:`call_soon` returns, when control returns to the event
Any positional arguments after the callback will be passed to the
callback when it is called.
+ An optional keyword-only *context* argument allows specifying a custom
+ :class:`contextvars.Context` for the *callback* to run in. The current
+ context is used when no *context* is provided.
+
An instance of :class:`asyncio.Handle` is returned, which can be
used to cancel the callback.
:ref:`Use functools.partial to pass keywords to the callback
<asyncio-pass-keywords>`.
-.. method:: AbstractEventLoop.call_soon_threadsafe(callback, \*args)
+ .. versionchanged:: 3.7
+ The *context* keyword-only parameter was added. See :pep:`567`
+ for more details.
+
+.. method:: AbstractEventLoop.call_soon_threadsafe(callback, *args, context=None)
Like :meth:`call_soon`, but thread safe.
See the :ref:`concurrency and multithreading <asyncio-multithreading>`
section of the documentation.
+ .. versionchanged:: 3.7
+ The *context* keyword-only parameter was added. See :pep:`567`
+ for more details.
+
.. _asyncio-delayed-calls:
Timeouts (relative *delay* or absolute *when*) should not exceed one day.
-.. method:: AbstractEventLoop.call_later(delay, callback, *args)
+.. method:: AbstractEventLoop.call_later(delay, callback, *args, context=None)
Arrange for the *callback* to be called after the given *delay*
seconds (either an int or float).
is called. If you want the callback to be called with some named
arguments, use a closure or :func:`functools.partial`.
+ An optional keyword-only *context* argument allows specifying a custom
+ :class:`contextvars.Context` for the *callback* to run in. The current
+ context is used when no *context* is provided.
+
:ref:`Use functools.partial to pass keywords to the callback
<asyncio-pass-keywords>`.
-.. method:: AbstractEventLoop.call_at(when, callback, *args)
+ .. versionchanged:: 3.7
+ The *context* keyword-only parameter was added. See :pep:`567`
+ for more details.
+
+.. method:: AbstractEventLoop.call_at(when, callback, *args, context=None)
Arrange for the *callback* to be called at the given absolute timestamp
*when* (an int or float), using the same time reference as
:ref:`Use functools.partial to pass keywords to the callback
<asyncio-pass-keywords>`.
+ .. versionchanged:: 3.7
+ The *context* keyword-only parameter was added. See :pep:`567`
+ for more details.
+
.. method:: AbstractEventLoop.time()
Return the current time, as a :class:`float` value, according to the
:exc:`CancelledError`. If the future isn't done yet, raises
:exc:`InvalidStateError`.
- .. method:: add_done_callback(fn)
+ .. method:: add_done_callback(callback, *, context=None)
Add a callback to be run when the future becomes done.
- The callback is called with a single argument - the future object. If the
+ The *callback* is called with a single argument - the future object. If the
future is already done when this is called, the callback is scheduled
with :meth:`~AbstractEventLoop.call_soon`.
+ An optional keyword-only *context* argument allows specifying a custom
+ :class:`contextvars.Context` for the *callback* to run in. The current
+ context is used when no *context* is provided.
+
:ref:`Use functools.partial to pass parameters to the callback
<asyncio-pass-keywords>`. For example,
``fut.add_done_callback(functools.partial(print, "Future:",
flush=True))`` will call ``print("Future:", fut, flush=True)``.
+ .. versionchanged:: 3.7
+ The *context* keyword-only parameter was added. See :pep:`567`
+ for more details.
+
.. method:: remove_done_callback(fn)
Remove all instances of a callback from the "call when done" list.
Don't directly create :class:`Task` instances: use the :func:`create_task`
function or the :meth:`AbstractEventLoop.create_task` method.
+ 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. See :pep:`567` for more details.
+
This class is :ref:`not thread safe <asyncio-multithreading>`.
+ .. versionchanged:: 3.7
+ Added support for the :mod:`contextvars` module.
+
.. classmethod:: all_tasks(loop=None)
Return a set of all tasks for an event loop.
destroying the event loop.
(Contributed by Yury Selivanov in :issue:`32314`.)
+* asyncio gained support for :mod:`contextvars`.
+ :meth:`loop.call_soon() <asyncio.AbstractEventLoop.call_soon>`,
+ :meth:`loop.call_soon_threadsafe() <asyncio.AbstractEventLoop.call_soon_threadsafe>`,
+ :meth:`loop.call_later() <asyncio.AbstractEventLoop.call_later>`,
+ :meth:`loop.call_at() <asyncio.AbstractEventLoop.call_at>`, and
+ :meth:`Future.add_done_callback() <asyncio.Future.add_done_callback>`
+ have a new optional keyword-only *context* parameter.
+ :class:`Tasks <asyncio.Task>` now track their context automatically.
+ See :pep:`567` for more details.
+ (Contributed by Yury Selivanov in :issue:`32436`.)
+
* The new :func:`asyncio.create_task` function has been added as a shortcut
to ``asyncio.get_event_loop().create_task()``.
(Contributed by Andrew Svetlov in :issue:`32311`.)
projects / python / commitdiff