0 dní v řadě · 0 bodů

Objekty · 60 min

Mise: skladový systém

Postavíš sklad s oceněním FIFO, objednávkami typu všechno nebo nic, upozorněním na docházející zboží a zálohou do JSON.

Hloubka
Úkoly
Lidsky řečeno

Představ si regál s mlékem. Nové krabice se dávají dozadu a bere se zepředu, aby nic nezůstalo ležet. Tomuhle pořadí se říká FIFO, z anglického first in, first out, tedy co přišlo první, odchází první. Sklad dílny funguje stejně, jen si navíc pamatuje, za kolik která krabice přišla.

Plán: kdo za co odpovídá

První nápad bývá slovník. Na pár řádků stačí, jenže nic nehlídá, co se s ním děje.

sklad = {"RET-11": {"kusy": 2, "cena": 31900}}

sklad["RET-11"]["kusy"] -= 5      # vydáme víc, než máme
sklad["RET-11"]["kuzy"] = 10      # překlep vytvoří nový klíč

print(sklad)
Výstup
{'RET-11': {'kusy': -3, 'cena': 31900, 'kuzy': 10}}

Záporný sklad a překlep prošly bez jediné chyby. Navíc jedna cena neumí popsat dvě dávky koupené za různé peníze. Data proto schováš do objektů, které si pravidla ohlídají samy.

Tady se hodí všechno z minulých lekcí. Rozdělení vychází z otázky ze zásady S: co se může měnit a z jakého důvodu.

ČástOdpovídá zaDůvod ke změně
Produktplatné údaje o zbožíco o zboží evidujeme
Kartadávky a výpočet FIFOzpůsob oceňování
Pohybjeden neměnný záznam historieco chceme auditovat
Skladpravidla nad celým sklademjak fungují objednávky
posluchačireakce na nízký stavkdo a jak se dozví
do_jsonu, z_jsonuformát uloženíkam a jak se ukládá
text
   objednávky, příjemky
            |
            v
        +-------+    nízký stav    +------------+
        | Sklad | ---------------> | posluchači |
        +-------+                  +------------+
         |     |
         v     v
    +-------+ +-------+
    | Karta | | Pohyb |     do_jsonu / z_jsonu stojí vedle:
    +-------+ +-------+     Sklad o formátu JSON nic neví
         |
         v
    +-------+
    | Davka |
    +-------+

Všechny částky jsou v haléřích jako celá čísla, takže 31900 je 319,00 Kč. Desetinná čísla by při sčítání peněz dělala drobné chyby. SKU je kód zboží, podle kterého se produkt hledá, třeba RET-11.

Krok 1: produkt a skladová karta

Produkt se po založení nemění, a tak je z něj zmrazená dataclass. Vlastní výjimky zase nesou data. Kdo chybu chytí, nemusí nic luštit z textu.

Úkol

Úkol 1: produkt a chyba s daty

Doplň dvě věci.

NedostatekZbozi(sku, pozadovano, dostupne) je potomek ChybaSkladu. Uloží si všechny tři hodnoty do stejně pojmenovaných atributů a její text obsahuje SKU.

Produkt.__post_init__ vyvolá ValueError, když:

  • sku je prázdné, nebo se liší od sku.strip().upper(), takže neprojde ret-11 ani RET-11,
  • nazev je prázdný nebo samé mezery,
  • minimum je záporné.
from dataclasses import dataclass

class ChybaSkladu(Exception):
    """Společný předek: volající může chytit všechny problémy skladu najednou."""


class NeznamyProdukt(ChybaSkladu):
    """SKU není v katalogu."""


class DuplicitniProdukt(ChybaSkladu):
    """SKU už v katalogu je."""

class NedostatekZbozi(ChybaSkladu):
    """Na skladě je méně kusů, než se požaduje."""

    # doplň __init__(self, sku, pozadovano, dostupne)

@dataclass(frozen=True)
class Produkt:
    sku: str
    nazev: str
    minimum: int = 0

    def __post_init__(self) -> None:
        # doplň kontroly
        pass

retez = Produkt("RET-11", "Řetěz", minimum=4)
print(retez)
Výstup

Teď FIFO. Dílna koupí 10 řetězů po 319 Kč a později 5 po 349 Kč. Prodá 12. Kolik ji prodané kusy stály?

text
příjem 10 ks po 319,00    [10 ks po 319]
příjem  5 ks po 349,00    [10 ks po 319] [5 ks po 349]

výdej 12 ks:
  z první dávky 10 ks     10 x 319,00 = 3 190,00   dávka zmizí
  z druhé dávky  2 ks      2 x 349,00 =   698,00
                          náklad        3 888,00

zbývá                     [3 ks po 349]            hodnota 1 047,00

Dávky tvoří frontu. Nové se přidávají na konec, odebírá se ze začátku. Přesně na to je deque z modulu collections.

from collections import deque

fronta = deque(["první dávka", "druhá dávka"])
fronta.append("třetí dávka")

print(fronta[0])
print(fronta.popleft())
print(list(fronta))
Výstup
první dávka
první dávka
['druhá dávka', 'třetí dávka']
Úkol

Úkol 2: karta s výdejem FIFO

Doplň ve třídě Karta:

  • vlastnost kusy: součet kusů ve všech dávkách,
  • vlastnost hodnota: součet kusy * cena přes dávky,
  • metodu vydej(kusy): odebere kusy od nejstarší dávky, prázdné dávky zahodí a vrátí náklad v haléřích.

vydej vyvolá ValueError, když kusy <= 0, a NedostatekZbozi, když je kusů málo. V obou případech karta zůstane beze změny.

from collections import deque
from dataclasses import dataclass

class ChybaSkladu(Exception):
    """Společný předek: volající může chytit všechny problémy skladu najednou."""


class NeznamyProdukt(ChybaSkladu):
    """SKU není v katalogu."""


class DuplicitniProdukt(ChybaSkladu):
    """SKU už v katalogu je."""

class NedostatekZbozi(ChybaSkladu):
    """Na skladě je méně kusů, než se požaduje."""

    def __init__(self, sku: str, pozadovano: int, dostupne: int):
        super().__init__(f"{sku}: požadováno {pozadovano} ks, dostupné {dostupne} ks")
        self.sku = sku
        self.pozadovano = pozadovano
        self.dostupne = dostupne

@dataclass(frozen=True)
class Produkt:
    sku: str
    nazev: str
    minimum: int = 0

    def __post_init__(self) -> None:
        if not self.sku or self.sku != self.sku.strip().upper():
            raise ValueError(f"Neplatné SKU: {self.sku!r}")
        if not self.nazev.strip():
            raise ValueError("Produkt musí mít název.")
        if self.minimum < 0:
            raise ValueError("Minimum nesmí být záporné.")

@dataclass
class Davka:
    kusy: int
    cena: int  # haléře za kus


class Karta:
    """Skladová karta jednoho produktu: dávky od nejstarší po nejnovější."""

    def __init__(self, produkt: Produkt):
        self.produkt = produkt
        self._davky: deque[Davka] = deque()

    @property
    def davky(self) -> list[tuple[int, int]]:
        return [(davka.kusy, davka.cena) for davka in self._davky]

    def prijmi(self, kusy: int, cena: int) -> None:
        if kusy <= 0:
            raise ValueError("Počet kusů musí být kladný.")
        if cena < 0:
            raise ValueError("Cena nesmí být záporná.")
        self._davky.append(Davka(kusy, cena))

    @property
    def kusy(self) -> int:
        return 0  # doplň

    @property
    def hodnota(self) -> int:
        return 0  # doplň

    def vydej(self, kusy: int) -> int:
        return 0  # doplň

karta = Karta(Produkt("RET-11", "Řetěz"))
karta.prijmi(10, 31900)
karta.prijmi(5, 34900)
print(karta.vydej(12), karta.kusy, karta.hodnota)
Výstup
Kvíz

Proč Karta hodnotu pokaždé spočítá a neukládá ji do atributu?

Pod kapotou · FIFO, průměr a cena za odvozený stav

deque.popleft je O(1), zatímco list.pop(0) posouvá celé pole a je O(n). kusy je tu O(počet dávek), což je obvykle malé číslo. Průběžný součet by zrychlil čtení, ale přidal invariant, který musí držet každá mutace. To se vyplatí až po změření.

FIFO v celých číslech je přesné, protože každý kus má konkrétní cenu. Metoda váženého průměru vyžaduje zaokrouhlení: 3 kusy za 100 haléřů nejdou rozdělit beze zbytku a součet nákladů se pak od pořizovací ceny odchýlí. Řeší se to přidělením zbytku, například metodou největších zbytků. Volba metody oceňování je účetní rozhodnutí, ne technické, proto je schovaná v jedné třídě.

frozen=True hlídá jen přiřazení do atributů instance. Objekt uložený uvnitř zůstává měnitelný, a tak je Davka záměrně interní a davky vrací kopie v n-ticích. Se slots=True navíc ušetříš paměť a odhalíš překlepy v názvech atributů.

Krok 2: sklad jako jediné dveře

Karet budou desítky. Kdyby si je každý bral přímo, někdo vydá zboží a zapomene zapsat pohyb. Proto kolem nich postavíš třídu Sklad. Tomuhle vzoru se říká fasáda: jedno místo, přes které vede cesta dovnitř a kde platí všechna pravidla. Karty do ní patří jako části celku, což je kompozice z lekce Kompozice místo dědičnosti.

Historii drží seznam neměnných Pohyb. Ven jde jako n-tice, aby si do ní nikdo nepřipsal řádek.

Úkol

Úkol 3: fasáda a historie

Doplň třídu Sklad. TypPohybu, Pohyb a metoda zaloz jsou hotové. Požadavky:

  • prijem(sku, kusy, cena) přijme dávku a vrátí Pohyb s částkou kusy * cena,
  • vydej(sku, kusy) vydá zboží a vrátí Pohyb, jehož částka je náklad FIFO,
  • stav(sku) vrátí počet kusů,
  • hodnota je vlastnost: hodnota celého skladu,
  • pohyby je vlastnost: n-tice všech pohybů,
  • neznámé SKU vždy vyvolá NeznamyProdukt,
  • pohyby se číslují od 1 a neúspěšná operace žádný nevytvoří.
from collections import deque
from dataclasses import dataclass
from enum import Enum

class ChybaSkladu(Exception):
    """Společný předek: volající může chytit všechny problémy skladu najednou."""


class NeznamyProdukt(ChybaSkladu):
    """SKU není v katalogu."""


class DuplicitniProdukt(ChybaSkladu):
    """SKU už v katalogu je."""

class NedostatekZbozi(ChybaSkladu):
    """Na skladě je méně kusů, než se požaduje."""

    def __init__(self, sku: str, pozadovano: int, dostupne: int):
        super().__init__(f"{sku}: požadováno {pozadovano} ks, dostupné {dostupne} ks")
        self.sku = sku
        self.pozadovano = pozadovano
        self.dostupne = dostupne

@dataclass(frozen=True)
class Produkt:
    sku: str
    nazev: str
    minimum: int = 0

    def __post_init__(self) -> None:
        if not self.sku or self.sku != self.sku.strip().upper():
            raise ValueError(f"Neplatné SKU: {self.sku!r}")
        if not self.nazev.strip():
            raise ValueError("Produkt musí mít název.")
        if self.minimum < 0:
            raise ValueError("Minimum nesmí být záporné.")

@dataclass
class Davka:
    kusy: int
    cena: int  # haléře za kus


class Karta:
    """Skladová karta jednoho produktu: dávky od nejstarší po nejnovější."""

    def __init__(self, produkt: Produkt):
        self.produkt = produkt
        self._davky: deque[Davka] = deque()

    @property
    def davky(self) -> list[tuple[int, int]]:
        return [(davka.kusy, davka.cena) for davka in self._davky]

    def prijmi(self, kusy: int, cena: int) -> None:
        if kusy <= 0:
            raise ValueError("Počet kusů musí být kladný.")
        if cena < 0:
            raise ValueError("Cena nesmí být záporná.")
        self._davky.append(Davka(kusy, cena))

    @property
    def kusy(self) -> int:
        return sum(davka.kusy for davka in self._davky)

    @property
    def hodnota(self) -> int:
        return sum(davka.kusy * davka.cena for davka in self._davky)

    def vydej(self, kusy: int) -> int:
        """Vydá kusy od nejstarší dávky a vrátí jejich pořizovací cenu."""
        if kusy <= 0:
            raise ValueError("Počet kusů musí být kladný.")
        dostupne = self.kusy
        if kusy > dostupne:
            raise NedostatekZbozi(self.produkt.sku, kusy, dostupne)
        naklad = 0
        zbyva = kusy
        while zbyva > 0:
            davka = self._davky[0]
            odber = min(zbyva, davka.kusy)
            davka.kusy -= odber
            naklad += odber * davka.cena
            zbyva -= odber
            if davka.kusy == 0:
                self._davky.popleft()
        return naklad

class TypPohybu(Enum):
    PRIJEM = "příjem"
    VYDEJ = "výdej"


@dataclass(frozen=True)
class Pohyb:
    cislo: int
    typ: TypPohybu
    sku: str
    kusy: int
    castka: int  # haléře: cena příjmu, nebo náklad výdeje

class Sklad:
    """Jediné dveře do skladu: zbytek programu mluví jen s touhle třídou."""

    def __init__(self) -> None:
        self._karty: dict[str, Karta] = {}
        self._pohyby: list[Pohyb] = []

    def zaloz(self, produkt: Produkt) -> None:
        if produkt.sku in self._karty:
            raise DuplicitniProdukt(produkt.sku)
        self._karty[produkt.sku] = Karta(produkt)

    def prijem(self, sku: str, kusy: int, cena: int) -> Pohyb | None:
        pass  # doplň

    def vydej(self, sku: str, kusy: int) -> Pohyb | None:
        pass  # doplň

    def stav(self, sku: str) -> int:
        return 0  # doplň

    @property
    def hodnota(self) -> int:
        return 0  # doplň

    @property
    def pohyby(self) -> tuple[Pohyb, ...]:
        return ()  # doplň

sklad = Sklad()
sklad.zaloz(Produkt("RET-11", "Řetěz"))
sklad.prijem("RET-11", 10, 31900)
print(sklad.vydej("RET-11", 3))
print(sklad.stav("RET-11"), sklad.hodnota)
Výstup

Krok 3: objednávka, všechno, nebo nic

Objednávka má víc řádků. Když je vydáváš jeden po druhém, první projde a druhý selže. Řetěz je pryč a zákazník nedostane nic.

stav = {"RET-11": 5, "BRZ-01": 1}
objednavka = [("RET-11", 3), ("BRZ-01", 2)]

try:
    for sku, kusy in objednavka:
        if kusy > stav[sku]:
            raise ValueError(f"Málo zboží: {sku}")
        stav[sku] -= kusy
except ValueError as chyba:
    print(chyba)

print(stav)
Výstup
Málo zboží: BRZ-01
{'RET-11': 2, 'BRZ-01': 1}

Oprava má dvě fáze. Nejdřív všechno ověř a nic přitom neměň. Až když všechno sedí, proveď změny, které už selhat nemůžou.

Úkol

Úkol 4: vydej všechno, nebo nic

Napiš metodu vydej_objednavku(polozky). polozky je seznam dvojic (sku, kusy) a stejné SKU se v něm může opakovat.

  • Když je některý počet kusů nulový nebo záporný, vyvolej ValueError.
  • Neznámé SKU vyvolá NeznamyProdukt.
  • Když na některé SKU nestačí zásoba, vyvolej NedostatekZbozi s celkovým požadovaným množstvím.
  • Při každé z těchto chyb zůstane sklad i historie beze změny.
  • Jinak vydej vše a vrať seznam pohybů, jeden za každý řádek objednávky.
from collections import deque
from dataclasses import dataclass
from enum import Enum

class ChybaSkladu(Exception):
    """Společný předek: volající může chytit všechny problémy skladu najednou."""


class NeznamyProdukt(ChybaSkladu):
    """SKU není v katalogu."""


class DuplicitniProdukt(ChybaSkladu):
    """SKU už v katalogu je."""

class NedostatekZbozi(ChybaSkladu):
    """Na skladě je méně kusů, než se požaduje."""

    def __init__(self, sku: str, pozadovano: int, dostupne: int):
        super().__init__(f"{sku}: požadováno {pozadovano} ks, dostupné {dostupne} ks")
        self.sku = sku
        self.pozadovano = pozadovano
        self.dostupne = dostupne

@dataclass(frozen=True)
class Produkt:
    sku: str
    nazev: str
    minimum: int = 0

    def __post_init__(self) -> None:
        if not self.sku or self.sku != self.sku.strip().upper():
            raise ValueError(f"Neplatné SKU: {self.sku!r}")
        if not self.nazev.strip():
            raise ValueError("Produkt musí mít název.")
        if self.minimum < 0:
            raise ValueError("Minimum nesmí být záporné.")

@dataclass
class Davka:
    kusy: int
    cena: int  # haléře za kus


class Karta:
    """Skladová karta jednoho produktu: dávky od nejstarší po nejnovější."""

    def __init__(self, produkt: Produkt):
        self.produkt = produkt
        self._davky: deque[Davka] = deque()

    @property
    def davky(self) -> list[tuple[int, int]]:
        return [(davka.kusy, davka.cena) for davka in self._davky]

    def prijmi(self, kusy: int, cena: int) -> None:
        if kusy <= 0:
            raise ValueError("Počet kusů musí být kladný.")
        if cena < 0:
            raise ValueError("Cena nesmí být záporná.")
        self._davky.append(Davka(kusy, cena))

    @property
    def kusy(self) -> int:
        return sum(davka.kusy for davka in self._davky)

    @property
    def hodnota(self) -> int:
        return sum(davka.kusy * davka.cena for davka in self._davky)

    def vydej(self, kusy: int) -> int:
        """Vydá kusy od nejstarší dávky a vrátí jejich pořizovací cenu."""
        if kusy <= 0:
            raise ValueError("Počet kusů musí být kladný.")
        dostupne = self.kusy
        if kusy > dostupne:
            raise NedostatekZbozi(self.produkt.sku, kusy, dostupne)
        naklad = 0
        zbyva = kusy
        while zbyva > 0:
            davka = self._davky[0]
            odber = min(zbyva, davka.kusy)
            davka.kusy -= odber
            naklad += odber * davka.cena
            zbyva -= odber
            if davka.kusy == 0:
                self._davky.popleft()
        return naklad

class TypPohybu(Enum):
    PRIJEM = "příjem"
    VYDEJ = "výdej"


@dataclass(frozen=True)
class Pohyb:
    cislo: int
    typ: TypPohybu
    sku: str
    kusy: int
    castka: int  # haléře: cena příjmu, nebo náklad výdeje

class Sklad:
    """Jediné dveře do skladu: zbytek programu mluví jen s touhle třídou."""

    def __init__(self) -> None:
        self._karty: dict[str, Karta] = {}
        self._pohyby: list[Pohyb] = []

    def zaloz(self, produkt: Produkt) -> None:
        if produkt.sku in self._karty:
            raise DuplicitniProdukt(produkt.sku)
        self._karty[produkt.sku] = Karta(produkt)

    def _karta(self, sku: str) -> Karta:
        try:
            return self._karty[sku]
        except KeyError:
            raise NeznamyProdukt(sku) from None

    def _zapis(self, typ: TypPohybu, sku: str, kusy: int, castka: int) -> Pohyb:
        pohyb = Pohyb(len(self._pohyby) + 1, typ, sku, kusy, castka)
        self._pohyby.append(pohyb)
        return pohyb

    def prijem(self, sku: str, kusy: int, cena: int) -> Pohyb:
        self._karta(sku).prijmi(kusy, cena)
        return self._zapis(TypPohybu.PRIJEM, sku, kusy, kusy * cena)

    def vydej(self, sku: str, kusy: int) -> Pohyb:
        naklad = self._karta(sku).vydej(kusy)
        return self._zapis(TypPohybu.VYDEJ, sku, kusy, naklad)

    def stav(self, sku: str) -> int:
        return self._karta(sku).kusy

    @property
    def hodnota(self) -> int:
        return sum(karta.hodnota for karta in self._karty.values())

    @property
    def pohyby(self) -> tuple[Pohyb, ...]:
        return tuple(self._pohyby)

    def vydej_objednavku(self, polozky: list[tuple[str, int]]) -> list[Pohyb]:
        return []  # doplň

sklad = Sklad()
sklad.zaloz(Produkt("RET-11", "Řetěz"))
sklad.zaloz(Produkt("BRZ-01", "Destičky"))
sklad.prijem("RET-11", 5, 31900)
sklad.prijem("BRZ-01", 1, 18900)
try:
    sklad.vydej_objednavku([("RET-11", 3), ("BRZ-01", 2)])
except NedostatekZbozi as chyba:
    print(chyba)
print(sklad.stav("RET-11"), sklad.stav("BRZ-01"))
Výstup
Kvíz

Na skladě je 5 kusů zboží A. Co má udělat vydej_objednavku([("A", 2), ("A", 4)])?

Pod kapotou · check-then-act mimo jedno vlákno

Ověření a provedení tu drží pohromadě jen proto, že mezi nimi nic jiného neběží. S vlákny vznikne souběh a potřebuješ threading.Lock kolem celé metody. V asyncio je kód atomický jen do nejbližšího await. Přes víc procesů zámek v paměti nepomůže.

V databázi nech rozhodnutí na jediném příkazu a kontroluj počet změněných řádků. Vše obal do transakce:

text
UPDATE zasoby SET kusy = kusy - :n WHERE sku = :sku AND kusy >= :n;
-- 0 změněných řádků znamená nedostatek: ROLLBACK

Přes víc služeb transakce nedosáhne. Tam nastupují rezervace s expirací a kompenzační kroky (saga). Rezervace jsou i obchodní vylepšení: zboží v košíku přestane být volné ještě před zaplacením.

Krok 4: upozornění a záloha

Dílna chce vědět, když řetězy docházejí. Sklad ale nemá znát e-mail, SMS ani chat, to by porušilo zásadu D. Proto si jen vede seznam posluchačů: funkcí, které zavolá, když se něco stane. Kdo chce zprávu, přihlásí se. Vzoru se říká pozorovatel (observer).

Druhá otázka je kdy volat. Kdyby se upozornění posílalo při každém výdeji pod minimem, nákupčí by dostal stejnou zprávu pořád dokola. Správné je reagovat na přechod přes hranici.

minimum = 5
stavy = [8, 6, 4, 3, 2, 9, 4]

for pred, po in zip(stavy, stavy[1:]):
    pod_minimem = po < minimum
    prechod = pred >= minimum > po
    print(f"{pred} -> {po}   pod minimem: {pod_minimem!s:<6} přechod: {prechod}")
Výstup
8 -> 6   pod minimem: False  přechod: False
6 -> 4   pod minimem: True   přechod: True
4 -> 3   pod minimem: True   přechod: False
3 -> 2   pod minimem: True   přechod: False
2 -> 9   pod minimem: False  přechod: False
9 -> 4   pod minimem: True   přechod: True

Podmínka se zapíná jen dvakrát: poprvé při poklesu na 4 a znovu po doplnění zásob a dalším poklesu.

Úkol

Úkol 5: upozornění na nízký stav

Přidej do Sklad:

  • atributy _posluchaci a chyby_upozorneni, oba na začátku prázdné seznamy,
  • metodu odebirej(posluchac), která funkci zaregistruje,
  • do vydej volání všech posluchačů jako posluchac(produkt, kusy), a to jen když stav právě klesl pod minimum, tedy předtím byl >= minimum a teď je < minimum.

Porouchaný posluchač nesmí shodit výdej ani zastavit ostatní posluchače. Jeho výjimku (Exception) přidej do chyby_upozorneni.

from collections import deque
from collections.abc import Callable
from dataclasses import dataclass
from enum import Enum

class ChybaSkladu(Exception):
    """Společný předek: volající může chytit všechny problémy skladu najednou."""


class NeznamyProdukt(ChybaSkladu):
    """SKU není v katalogu."""


class DuplicitniProdukt(ChybaSkladu):
    """SKU už v katalogu je."""

class NedostatekZbozi(ChybaSkladu):
    """Na skladě je méně kusů, než se požaduje."""

    def __init__(self, sku: str, pozadovano: int, dostupne: int):
        super().__init__(f"{sku}: požadováno {pozadovano} ks, dostupné {dostupne} ks")
        self.sku = sku
        self.pozadovano = pozadovano
        self.dostupne = dostupne

@dataclass(frozen=True)
class Produkt:
    sku: str
    nazev: str
    minimum: int = 0

    def __post_init__(self) -> None:
        if not self.sku or self.sku != self.sku.strip().upper():
            raise ValueError(f"Neplatné SKU: {self.sku!r}")
        if not self.nazev.strip():
            raise ValueError("Produkt musí mít název.")
        if self.minimum < 0:
            raise ValueError("Minimum nesmí být záporné.")

@dataclass
class Davka:
    kusy: int
    cena: int  # haléře za kus


class Karta:
    """Skladová karta jednoho produktu: dávky od nejstarší po nejnovější."""

    def __init__(self, produkt: Produkt):
        self.produkt = produkt
        self._davky: deque[Davka] = deque()

    @property
    def davky(self) -> list[tuple[int, int]]:
        return [(davka.kusy, davka.cena) for davka in self._davky]

    def prijmi(self, kusy: int, cena: int) -> None:
        if kusy <= 0:
            raise ValueError("Počet kusů musí být kladný.")
        if cena < 0:
            raise ValueError("Cena nesmí být záporná.")
        self._davky.append(Davka(kusy, cena))

    @property
    def kusy(self) -> int:
        return sum(davka.kusy for davka in self._davky)

    @property
    def hodnota(self) -> int:
        return sum(davka.kusy * davka.cena for davka in self._davky)

    def vydej(self, kusy: int) -> int:
        """Vydá kusy od nejstarší dávky a vrátí jejich pořizovací cenu."""
        if kusy <= 0:
            raise ValueError("Počet kusů musí být kladný.")
        dostupne = self.kusy
        if kusy > dostupne:
            raise NedostatekZbozi(self.produkt.sku, kusy, dostupne)
        naklad = 0
        zbyva = kusy
        while zbyva > 0:
            davka = self._davky[0]
            odber = min(zbyva, davka.kusy)
            davka.kusy -= odber
            naklad += odber * davka.cena
            zbyva -= odber
            if davka.kusy == 0:
                self._davky.popleft()
        return naklad

class TypPohybu(Enum):
    PRIJEM = "příjem"
    VYDEJ = "výdej"


@dataclass(frozen=True)
class Pohyb:
    cislo: int
    typ: TypPohybu
    sku: str
    kusy: int
    castka: int  # haléře: cena příjmu, nebo náklad výdeje

Posluchac = Callable[[Produkt, int], None]

class Sklad:
    """Jediné dveře do skladu: zbytek programu mluví jen s touhle třídou."""

    def __init__(self) -> None:
        self._karty: dict[str, Karta] = {}
        self._pohyby: list[Pohyb] = []

    def zaloz(self, produkt: Produkt) -> None:
        if produkt.sku in self._karty:
            raise DuplicitniProdukt(produkt.sku)
        self._karty[produkt.sku] = Karta(produkt)

    def _karta(self, sku: str) -> Karta:
        try:
            return self._karty[sku]
        except KeyError:
            raise NeznamyProdukt(sku) from None

    def _zapis(self, typ: TypPohybu, sku: str, kusy: int, castka: int) -> Pohyb:
        pohyb = Pohyb(len(self._pohyby) + 1, typ, sku, kusy, castka)
        self._pohyby.append(pohyb)
        return pohyb

    def prijem(self, sku: str, kusy: int, cena: int) -> Pohyb:
        self._karta(sku).prijmi(kusy, cena)
        return self._zapis(TypPohybu.PRIJEM, sku, kusy, kusy * cena)

    def vydej(self, sku: str, kusy: int) -> Pohyb:
        naklad = self._karta(sku).vydej(kusy)
        return self._zapis(TypPohybu.VYDEJ, sku, kusy, naklad)

    def stav(self, sku: str) -> int:
        return self._karta(sku).kusy

    @property
    def hodnota(self) -> int:
        return sum(karta.hodnota for karta in self._karty.values())

    @property
    def pohyby(self) -> tuple[Pohyb, ...]:
        return tuple(self._pohyby)

    def vydej_objednavku(self, polozky: list[tuple[str, int]]) -> list[Pohyb]:
        """Vydá všechny řádky objednávky, nebo žádný."""
        soucty: dict[str, int] = {}
        for sku, kusy in polozky:
            if kusy <= 0:
                raise ValueError("Počet kusů musí být kladný.")
            soucty[sku] = soucty.get(sku, 0) + kusy
        for sku, kusy in soucty.items():
            dostupne = self._karta(sku).kusy
            if kusy > dostupne:
                raise NedostatekZbozi(sku, kusy, dostupne)
        return [self.vydej(sku, kusy) for sku, kusy in polozky]

    def odebirej(self, posluchac: Posluchac) -> None:
        pass  # doplň

sklad = Sklad()
sklad.odebirej(lambda produkt, kusy: print("Doobjednat:", produkt.nazev, kusy))
sklad.zaloz(Produkt("RET-11", "Řetěz", minimum=4))
sklad.prijem("RET-11", 6, 31900)
sklad.vydej("RET-11", 3)
sklad.vydej("RET-11", 1)
Výstup

Zbývá záloha. Sklad nemá vědět nic o JSON, ten se může jednou vyměnit za databázi. Umí jen vydat svůj stav jako obyčejná data a znovu se z nich postavit. O převod na text se starají dvě malé funkce vedle. Pozor na pár věcí, které JSON neumí:

import json
from enum import Enum


class TypPohybu(Enum):
    PRIJEM = "příjem"


try:
    json.dumps({"typ": TypPohybu.PRIJEM})
except TypeError as chyba:
    print("Chyba:", chyba)

print(json.dumps({"typ": TypPohybu.PRIJEM.value}, ensure_ascii=False))
print(TypPohybu("příjem"))
print(json.loads(json.dumps({"davka": (10, 31900)})))
Výstup
Chyba: Object of type TypPohybu is not JSON serializable
{"typ": "příjem"}
TypPohybu.PRIJEM
{'davka': [10, 31900]}

Výčet se ukládá přes .value a zpátky se získá voláním TypPohybu(hodnota). N-tice se vrací jako seznam. A hlavně musí přežít pořadí dávek, jinak by po načtení FIFO počítalo špatně.

Úkol

Úkol 6: záloha do JSON

Doplň:

  • Sklad.snimek() vrátí slovník jen z typů, které zná JSON. Musí obsahovat "verze": 1, produkty včetně minima a dávek v pořadí a všechny pohyby.
  • Sklad.ze_snimku(data) (metoda třídy) z něj postaví nový sklad. Při jiné verzi než 1 vyvolá ValueError.
  • do_jsonu(sklad) vrátí text JSON a z_jsonu(text) z něj vrátí Sklad.

Posluchači se neukládají. Načtení nesmí přidávat nové pohyby ani nikoho upozorňovat.

import json
from collections import deque
from collections.abc import Callable
from dataclasses import dataclass
from enum import Enum

class ChybaSkladu(Exception):
    """Společný předek: volající může chytit všechny problémy skladu najednou."""


class NeznamyProdukt(ChybaSkladu):
    """SKU není v katalogu."""


class DuplicitniProdukt(ChybaSkladu):
    """SKU už v katalogu je."""

class NedostatekZbozi(ChybaSkladu):
    """Na skladě je méně kusů, než se požaduje."""

    def __init__(self, sku: str, pozadovano: int, dostupne: int):
        super().__init__(f"{sku}: požadováno {pozadovano} ks, dostupné {dostupne} ks")
        self.sku = sku
        self.pozadovano = pozadovano
        self.dostupne = dostupne

@dataclass(frozen=True)
class Produkt:
    sku: str
    nazev: str
    minimum: int = 0

    def __post_init__(self) -> None:
        if not self.sku or self.sku != self.sku.strip().upper():
            raise ValueError(f"Neplatné SKU: {self.sku!r}")
        if not self.nazev.strip():
            raise ValueError("Produkt musí mít název.")
        if self.minimum < 0:
            raise ValueError("Minimum nesmí být záporné.")

@dataclass
class Davka:
    kusy: int
    cena: int  # haléře za kus


class Karta:
    """Skladová karta jednoho produktu: dávky od nejstarší po nejnovější."""

    def __init__(self, produkt: Produkt):
        self.produkt = produkt
        self._davky: deque[Davka] = deque()

    @property
    def davky(self) -> list[tuple[int, int]]:
        return [(davka.kusy, davka.cena) for davka in self._davky]

    def prijmi(self, kusy: int, cena: int) -> None:
        if kusy <= 0:
            raise ValueError("Počet kusů musí být kladný.")
        if cena < 0:
            raise ValueError("Cena nesmí být záporná.")
        self._davky.append(Davka(kusy, cena))

    @property
    def kusy(self) -> int:
        return sum(davka.kusy for davka in self._davky)

    @property
    def hodnota(self) -> int:
        return sum(davka.kusy * davka.cena for davka in self._davky)

    def vydej(self, kusy: int) -> int:
        """Vydá kusy od nejstarší dávky a vrátí jejich pořizovací cenu."""
        if kusy <= 0:
            raise ValueError("Počet kusů musí být kladný.")
        dostupne = self.kusy
        if kusy > dostupne:
            raise NedostatekZbozi(self.produkt.sku, kusy, dostupne)
        naklad = 0
        zbyva = kusy
        while zbyva > 0:
            davka = self._davky[0]
            odber = min(zbyva, davka.kusy)
            davka.kusy -= odber
            naklad += odber * davka.cena
            zbyva -= odber
            if davka.kusy == 0:
                self._davky.popleft()
        return naklad

class TypPohybu(Enum):
    PRIJEM = "příjem"
    VYDEJ = "výdej"


@dataclass(frozen=True)
class Pohyb:
    cislo: int
    typ: TypPohybu
    sku: str
    kusy: int
    castka: int  # haléře: cena příjmu, nebo náklad výdeje

Posluchac = Callable[[Produkt, int], None]

class Sklad:
    """Jediné dveře do skladu: zbytek programu mluví jen s touhle třídou."""

    def __init__(self) -> None:
        self._karty: dict[str, Karta] = {}
        self._pohyby: list[Pohyb] = []
        self._posluchaci: list[Posluchac] = []
        self.chyby_upozorneni: list[Exception] = []

    def zaloz(self, produkt: Produkt) -> None:
        if produkt.sku in self._karty:
            raise DuplicitniProdukt(produkt.sku)
        self._karty[produkt.sku] = Karta(produkt)

    def _karta(self, sku: str) -> Karta:
        try:
            return self._karty[sku]
        except KeyError:
            raise NeznamyProdukt(sku) from None

    def _zapis(self, typ: TypPohybu, sku: str, kusy: int, castka: int) -> Pohyb:
        pohyb = Pohyb(len(self._pohyby) + 1, typ, sku, kusy, castka)
        self._pohyby.append(pohyb)
        return pohyb

    def prijem(self, sku: str, kusy: int, cena: int) -> Pohyb:
        self._karta(sku).prijmi(kusy, cena)
        return self._zapis(TypPohybu.PRIJEM, sku, kusy, kusy * cena)

    def vydej(self, sku: str, kusy: int) -> Pohyb:
        karta = self._karta(sku)
        pred = karta.kusy
        naklad = karta.vydej(kusy)
        pohyb = self._zapis(TypPohybu.VYDEJ, sku, kusy, naklad)
        if pred >= karta.produkt.minimum > karta.kusy:
            self._oznam(karta.produkt, karta.kusy)
        return pohyb

    def stav(self, sku: str) -> int:
        return self._karta(sku).kusy

    @property
    def hodnota(self) -> int:
        return sum(karta.hodnota for karta in self._karty.values())

    @property
    def pohyby(self) -> tuple[Pohyb, ...]:
        return tuple(self._pohyby)

    def vydej_objednavku(self, polozky: list[tuple[str, int]]) -> list[Pohyb]:
        """Vydá všechny řádky objednávky, nebo žádný."""
        soucty: dict[str, int] = {}
        for sku, kusy in polozky:
            if kusy <= 0:
                raise ValueError("Počet kusů musí být kladný.")
            soucty[sku] = soucty.get(sku, 0) + kusy
        for sku, kusy in soucty.items():
            dostupne = self._karta(sku).kusy
            if kusy > dostupne:
                raise NedostatekZbozi(sku, kusy, dostupne)
        return [self.vydej(sku, kusy) for sku, kusy in polozky]

    def odebirej(self, posluchac: Posluchac) -> None:
        self._posluchaci.append(posluchac)

    def _oznam(self, produkt: Produkt, kusy: int) -> None:
        for posluchac in self._posluchaci:
            try:
                posluchac(produkt, kusy)
            except Exception as chyba:
                self.chyby_upozorneni.append(chyba)

    def snimek(self) -> dict:
        return {}  # doplň

    @classmethod
    def ze_snimku(cls, data: dict) -> "Sklad":
        return cls()  # doplň

def do_jsonu(sklad: Sklad) -> str:
    return ""  # doplň


def z_jsonu(text: str) -> Sklad:
    return Sklad()  # doplň

sklad = Sklad()
sklad.zaloz(Produkt("RET-11", "Řetěz", minimum=4))
sklad.prijem("RET-11", 6, 31900)
text = do_jsonu(sklad)
print(text)
print(z_jsonu(text).hodnota)
Výstup
Kvíz

Sklad.ze_snimku vkládá dávky přímo do karet a pohyby přes _zapis. Proč nevolá prijem a vydej?

Pod kapotou · od pozorovatele k outboxu a event sourcingu

Posluchači tu běží synchronně uvnitř výdeje, takže pomalá brána zdrží sklad. V systému s databází navíc hrozí dvě chyby: zpráva odejde a transakce se vrátí, nebo se transakce potvrdí a proces spadne dřív, než zpráva odejde. Standardní řešení je transactional outbox: událost se zapíše do tabulky ve stejné transakci a samostatný proces ji doručí aspoň jednou. Příjemce pak musí být idempotentní.

Seznam posluchačů drží silné reference, takže metoda dlouho žijícího skladu udrží svůj objekt v paměti. Pomůže odhlášení nebo weakref.WeakMethod.

Všimni si redundance ve snímku: dávky jdou odvodit z historie, když ji přehraješ od začátku. Stav jako výsledek přehrání událostí je event sourcing a snímek je běžná optimalizace, aby se nemuselo přehrávat vše. Levný a silný test je ověřit, že přehraná historie dá stejné dávky jako snímek.

Pole verze je malá investice. Při změně formátu napíšeš řetěz migrací v1 -> v2 -> v3 a stará záloha zůstane čitelná. A pokud JSON čte JavaScript, celá čísla nad 2^53 v něm ztrácejí přesnost. Velké částky se proto v API často posílají jako text.

Celý program

Poslední dílky jsou krátké: prehled vrátí data pro výpis a tisk zůstane mimo sklad ve funkci vypis_prehled. Tady je všechno pohromadě, včetně provozu jednoho dne v dílně.

import json
from collections import deque
from collections.abc import Callable
from dataclasses import dataclass
from enum import Enum

class ChybaSkladu(Exception):
    """Společný předek: volající může chytit všechny problémy skladu najednou."""


class NeznamyProdukt(ChybaSkladu):
    """SKU není v katalogu."""


class DuplicitniProdukt(ChybaSkladu):
    """SKU už v katalogu je."""

class NedostatekZbozi(ChybaSkladu):
    """Na skladě je méně kusů, než se požaduje."""

    def __init__(self, sku: str, pozadovano: int, dostupne: int):
        super().__init__(f"{sku}: požadováno {pozadovano} ks, dostupné {dostupne} ks")
        self.sku = sku
        self.pozadovano = pozadovano
        self.dostupne = dostupne

@dataclass(frozen=True)
class Produkt:
    sku: str
    nazev: str
    minimum: int = 0

    def __post_init__(self) -> None:
        if not self.sku or self.sku != self.sku.strip().upper():
            raise ValueError(f"Neplatné SKU: {self.sku!r}")
        if not self.nazev.strip():
            raise ValueError("Produkt musí mít název.")
        if self.minimum < 0:
            raise ValueError("Minimum nesmí být záporné.")

@dataclass
class Davka:
    kusy: int
    cena: int  # haléře za kus


class Karta:
    """Skladová karta jednoho produktu: dávky od nejstarší po nejnovější."""

    def __init__(self, produkt: Produkt):
        self.produkt = produkt
        self._davky: deque[Davka] = deque()

    @property
    def davky(self) -> list[tuple[int, int]]:
        return [(davka.kusy, davka.cena) for davka in self._davky]

    def prijmi(self, kusy: int, cena: int) -> None:
        if kusy <= 0:
            raise ValueError("Počet kusů musí být kladný.")
        if cena < 0:
            raise ValueError("Cena nesmí být záporná.")
        self._davky.append(Davka(kusy, cena))

    @property
    def kusy(self) -> int:
        return sum(davka.kusy for davka in self._davky)

    @property
    def hodnota(self) -> int:
        return sum(davka.kusy * davka.cena for davka in self._davky)

    def vydej(self, kusy: int) -> int:
        """Vydá kusy od nejstarší dávky a vrátí jejich pořizovací cenu."""
        if kusy <= 0:
            raise ValueError("Počet kusů musí být kladný.")
        dostupne = self.kusy
        if kusy > dostupne:
            raise NedostatekZbozi(self.produkt.sku, kusy, dostupne)
        naklad = 0
        zbyva = kusy
        while zbyva > 0:
            davka = self._davky[0]
            odber = min(zbyva, davka.kusy)
            davka.kusy -= odber
            naklad += odber * davka.cena
            zbyva -= odber
            if davka.kusy == 0:
                self._davky.popleft()
        return naklad

class TypPohybu(Enum):
    PRIJEM = "příjem"
    VYDEJ = "výdej"


@dataclass(frozen=True)
class Pohyb:
    cislo: int
    typ: TypPohybu
    sku: str
    kusy: int
    castka: int  # haléře: cena příjmu, nebo náklad výdeje

Posluchac = Callable[[Produkt, int], None]

class Sklad:
    """Jediné dveře do skladu: zbytek programu mluví jen s touhle třídou."""

    def __init__(self) -> None:
        self._karty: dict[str, Karta] = {}
        self._pohyby: list[Pohyb] = []
        self._posluchaci: list[Posluchac] = []
        self.chyby_upozorneni: list[Exception] = []

    def zaloz(self, produkt: Produkt) -> None:
        if produkt.sku in self._karty:
            raise DuplicitniProdukt(produkt.sku)
        self._karty[produkt.sku] = Karta(produkt)

    def _karta(self, sku: str) -> Karta:
        try:
            return self._karty[sku]
        except KeyError:
            raise NeznamyProdukt(sku) from None

    def _zapis(self, typ: TypPohybu, sku: str, kusy: int, castka: int) -> Pohyb:
        pohyb = Pohyb(len(self._pohyby) + 1, typ, sku, kusy, castka)
        self._pohyby.append(pohyb)
        return pohyb

    def prijem(self, sku: str, kusy: int, cena: int) -> Pohyb:
        self._karta(sku).prijmi(kusy, cena)
        return self._zapis(TypPohybu.PRIJEM, sku, kusy, kusy * cena)

    def vydej(self, sku: str, kusy: int) -> Pohyb:
        karta = self._karta(sku)
        pred = karta.kusy
        naklad = karta.vydej(kusy)
        pohyb = self._zapis(TypPohybu.VYDEJ, sku, kusy, naklad)
        if pred >= karta.produkt.minimum > karta.kusy:
            self._oznam(karta.produkt, karta.kusy)
        return pohyb

    def stav(self, sku: str) -> int:
        return self._karta(sku).kusy

    @property
    def hodnota(self) -> int:
        return sum(karta.hodnota for karta in self._karty.values())

    @property
    def pohyby(self) -> tuple[Pohyb, ...]:
        return tuple(self._pohyby)

    def vydej_objednavku(self, polozky: list[tuple[str, int]]) -> list[Pohyb]:
        """Vydá všechny řádky objednávky, nebo žádný."""
        soucty: dict[str, int] = {}
        for sku, kusy in polozky:
            if kusy <= 0:
                raise ValueError("Počet kusů musí být kladný.")
            soucty[sku] = soucty.get(sku, 0) + kusy
        for sku, kusy in soucty.items():
            dostupne = self._karta(sku).kusy
            if kusy > dostupne:
                raise NedostatekZbozi(sku, kusy, dostupne)
        return [self.vydej(sku, kusy) for sku, kusy in polozky]

    def odebirej(self, posluchac: Posluchac) -> None:
        self._posluchaci.append(posluchac)

    def _oznam(self, produkt: Produkt, kusy: int) -> None:
        for posluchac in self._posluchaci:
            try:
                posluchac(produkt, kusy)
            except Exception as chyba:
                self.chyby_upozorneni.append(chyba)

    def snimek(self) -> dict:
        """Celý stav jako obyčejná data bez vlastních tříd."""
        return {
            "verze": 1,
            "produkty": [
                {
                    "sku": karta.produkt.sku,
                    "nazev": karta.produkt.nazev,
                    "minimum": karta.produkt.minimum,
                    "davky": [[kusy, cena] for kusy, cena in karta.davky],
                }
                for karta in self._karty.values()
            ],
            "pohyby": [
                {"typ": p.typ.value, "sku": p.sku, "kusy": p.kusy, "castka": p.castka}
                for p in self._pohyby
            ],
        }

    @classmethod
    def ze_snimku(cls, data: dict) -> "Sklad":
        if data.get("verze") != 1:
            raise ValueError(f"Neznámá verze dat: {data.get('verze')!r}")
        sklad = cls()
        for zaznam in data["produkty"]:
            sklad.zaloz(Produkt(zaznam["sku"], zaznam["nazev"], zaznam["minimum"]))
            karta = sklad._karta(zaznam["sku"])
            for kusy, cena in zaznam["davky"]:
                karta.prijmi(kusy, cena)
        for z in data["pohyby"]:
            sklad._zapis(TypPohybu(z["typ"]), z["sku"], z["kusy"], z["castka"])
        return sklad

    def prehled(self) -> list[tuple[Produkt, int, int]]:
        return [(k.produkt, k.kusy, k.hodnota) for k in self._karty.values()]

def do_jsonu(sklad: Sklad) -> str:
    return json.dumps(sklad.snimek(), ensure_ascii=False, indent=2)


def z_jsonu(text: str) -> Sklad:
    return Sklad.ze_snimku(json.loads(text))

def na_kc(halere: int) -> str:
    koruny, zbytek = divmod(halere, 100)
    return f"{koruny:,}".replace(",", " ") + f",{zbytek:02d} Kč"


def vypis_prehled(sklad: Sklad) -> None:
    print(f"{'SKU':<8}{'produkt':<20}{'kusy':>5}{'hodnota':>16}")
    for produkt, kusy, hodnota in sklad.prehled():
        znacka = " !" if kusy < produkt.minimum else ""
        print(f"{produkt.sku:<8}{produkt.nazev:<20}{kusy:>5}{na_kc(hodnota):>16}{znacka}")
    print(f"{'celkem':<33}{na_kc(sklad.hodnota):>16}")

sklad = Sklad()
sklad.odebirej(lambda produkt, kusy: print(f"Doobjednat: {produkt.nazev}, zbývá {kusy} ks"))

sklad.zaloz(Produkt("RET-11", "Řetěz 11 rychlostí", minimum=4))
sklad.zaloz(Produkt("DUS-29", "Duše 29 palců", minimum=6))
sklad.zaloz(Produkt("BRZ-01", "Brzdové destičky", minimum=2))

sklad.prijem("RET-11", 10, 31900)
sklad.prijem("RET-11", 5, 34900)
sklad.prijem("DUS-29", 20, 12900)
sklad.prijem("BRZ-01", 4, 18900)

sklad.vydej_objednavku([("RET-11", 7), ("DUS-29", 2)])
sklad.vydej_objednavku([("RET-11", 5), ("BRZ-01", 3)])

try:
    sklad.vydej_objednavku([("DUS-29", 1), ("BRZ-01", 5)])
except ChybaSkladu as chyba:
    print("Objednávka odmítnuta:", chyba)

kopie = z_jsonu(do_jsonu(sklad))
print("Pohybů v historii:", len(kopie.pohyby))
print("Záloha sedí:", kopie.snimek() == sklad.snimek())
print()
vypis_prehled(kopie)
Výstup
Doobjednat: Řetěz 11 rychlostí, zbývá 3 ks
Doobjednat: Brzdové destičky, zbývá 1 ks
Objednávka odmítnuta: BRZ-01: požadováno 5 ks, dostupné 1 ks
Pohybů v historii: 8
Záloha sedí: True

SKU     produkt              kusy         hodnota
RET-11  Řetěz 11 rychlostí      3     1 047,00 Kč !
DUS-29  Duše 29 palců          18     2 322,00 Kč
BRZ-01  Brzdové destičky        1       189,00 Kč !
celkem                                3 558,00 Kč

Projdi si výsledek. Druhá objednávka srazila řetězy i destičky pod minimum, takže přišla dvě upozornění. Třetí objednávka chtěla víc destiček, než je na skladě, a neprošla celá, duše tedy zůstaly netknuté. Zbylé řetězy jsou oceněné cenou poslední, dražší dávky, protože levnější kusy odešly první.

Takhle se v kódu projevily zásady z lekce Návrh: SOLID bez dogmat:

ZásadaKde ji vidíš
Soceňování je v Karta, formát v do_jsonu, tisk ve vypis_prehled
Onový způsob upozornění je další posluchač, Sklad se nemění
LNedostatekZbozi jde chytit jako ChybaSkladu a chová se stejně
Iposluchač je obyčejná funkce se dvěma parametry
DSklad nezná e-mail ani bránu, dostane je zvenčí

Vědomě tu není rozhraní pro úložiště ani tovární třída. Zatím je jen jeden formát, a tak by neměly co oddělovat.