Lidsky řečeno
Představ si pásovou linku. Každý pracovník vezme jeden kus, udělá svou část a pošle ho dál. Nikdo nečeká, až se před ním nahromadí celá denní výroba. A když poslední člověk přestane odebírat, pás se zastaví a nikde se nic nehromadí. Generátory v Pythonu fungují přesně takhle.
Plán a data
Pipeline poskládáš z malých kroků. Každý je samostatný a jde otestovat zvlášť:
řádky -> parsuj -> okna -> souhrny -> alarmy -> zápis po dávkách
text Mereni minuty průměry Alarm cizí systémZdroj dat si nasimulujeme. Generátor vyrábí řádky jeden po druhém, se stejným seed vždy stejné. Občas přimíchá rozbitý řádek, chybějící pole, nesmyslnou hodnotu nebo opožděný záznam.
import json
import random
def proud_z_cidel(pocet, seed=42):
los = random.Random(seed)
cidla = ["mraz-1", "mraz-2", "mraz-3"]
for cas in range(pocet):
cidlo = cidla[cas % 3]
teplota = -18 + los.uniform(-1, 1)
if cidlo == "mraz-2" and 600 <= cas < 1100:
teplota += 8 # open door
nahoda = los.random()
if nahoda < 0.002:
yield '{"cidlo": "mraz' # cut-off line
elif nahoda < 0.004:
yield json.dumps({"cidlo": cidlo, "cas": cas})
elif nahoda < 0.006:
yield json.dumps({"cidlo": cidlo, "cas": cas, "teplota": 999})
elif nahoda < 0.008:
yield json.dumps({"cidlo": cidlo, "cas": max(0, cas - 90), "teplota": -18.0})
else:
yield json.dumps({"cidlo": cidlo, "cas": cas, "teplota": round(teplota, 2)})
for radek in proud_z_cidel(3):
print(radek)
{"cidlo": "mraz-1", "cas": 0, "teplota": -17.72}
{"cidlo": "mraz-2", "cas": 1, "teplota": -18.45}
{"cidlo": "mraz-3", "cas": 2, "teplota": -17.53}Proč generátory? Každý krok si vyžádá další položku až ve chvíli, kdy ji potřebuje. Tahle ukázka to odhalí: sleduj, jak jedna položka projde celou linkou, než vznikne další.
def zdroj():
for cislo in range(1, 4):
print("zdroj vydává", cislo)
yield cislo
def zdvojnasob(polozky):
for polozka in polozky:
print(" zdvojnásobuji", polozka)
yield polozka * 2
def jen_vetsi(polozky, hranice):
for polozka in polozky:
if polozka > hranice:
print(" propouštím", polozka)
yield polozka
linka = jen_vetsi(zdvojnasob(zdroj()), 2)
print("linka je sestavená, zatím nic neběželo")
print("první výsledek:", next(linka))
linka je sestavená, zatím nic neběželo
zdroj vydává 1
zdvojnásobuji 1
zdroj vydává 2
zdvojnásobuji 2
propouštím 4
první výsledek: 4Třetí číslo se nikdy nevyrobilo, protože si o něj nikdo neřekl. Tomu se říká pull model: tempo určuje konec linky.
Krok 1: vyčisti vstup
Špatný řádek nesmí shodit program, ale nesmí ani tiše zmizet. Každý zahozený záznam proto započítáš podle důvodu. V provozu právě z těchhle čísel poznáš, že se některé čidlo začalo kazit.
Krok 1: parsuj
Napiš generátor parsuj(radky, chyby). Pro každý řádek vydá Mereni. Špatné záznamy přeskočí a započítá do chyby (je to Counter):
chyby["format"], když řádek není platný JSON,chyby["pole"], když chybí pole nebo nejde převést (cidlopřesstr,caspřesint,teplotapřesfloat), případně když JSON není objekt,chyby["rozsah"], když teplota neleží v rozsahu od -60 do 60 včetně.
import json
from collections import Counter
from dataclasses import dataclass
@dataclass(frozen=True, slots=True)
class Mereni:
cidlo: str
cas: int
teplota: float
def parsuj(radky, chyby):
# doplň
yield from ()
chyby = Counter()
print(list(parsuj(['{"cidlo": "a", "cas": 1, "teplota": -18.5}', "rozbito"], chyby)))
print(chyby)
Krok 2: rozděl čas na okna
Jednotlivá měření jsou moc zašuměná, proto se skládají do oken: pevných, nepřekrývajících se úseků času. Záznam s časem 137 při délce okna 60 patří do okna, které začíná na 120.
cas: 0 ... 59 | 60 ... 119 | 120 ... 179
okno: 0 | 60 | 120Generátor drží v paměti jen rozdělané okno. Jakmile přijde záznam z novějšího okna, staré je hotové a pošle se dál. Záznam ze staršího okna přišel pozdě, a protože jeho okno už odešlo, jen ho započítáš.
Krok 2: okna
Napiš generátor okna(mereni, delka, chyby), který vydává dvojice (zacatek_okna, seznam_mereni). Okno odešli, jakmile přijde záznam z pozdějšího okna, a poslední okno vydej na konci vstupu. Záznam ze staršího okna, než je to rozdělané, přeskoč a přičti do chyby["pozde"]. Prázdná okna se nevydávají.
from collections import Counter
from dataclasses import dataclass
@dataclass(frozen=True, slots=True)
class Mereni:
cidlo: str
cas: int
teplota: float
def okna(mereni, delka, chyby):
# doplň
yield from ()
data = [Mereni("a", 5, -18.0), Mereni("a", 61, -17.0)]
print(list(okna(data, 60, Counter())))
Proč se po odeslání okna nemá použít obsah.clear()?
yield předává odkaz, ne kopii. Pokud si příjemce okno uložil, po clear() by v ruce držel prázdný seznam.
Kroky 3 a 4: souhrny a alarmy
Z každého okna spočítáš pro každé čidlo jeden souhrn. Na něj naváže detektor. Jedno teplé okno nic neznamená, ale několik za sebou už ano. Detektor si proto musí pamatovat stav: kolik oken v řadě bylo každé čidlo nad limitem. Stav má velikost podle počtu čidel, ne podle délky proudu, takže paměť neroste.
Krok 3: souhrny
Napiš generátor souhrny(okna). Vstupem jsou dvojice (zacatek, seznam_mereni). Pro každé okno vydej za každé čidlo jeden Souhrn s počtem měření, průměrem zaokrouhleným na 2 desetinná místa a maximem. V rámci okna jdou čidla podle abecedy.
from dataclasses import dataclass
@dataclass(frozen=True, slots=True)
class Mereni:
cidlo: str
cas: int
teplota: float
@dataclass(frozen=True, slots=True)
class Souhrn:
zacatek: int
cidlo: str
pocet: int
prumer: float
maximum: float
def souhrny(okna):
# doplň
yield from ()
okno = (60, [Mereni("b", 61, -10.0), Mereni("a", 62, -18.0), Mereni("b", 63, -12.0)])
print(list(souhrny([okno])))
Krok 4: alarmy
Napiš generátor alarmy(souhrny, limit, po_sobe). Pro každé čidlo sleduj, kolik jeho oken v řadě mělo prumer větší než limit. Když řada dosáhne přesně po_sobe, vydej Alarm(cidlo, zacatek, prumer) z právě toho souhrnu. Další okna téže řady už alarm nespouštějí. Okno pod limitem nebo na něm řadu vynuluje a čidla se navzájem neovlivňují.
from dataclasses import dataclass
@dataclass(frozen=True, slots=True)
class Souhrn:
zacatek: int
cidlo: str
pocet: int
prumer: float
maximum: float
@dataclass(frozen=True, slots=True)
class Alarm:
cidlo: str
zacatek: int
prumer: float
def alarmy(souhrny, limit, po_sobe):
# doplň
yield from ()
data = [Souhrn(0, "a", 1, -5.0, -5.0), Souhrn(60, "a", 1, -4.0, -4.0)]
print(list(alarmy(data, -12, 2)))
Krok 5: zápis po dávkách
Cizí systém nechceš volat kvůli každé položce, každé volání něco stojí. Proto se zapisuje po dávkách. Python 3.12 přidal přesně na to itertools.batched: z proudu dělá n-tice dané velikosti a poslední může být kratší.
from itertools import batched
for davka in batched(range(1, 8), 3):
print(davka)
(1, 2, 3) (4, 5, 6) (7,)
Síť občas selže, takže zápis se má zopakovat. Ale ne donekonečna: když výpadek trvá, chyba musí vyletět ven a někdo se o ni musí postarat.
Krok 5: odolný zápis
Napiš funkci zapis_po_davkach(prvky, velikost, zapis, pokusy=3). Rozdělí prvky na dávky, každou předá funkci zapis a vrátí celkový počet zapsaných prvků. Když zapis vyhodí ConnectionError, zkus stejnou dávku znovu. Po pokusy neúspěšných pokusech výjimku pusť ven. Jiné výjimky nechytej.
from itertools import batched
def zapis_po_davkach(prvky, velikost, zapis, pokusy=3):
# doplň
return 0
print(zapis_po_davkach(range(5), 2, print))
Zápis dávky skončil ConnectionError, ale server ji ve skutečnosti uložil a jen se ztratila odpověď. Co udělá opakování?
Odesílatel nemá jak poznat, kde se spojení přerušilo. Proto mívají záznamy jednoznačné ID a příjemce s ním zachází tak, aby opakovaný zápis nic nezměnil.
Krok 6: složení a ostrý provoz
Všechny díly jsou hotové. Protože každý bere iterátor a vrací iterátor, spojíš je prostým vnořením. Dokud poslední krok nezačne odebírat, neproběhne nic.
Krok 6: celá pipeline
Hotové díly jsou v kódu. Doplň funkci spust(radky, delka, limit, po_sobe, velikost, zapis): propoj je a vrať dvojici (pocet_zapsanych_alarmu, chyby), kde chyby je jeden společný Counter pro parsuj i okna.
import json
from collections import Counter, defaultdict
from dataclasses import dataclass
from itertools import batched
@dataclass(frozen=True, slots=True)
class Mereni:
cidlo: str
cas: int
teplota: float
@dataclass(frozen=True, slots=True)
class Souhrn:
zacatek: int
cidlo: str
pocet: int
prumer: float
maximum: float
@dataclass(frozen=True, slots=True)
class Alarm:
cidlo: str
zacatek: int
prumer: float
def parsuj(radky, chyby):
for radek in radky:
try:
data = json.loads(radek)
except json.JSONDecodeError:
chyby["format"] += 1
continue
try:
mereni = Mereni(str(data["cidlo"]), int(data["cas"]), float(data["teplota"]))
except (KeyError, TypeError, ValueError):
chyby["pole"] += 1
continue
if not -60 <= mereni.teplota <= 60:
chyby["rozsah"] += 1
continue
yield mereni
def okna(mereni, delka, chyby):
aktualni = None
obsah = []
for zaznam in mereni:
zacatek = zaznam.cas - zaznam.cas % delka
if aktualni is None:
aktualni = zacatek
if zacatek < aktualni:
chyby["pozde"] += 1
continue
if zacatek > aktualni:
yield aktualni, obsah
aktualni, obsah = zacatek, []
obsah.append(zaznam)
if obsah:
yield aktualni, obsah
def souhrny(okna):
for zacatek, obsah in okna:
podle_cidla = defaultdict(list)
for zaznam in obsah:
podle_cidla[zaznam.cidlo].append(zaznam.teplota)
for cidlo in sorted(podle_cidla):
teploty = podle_cidla[cidlo]
prumer = round(sum(teploty) / len(teploty), 2)
yield Souhrn(zacatek, cidlo, len(teploty), prumer, max(teploty))
def alarmy(souhrny, limit, po_sobe):
rady = defaultdict(int)
for souhrn in souhrny:
if souhrn.prumer > limit:
rady[souhrn.cidlo] += 1
if rady[souhrn.cidlo] == po_sobe:
yield Alarm(souhrn.cidlo, souhrn.zacatek, souhrn.prumer)
else:
rady[souhrn.cidlo] = 0
def zapis_po_davkach(prvky, velikost, zapis, pokusy=3):
zapsano = 0
for davka in batched(prvky, velikost):
for pokus in range(1, pokusy + 1):
try:
zapis(davka)
break
except ConnectionError:
if pokus == pokusy:
raise
zapsano += len(davka)
return zapsano
def spust(radky, delka, limit, po_sobe, velikost, zapis):
chyby = Counter()
# doplň: propoj kroky
zapsano = 0
return zapsano, chyby
A teď ostrý test. Celá linka běží na proudu z čidel, nejdřív na kratším, pak na čtyřikrát delším. Měříme špičku paměti. Pokud je pipeline opravdu proudová, délka vstupu na ni nemá vliv.
import json
import random
import tracemalloc
from collections import Counter, defaultdict
from dataclasses import dataclass
from itertools import batched
@dataclass(frozen=True, slots=True)
class Mereni:
cidlo: str
cas: int
teplota: float
@dataclass(frozen=True, slots=True)
class Souhrn:
zacatek: int
cidlo: str
pocet: int
prumer: float
maximum: float
@dataclass(frozen=True, slots=True)
class Alarm:
cidlo: str
zacatek: int
prumer: float
def proud_z_cidel(pocet, seed=42):
los = random.Random(seed)
cidla = ["mraz-1", "mraz-2", "mraz-3"]
for cas in range(pocet):
cidlo = cidla[cas % 3]
teplota = -18 + los.uniform(-1, 1)
if cidlo == "mraz-2" and 600 <= cas < 1100:
teplota += 8
nahoda = los.random()
if nahoda < 0.002:
yield '{"cidlo": "mraz'
elif nahoda < 0.004:
yield json.dumps({"cidlo": cidlo, "cas": cas})
elif nahoda < 0.006:
yield json.dumps({"cidlo": cidlo, "cas": cas, "teplota": 999})
elif nahoda < 0.008:
yield json.dumps({"cidlo": cidlo, "cas": max(0, cas - 90), "teplota": -18.0})
else:
yield json.dumps({"cidlo": cidlo, "cas": cas, "teplota": round(teplota, 2)})
def parsuj(radky, chyby):
for radek in radky:
try:
data = json.loads(radek)
except json.JSONDecodeError:
chyby["format"] += 1
continue
try:
mereni = Mereni(str(data["cidlo"]), int(data["cas"]), float(data["teplota"]))
except (KeyError, TypeError, ValueError):
chyby["pole"] += 1
continue
if not -60 <= mereni.teplota <= 60:
chyby["rozsah"] += 1
continue
yield mereni
def okna(mereni, delka, chyby):
aktualni = None
obsah = []
for zaznam in mereni:
zacatek = zaznam.cas - zaznam.cas % delka
if aktualni is None:
aktualni = zacatek
if zacatek < aktualni:
chyby["pozde"] += 1
continue
if zacatek > aktualni:
yield aktualni, obsah
aktualni, obsah = zacatek, []
obsah.append(zaznam)
if obsah:
yield aktualni, obsah
def souhrny(okna):
for zacatek, obsah in okna:
podle_cidla = defaultdict(list)
for zaznam in obsah:
podle_cidla[zaznam.cidlo].append(zaznam.teplota)
for cidlo in sorted(podle_cidla):
teploty = podle_cidla[cidlo]
prumer = round(sum(teploty) / len(teploty), 2)
yield Souhrn(zacatek, cidlo, len(teploty), prumer, max(teploty))
def alarmy(souhrny, limit, po_sobe):
rady = defaultdict(int)
for souhrn in souhrny:
if souhrn.prumer > limit:
rady[souhrn.cidlo] += 1
if rady[souhrn.cidlo] == po_sobe:
yield Alarm(souhrn.cidlo, souhrn.zacatek, souhrn.prumer)
else:
rady[souhrn.cidlo] = 0
def spust(radky, zapis):
chyby = Counter()
linka = alarmy(souhrny(okna(parsuj(radky, chyby), 60, chyby)), -12, 2)
zapsano = 0
for davka in batched(linka, 10):
zapis(davka)
zapsano += len(davka)
return zapsano, chyby
def spicka_pameti(pocet):
tracemalloc.start()
vysledek = spust(proud_z_cidel(pocet), lambda davka: None)
_, vrchol = tracemalloc.get_traced_memory()
tracemalloc.stop()
return vysledek, vrchol
zapsane = []
pocet, chyby = spust(proud_z_cidel(3000), zapsane.extend)
print("alarmů:", pocet)
for alarm in zapsane:
print(" ", alarm)
print("zahozeno:", dict(sorted(chyby.items())))
_, kratky = spicka_pameti(3000)
_, dlouhy = spicka_pameti(12000)
print("čtyřikrát delší proud, paměť skoro stejná:", dlouhy < kratky * 1.5)
alarmů: 1
Alarm(cidlo='mraz-2', zacatek=660, prumer=-9.82)
zahozeno: {'format': 7, 'pole': 2, 'pozde': 7, 'rozsah': 11}
čtyřikrát delší proud, paměť skoro stejná: TrueVrata se otevřela v čase 600. První teplé okno alarm nespustilo, ten přišel až s druhým, které začíná v čase 660. Do té doby to mohla být náhoda. Zahozené záznamy jsou spočítané podle důvodu. Paměť se s délkou vstupu nemění, takže stejný kód poběží hodinu i rok.
Když je zdroj rychlejší než zpracování
Generátory řeší tempo samy, protože všechno běží v jednom toku. Jakmile zdroj a zpracování běží souběžně, třeba přes asyncio, potřebuješ zpětný tlak (backpressure): pomalý konec musí umět zdroj přibrzdit. Zajišťuje to fronta s omezenou délkou. Bez limitu se data hromadí v paměti.
import asyncio
async def zdroj(fronta, pocet, stav):
for cislo in range(pocet):
await fronta.put(cislo)
stav["spicka"] = max(stav["spicka"], fronta.qsize())
await fronta.put(None)
async def zpracovani(fronta):
while await fronta.get() is not None:
await asyncio.sleep(0)
async def beh(maxsize):
fronta = asyncio.Queue(maxsize=maxsize)
stav = {"spicka": 0}
async with asyncio.TaskGroup() as skupina:
skupina.create_task(zdroj(fronta, 50, stav))
skupina.create_task(zpracovani(fronta))
return stav["spicka"]
print("fronta bez limitu, špička:", asyncio.run(beh(0)))
print("fronta s limitem 5, špička:", asyncio.run(beh(5)))
fronta bez limitu, špička: 50 fronta s limitem 5, špička: 5
Pod kapotou · co by chtěl skutečný provoz
Čas události a čas zpracování. Okna tu řadíš podle času v záznamu, ne podle hodin serveru, takže přehrání starých dat dá stejný výsledek. Cenou jsou opožděná data. Naše pravidlo je zahazuje hned. Systémy jako Apache Flink používají watermark: odhad „starší záznamy už nečekám“. Okno se zavře o něco později a zpoždění se vyměňuje za úplnost.
Doručení. Náš zápis s opakováním dává at-least-once: nic se neztratí, ale něco může přijít dvakrát. Běžné řešení je idempotentní příjemce a deterministické ID, tady třeba (cidlo, zacatek). Po pádu procesu navíc zmizí stav rady i rozdělané okno. Vyřešil by to checkpoint: periodicky uložený stav spolu s pozicí ve vstupu, zapsané atomicky.
Generátory a chyby. Výjimka, která generátorem proletí, ho definitivně ukončí a další next dá StopIteration. Proto se vadné záznamy řeší uvnitř kroku a ven nesmí. Když spotřebitel skončí dřív, rozdělané generátory dostanou GeneratorExit až při close() nebo při úklidu objektu. V CPythonu to díky počítání referencí bývá hned, jinde ne. Zdroj se souborem nebo spojením proto zavírej explicitně, třeba přes contextlib.closing.
Paměťové pasti. itertools.tee si bufferuje vše, co jedna větev přečetla a druhá ne. sorted načte do paměti celý vstup a groupby na nesetříděných datech rozseká skupiny na kusy. Stav podle klíče (rady) roste s počtem různých čidel. U klíčů bez horní hranice, jako jsou ID uživatelů, potřebuje vypršení platnosti.
Škálování. Rozdělení podle čidla na oddíly (model Kafky) zachová pořadí v rámci čidla a dovolí zpracovávat oddíly paralelně, protože stav detektoru je čistě po čidlech. Režie jednoho yield a dataclass na záznam se při velkém objemu projeví. Pak se vyplatí zpracovávat celé dávky, třeba sloupcově v NumPy.