`asyncio` — асинхронний планувальник вводу/виводу#

Цей модуль забезпечує кооперативний планувальник багатозадачності для корутин async/await, а також примітиви синхронізації (замки, події) і неблокуюче TCP-мережування через потоки читання та запису. Завдання виконуються паралельно в одному циклі подій; поточне завдання передає керування назад до циклу за допомогою await.

Приклад:

import asyncio

async def blink(led, period_ms):
    while True:
        led.on()
        await asyncio.sleep_ms(5)
        led.off()
        await asyncio.sleep_ms(period_ms)

async def main(led1, led2):
    asyncio.create_task(blink(led1, 700))
    asyncio.create_task(blink(led2, 400))
    await asyncio.sleep_ms(10_000)

# Running on an OpenMV Cam
from machine import LED
asyncio.run(main(LED(1), LED(2)))

Основні функції#

asyncio.create_task(coro: Coroutine) → Task#

Створює нове завдання із зазначеної корутини та планує його виконання.

Повертає відповідний об’єкт Task.

asyncio.current_task() → Task#: Повертає об’єкт Task, пов’язаний з поточним виконуваним завданням.

asyncio.run(coro: Coroutine) → Any#

Створює нове завдання із зазначеної корутини та виконує його до завершення.

Повертає значення, повернене coro.

asyncio.sleep(t: float) → None#

Призупиняє виконання на t секунд (може бути числом з плаваючою крапкою).

Це корутина.

asyncio.sleep_ms(t: int) → None#

Призупиняє виконання на t мілісекунд.

Це корутина та розширення MicroPython.

Додаткові функції#

asyncio.wait_for(awaitable: Awaitable, timeout: float) → Any#

Очікує завершення awaitable, але скасовує його, якщо воно займає більше ніж timeout секунд. Якщо awaitable не є завданням, із нього буде створено завдання.

Якщо час очікування вичерпано, завдання скасовується і виникає виняток asyncio.TimeoutError: його має перехопити виклик. Завдання отримує asyncio.CancelledError, який можна ігнорувати або перехопити за допомогою try...except чи try...finally для виконання коду завершення.

Повертає значення, повернене awaitable.

Це корутина.

asyncio.wait_for_ms(awaitable: Awaitable, timeout: int) → Any#

Аналогічна wait_for(), але timeout задається цілим числом у мілісекундах.

Це корутина та розширення MicroPython.

asyncio.gather(*awaitables, return_exceptions: bool = False) → List#

Виконує всі awaitables паралельно. Будь-які awaitables, що не є завданнями, підвищуються до завдань.

Повертає список значень, повернених усіма awaitables.

Це корутина.

class Task#

class asyncio.Task#

Цей об’єкт обертає корутину в активне завдання. На завдання можна очікувати за допомогою await task, що чекатиме завершення завдання та повертатиме його результат.

Завдання не слід створювати безпосередньо — для цього використовуйте create_task().

cancel() → None#: Скасовує завдання, вводячи до нього asyncio.CancelledError. Завдання може ігнорувати цей виняток. Код завершення можна виконати, перехопивши його або використавши try ... finally.

class Event#

class asyncio.Event#

Створює нову подію, яка може використовуватися для синхронізації завдань. Події починаються в очищеному стані.

is_set() → bool#: Повертає True, якщо подію встановлено, інакше False.

set() → None#

Встановлює подію. Усі завдання, що очікують на подію, буде заплановано до виконання.

Примітка: виклик має здійснюватися зсередини завдання. Небезпечно викликати це з переривання, зворотного виклику планувальника або іншого потоку. Дивіться ThreadSafeFlag.

clear() → None#: Очищає подію.

wait() → None#

Очікує встановлення події. Якщо подію вже встановлено, повертається негайно.

Це корутина.

class ThreadSafeFlag#

class asyncio.ThreadSafeFlag#

Створює новий прапорець, який може використовуватися для синхронізації завдання з кодом, що виконується поза циклом asyncio, наприклад в інших потоках, перериваннях або зворотних викликах планувальника. Прапорці починаються в очищеному стані.

set() → None#: Встановлює прапорець. Якщо є завдання, що очікує на прапорець, воно буде заплановано до виконання.

clear() → None#: Очищає прапорець. Це може використовуватися, щоб переконатися, що можливо раніше встановлений прапорець очищено перед очікуванням на нього.

wait() → None#

Очікує встановлення прапорця. Якщо прапорець уже встановлено, повертається негайно. Прапорець автоматично скидається після повернення з wait.

На прапорець може очікувати лише одне завдання одночасно.

Це корутина.

class Lock#

class asyncio.Lock#

Створює новий замок, який можна використовувати для координації завдань. Замки починаються у розблокованому стані.

Окрім наведених нижче методів, замки можна використовувати в операторі async with.

locked() → bool#: Повертає True, якщо замок заблоковано, інакше False.

acquire() → bool#

Очікує, поки замок перейде у розблокований стан, а потім атомарно блокує його. Лише одне завдання може захопити замок одночасно.

Це корутина.

release() → None#: Звільняє замок. Якщо є завдання, що очікують замок, наступне у черзі планується до виконання, а замок залишається заблокованим. Інакше завдань, що очікують, немає, і замок переходить у розблокований стан.

TCP-потокові з’єднання#

asyncio.open_connection(host: str, port: int, ssl: ssl.SSLContext | bool | None = None) → Tuple[Stream, Stream]#

Відкриває TCP-з’єднання до зазначеного host і port. Адреса host буде розпізнана за допомогою socket.getaddrinfo(), що наразі є блокуючим викликом. Якщо ssl є об’єктом ssl.SSLContext, цей контекст використовується для створення транспорту; якщо ssl дорівнює True, використовується типовий контекст.

Повертає пару потоків: потік читання та потік запису. Якщо хост не вдалося розпізнати або з’єднання не вдалося встановити, виникне специфічний для сокетів виняток OSError.

Це корутина.

asyncio.start_server(callback: Callable, host: str, port: int, backlog: int = 5, ssl: ssl.SSLContext | None = None) → Server#

Запускає TCP-сервер на зазначеному host і port. callback буде викликатися для вхідних прийнятих з’єднань і отримуватиме 2 аргументи: потоки читання та запису для цього з’єднання.

Якщо ssl є об’єктом ssl.SSLContext, цей контекст використовується для створення транспорту.

Повертає об’єкт Server.

Це корутина.

class asyncio.Stream#

Цей клас представляє TCP-потокове з’єднання. Щоб мінімізувати код, клас реалізує і читача, і записувача, а StreamReader і StreamWriter є псевдонімами цього класу.

get_extra_info(v: str) → Any#: Отримує додаткову інформацію про потік, задану параметром v. Допустимі значення v: peername.

close() → None#: Закриває потік.

wait_closed() → None#

Очікує закриття потоку.

Це корутина.

read(n: int = -1) → bytes#

Читає до n байт і повертає їх. Якщо n не вказано або дорівнює -1, читає всі байти до EOF. Якщо EOF зустрінуто до читання будь-яких байт, повертається порожній об’єкт bytes.

Це корутина.

readinto(buf: bytearray | memoryview) → int#

Читає до n байт у buf, де n дорівнює довжині buf.

Повертає кількість байт, прочитаних у buf.

Це корутина та розширення MicroPython.

readexactly(n: int) → bytes#

Читає рівно n байт і повертає їх як об’єкт bytes.

Якщо потік завершується до читання n байт, виникає виняток EOFError.

Це корутина.

readline() → bytes#

Читає рядок і повертає його.

Це корутина.

write(buf: bytes) → None#: Накопичує buf у вихідному буфері. Дані записуються лише під час виклику Stream.drain(). Рекомендується викликати Stream.drain() одразу після виклику цієї функції.

drain() → None#

Записує (дренує) всі буферизовані вихідні дані у потік.

Це корутина.

class asyncio.Server#

Цей клас представляє сервер, повернений функцією start_server(). Його можна використовувати в операторі async with для закриття сервера під час виходу.

close() → None#: Закриває сервер.

wait_closed() → None#

Очікує закриття сервера.

Це корутина.

Цикл подій#

asyncio.get_event_loop() → Loop#: Повертає цикл подій, що використовується для планування та виконання завдань. Дивіться Loop.

asyncio.new_event_loop() → Loop#

Скидає цикл подій і повертає його.

Примітка: оскільки MicroPython має лише один цикл подій, ця функція лише скидає стан циклу, а не створює новий.

class asyncio.Loop#

Цей об’єкт планує та виконує завдання. Його не можна створити безпосередньо — використовуйте get_event_loop().

create_task(coro: Coroutine) → Task#: Створює завдання із зазначеного coro і повертає новий об’єкт Task.

run_forever() → None#: Запускає цикл подій до виклику stop().

run_until_complete(awaitable: Awaitable) → Any#: Виконує зазначений awaitable до його завершення. Якщо awaitable не є завданням, воно буде підвищено до нього.

stop() → None#: Зупиняє цикл подій.

close() → None#: Закриває цикл подій.

set_exception_handler(handler: Callable) → None#: Встановлює обробник винятків, який викликається, коли завдання породжує незловлений виняток. handler має приймати два аргументи: (loop, context).

get_exception_handler() → Callable | None#: Отримує поточний обробник винятків. Повертає обробник або None, якщо користувацький обробник не встановлено.

default_exception_handler(context: dict) → None#: Типовий обробник винятків, що викликається.

call_exception_handler(context: dict) → None#: Викликає поточний обробник винятків. Аргумент context передається як є і є словником з ключами: 'message', 'exception', 'future'.

asyncio — асинхронний планувальник вводу/виводу#

Основні функції#

Додаткові функції#

class Task#

class Event#

class ThreadSafeFlag#

class Lock#

TCP-потокові з’єднання#

Цикл подій#

`asyncio` — асинхронний планувальник вводу/виводу#