`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'.

asyncio — aszinkron I/O ütemező¶

Alapvető függvények¶

További függvények¶

class Task¶

class Event¶

class ThreadSafeFlag¶

class Lock¶

TCP adatfolyam-kapcsolatok¶

Eseményhurok¶

`asyncio` — aszinkron I/O ütemező¶