asyncio — aszinkron I/O ütemező

Ez a modul kooperatív többfeladatos ütemezőt biztosít az async/await korutinokhoz, valamint szinkronizációs primitíveket (zárak, események) és nem blokkoló TCP-hálózatkezelést adatfolyam-olvasókon és -írókon keresztül. A feladatok egyetlen eseményhurkon futnak párhuzamosan; az éppen futó feladat az await segítségével adja vissza a vezérlést a huroknak.

Példa:

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)))

Alapvető függvények

asyncio.create_task(coro: Coroutine) → Task

Létrehoz egy új feladatot a megadott korutinból, és ütemezi a futtatását.

Visszaadja a hozzá tartozó Task objektumot.

asyncio.current_task() → Task

Visszaadja az éppen futó feladathoz tartozó Task objektumot.

asyncio.run(coro: Coroutine) → Any

Létrehoz egy új feladatot a megadott korutinból, és futtatja, amíg be nem fejeződik.

Visszaadja a coro által visszaadott értéket.

asyncio.sleep(t: float) → None

Alszik t másodpercig (lehet lebegőpontos szám is).

Ez egy korutin.

asyncio.sleep_ms(t: int) → None

Alszik t ezredmásodpercig.

Ez egy korutin, és egyben MicroPython-bővítmény.

További függvények

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

Megvárja, amíg az awaitable befejeződik, de megszakítja, ha tovább tart timeout másodpercnél. Ha az awaitable nem feladat, akkor feladat jön létre belőle.

Időtúllépés esetén megszakítja a feladatot, és asyncio.TimeoutError kivételt vált ki: ezt a hívónak kell elkapnia. A feladat asyncio.CancelledError kivételt kap, amely figyelmen kívül hagyható, vagy elkapható try...except vagy try...finally használatával takarítókód futtatásához.

Visszaadja az awaitable visszatérési értékét.

Ez egy korutin.

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

Hasonló a wait_for() függvényhez, de a timeout egész szám ezredmásodpercben.

Ez egy korutin, és egyben MicroPython-bővítmény.

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

Az összes awaitables párhuzamos futtatása. Azok az awaitables, amelyek nem feladatok, feladatokká alakulnak.

Visszaad egy listát az összes awaitables visszatérési értékeivel.

Ez egy korutin.

class Task

class asyncio.Task

Ez az objektum egy korutint csomagol be futó feladattá. A feladatokra az await task használatával lehet várni, ami megvárja a feladat befejeződését, és visszaadja a feladat visszatérési értékét.

A feladatokat nem közvetlenül kell létrehozni, hanem a create_task() függvényt kell használni hozzájuk.

cancel() → None

Megszakítja a feladatot azáltal, hogy asyncio.CancelledError kivételt injektál bele. A feladat figyelmen kívül hagyhatja ezt a kivételt. Takarítókód futtatható a kivétel elkapásával, vagy try ... finally használatával.

class Event

class asyncio.Event

Létrehoz egy új eseményt, amely feladatok szinkronizálására használható. Az események törölt állapotban indulnak.

is_set() → bool

Visszaadja a True értéket, ha az esemény be van állítva, egyébként False értéket.

set() → None

Beállítja az eseményt. Minden, az eseményre váró feladat futtatásra lesz ütemezve.

Megjegyzés: Ezt feladaton belülről kell hívni. Nem biztonságos IRQ-ból, ütemező-visszahívásból vagy más szálból hívni. Lásd: ThreadSafeFlag.

clear() → None

Törli az eseményt.

wait() → None

Megvárja, amíg az esemény beáll. Ha az esemény már be van állítva, azonnal visszatér.

Ez egy korutin.

class ThreadSafeFlag

class asyncio.ThreadSafeFlag

Létrehoz egy új jelzőt, amely egy feladat szinkronizálására használható az asyncio hurkon kívül futó kóddal, például más szálakkal, IRQ-kkal vagy ütemező-visszahívásokkal. A jelzők törölt állapotban indulnak.

set() → None

Beállítja a jelzőt. Ha van a jelzőre váró feladat, az futtatásra lesz ütemezve.

clear() → None

Törli a jelzőt. Ez használható annak biztosítására, hogy egy esetlegesen korábban beállított jelző törölve legyen, mielőtt várnánk rá.

wait() → None

Megvárja, amíg a jelző beáll. Ha a jelző már be van állítva, azonnal visszatér. A jelző a wait visszatérésekor automatikusan visszaáll.

Egy jelzőre egyszerre csak egyetlen feladat várhat.

Ez egy korutin.

class Lock

class asyncio.Lock

Létrehoz egy új zárat, amely feladatok összehangolására használható. A zárak feloldott állapotban indulnak.

Az alábbi metódusokon kívül a zárak async with utasításban is használhatók.

locked() → bool

Visszaadja a True értéket, ha a zár zárolva van, egyébként False értéket.

acquire() → bool

Megvárja, amíg a zár feloldott állapotba kerül, majd atomi módon zárolja. Egyszerre csak egy feladat szerezheti meg a zárat.

Ez egy korutin.

release() → None

Feloldja a zárat. Ha bármely feladat a zárra vár, akkor a sorban következő feladat futtatásra lesz ütemezve, és a zár zárolva marad. Egyébként, ha nincs várakozó feladat, a zár feloldódik.

TCP adatfolyam-kapcsolatok

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

TCP-kapcsolatot nyit a megadott host és port felé. A host cím a socket.getaddrinfo() segítségével lesz feloldva, ami jelenleg blokkoló hívás. Ha az ssl egy ssl.SSLContext objektum, ez a kontextus lesz használva a transzport létrehozásához; ha az ssl értéke True, akkor egy alapértelmezett kontextus lesz használva.

Visszaad egy adatfolyam-párt: egy olvasó és egy író adatfolyamot. Socket-specifikus OSError kivételt vált ki, ha a host nem volt feloldható, vagy ha a kapcsolat nem volt létrehozható.

Ez egy korutin.

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

TCP-szervert indít a megadott host és port címen. A callback a bejövő, elfogadott kapcsolatokkal lesz meghívva, és 2 argumentumot kap: a kapcsolat olvasó és író adatfolyamait.

Ha az ssl egy ssl.SSLContext objektum, ez a kontextus lesz használva a transzport létrehozásához.

Visszaad egy Server objektumot.

Ez egy korutin.

class asyncio.Stream

Ez egy TCP adatfolyam-kapcsolatot képvisel. A kód minimalizálása érdekében ez az osztály egyaránt megvalósít olvasót és írót, és mind a StreamReader, mind a StreamWriter ennek az osztálynak az aliasa.

get_extra_info(v: str) → Any

Lekér további információt az adatfolyamról, amelyet a v ad meg. A v érvényes értékei: peername.

close() → None

Lezárja az adatfolyamot.

wait_closed() → None

Megvárja, amíg az adatfolyam lezárul.

Ez egy korutin.

read(n: int = -1) → bytes

Legfeljebb n bájtot olvas, és visszaadja őket. Ha az n nincs megadva vagy -1, akkor minden bájtot beolvas EOF-ig. A visszaadott érték üres bytes objektum lesz, ha EOF következik be, mielőtt bármilyen bájtot beolvasna.

Ez egy korutin.

readinto(buf: bytearray | memoryview) → int

Legfeljebb n bájtot olvas a buf objektumba, ahol n a buf hosszával egyenlő.

Visszaadja a buf objektumba beolvasott bájtok számát.

Ez egy korutin, és egyben MicroPython-bővítmény.

readexactly(n: int) → bytes

Pontosan n bájtot olvas, és bytes objektumként adja vissza őket.

EOFError kivételt vált ki, ha az adatfolyam véget ér, mielőtt n bájtot beolvasna.

Ez egy korutin.

readline() → bytes

Beolvas egy sort, és visszaadja.

Ez egy korutin.

write(buf: bytes) → None

Hozzáfűzi a buf tartalmát a kimeneti pufferhez. Az adatok csak akkor lesznek kiürítve, amikor a Stream.drain() metódust meghívják. Ajánlott a Stream.drain() metódust közvetlenül e függvény meghívása után hívni.

drain() → None

Kiüríti (kiírja) az összes pufferelt kimeneti adatot az adatfolyamba.

Ez egy korutin.

class asyncio.Server

Ez a start_server() által visszaadott szerverosztályt képviseli. Használható async with utasításban a szerver kilépéskor történő lezárásához.

close() → None

Lezárja a szervert.

wait_closed() → None

Megvárja, amíg a szerver lezárul.

Ez egy korutin.

Eseményhurok

asyncio.get_event_loop() → Loop

Visszaadja a feladatok ütemezésére és futtatására használt eseményhurkot. Lásd: Loop.

asyncio.new_event_loop() → Loop

Visszaállítja az eseményhurkot, és visszaadja azt.

Megjegyzés: mivel a MicroPython csak egyetlen eseményhurokkal rendelkezik, ez a függvény csupán visszaállítja a hurok állapotát, nem hoz létre újat.

class asyncio.Loop

Ez azt az objektumot képviseli, amely a feladatokat ütemezi és futtatja. Nem hozható létre, helyette a get_event_loop() függvényt kell használni.

create_task(coro: Coroutine) → Task

Létrehoz egy feladatot a megadott coro korutinból, és visszaadja az új Task objektumot.

run_forever() → None

Futtatja az eseményhurkot, amíg a stop() meghívásra nem kerül.

run_until_complete(awaitable: Awaitable) → Any

Futtatja a megadott awaitable objektumot, amíg be nem fejeződik. Ha az awaitable nem feladat, akkor feladattá alakul.

stop() → None

Leállítja az eseményhurkot.

close() → None

Lezárja az eseményhurkot.

set_exception_handler(handler: Callable) → None

Beállítja a kivételkezelőt, amely akkor lesz meghívva, amikor egy feladat olyan kivételt vált ki, amelyet nem kapnak el. A handler két argumentumot fogadjon: (loop, context).

get_exception_handler() → Callable | None

Lekéri az aktuális kivételkezelőt. Visszaadja a kezelőt, vagy None értéket, ha nincs egyéni kezelő beállítva.

default_exception_handler(context: dict) → None

Az alapértelmezett kivételkezelő, amelyet meghív.

call_exception_handler(context: dict) → None

Meghívja az aktuális kivételkezelőt. A context argumentum változatlanul kerül átadásra, és egy szótár, amely a következő kulcsokat tartalmazza: 'message', 'exception', 'future'.