From 754bbf7a25a8dda49b5d08ef0d0443bbf5af0e36 Mon Sep 17 00:00:00 2001 From: Craig Jennings Date: Sun, 7 Apr 2024 13:41:34 -0500 Subject: new repository --- .../python~3.12/library%2Fasyncio-extending.html | 24 ++++++++++++++++++++++ 1 file changed, 24 insertions(+) create mode 100644 devdocs/python~3.12/library%2Fasyncio-extending.html (limited to 'devdocs/python~3.12/library%2Fasyncio-extending.html') diff --git a/devdocs/python~3.12/library%2Fasyncio-extending.html b/devdocs/python~3.12/library%2Fasyncio-extending.html new file mode 100644 index 00000000..d34d7230 --- /dev/null +++ b/devdocs/python~3.12/library%2Fasyncio-extending.html @@ -0,0 +1,24 @@ +

Extending

The main direction for asyncio extending is writing custom event loop classes. Asyncio has helpers that could be used to simplify this task.

Note

Third-parties should reuse existing asyncio code with caution, a new Python version is free to break backward compatibility in internal part of API.

Writing a Custom Event Loop

asyncio.AbstractEventLoop declares very many methods. Implementing all them from scratch is a tedious job.

A loop can get many common methods implementation for free by inheriting from asyncio.BaseEventLoop.

In turn, the successor should implement a bunch of private methods declared but not implemented in asyncio.BaseEventLoop.

For example, loop.create_connection() checks arguments, resolves DNS addresses, and calls loop._make_socket_transport() that should be implemented by inherited class. The _make_socket_transport() method is not documented and is considered as an internal API.

Future and Task private constructors

asyncio.Future and asyncio.Task should be never created directly, please use corresponding loop.create_future() and loop.create_task(), or asyncio.create_task() factories instead.

However, third-party event loops may reuse built-in future and task implementations for the sake of getting a complex and highly optimized code for free.

For this purpose the following, private constructors are listed:

+Future.__init__(*, loop=None)
+

Create a built-in future instance.

loop is an optional event loop instance.

+
+Task.__init__(coro, *, loop=None, name=None, context=None)
+

Create a built-in task instance.

loop is an optional event loop instance. The rest of arguments are described in loop.create_task() description.

Changed in version 3.11: context argument is added.

+

Task lifetime support

A third party task implementation should call the following functions to keep a task visible by asyncio.all_tasks() and asyncio.current_task():

+asyncio._register_task(task)
+

Register a new task as managed by asyncio.

Call the function from a task constructor.

+
+asyncio._unregister_task(task)
+

Unregister a task from asyncio internal structures.

The function should be called when a task is about to finish.

+
+asyncio._enter_task(loop, task)
+

Switch the current task to the task argument.

Call the function just before executing a portion of embedded coroutine (coroutine.send() or coroutine.throw()).

+
+asyncio._leave_task(loop, task)
+

Switch the current task back from task to None.

Call the function just after coroutine.send() or coroutine.throw() execution.

+
+

+ © 2001–2023 Python Software Foundation
Licensed under the PSF License.
+ https://docs.python.org/3.12/library/asyncio-extending.html +

+
-- cgit v1.2.3