0 dní v řadě · 0 bodů

Python pod kapotou · 50 min

Mise: streamovací datová pipeline

Postavíš pipeline, která čistí nekonečný proud z čidel, skládá časová okna, hlásí alarmy a zapisuje je po dávkách při stálé paměti.

Hloubka
Úkoly
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ášť:

text
řádky -> parsuj -> okna -> souhrny -> alarmy -> zápis po dávkách
 text    Mereni    minuty   průměry    Alarm      cizí systém

Zdroj 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)
Výstup
{"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))
Výstup
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: 4

Tř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.

Úkol

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 (cidlo přes str, cas přes int, teplota přes float), 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)
Výstup

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.

text
cas:    0 ... 59 | 60 ... 119 | 120 ... 179
okno:      0     |     60     |     120

Generá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áš.

Úkol

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())))
Výstup
Kvíz

Proč se po odeslání okna nemá použít obsah.clear()?

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.

Úkol

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])))
Výstup
Úkol

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)))
Výstup

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)
Výstup
(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.

Úkol

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))
Výstup
Kvíz

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í?

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.

Úkol

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
Výstup

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)
Výstup
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á: True

Vrata 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)))
Výstup
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.