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)
{'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.
| Část | Odpovídá za | Důvod ke změně |
|---|---|---|
Produkt | platné údaje o zboží | co o zboží evidujeme |
Karta | dávky a výpočet FIFO | způsob oceňování |
Pohyb | jeden neměnný záznam historie | co chceme auditovat |
Sklad | pravidla nad celým skladem | jak fungují objednávky |
| posluchači | reakce na nízký stav | kdo a jak se dozví |
do_jsonu, z_jsonu | formát uložení | kam a jak se ukládá |
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 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ž:
skuje prázdné, nebo se liší odsku.strip().upper(), takže neprojderet-11aniRET-11,nazevje prázdný nebo samé mezery,minimumje 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)
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?
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,00Dá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))
první dávka první dávka ['druhá dávka', 'třetí dávka']
Ú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četkusy * cenapř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)
Proč Karta hodnotu pokaždé spočítá a neukládá ji do atributu?
Co se dá odvodit, nemusíš synchronizovat. Uložená kopie by se při první zapomenuté aktualizaci začala lišit od skutečnosti.
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 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íPohybs částkoukusy * cena,vydej(sku, kusy)vydá zboží a vrátíPohyb, jehož částka je náklad FIFO,stav(sku)vrátí počet kusů,hodnotaje vlastnost: hodnota celého skladu,pohybyje 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)
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)
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 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
NedostatekZbozis 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"))
Na skladě je 5 kusů zboží A. Co má udělat vydej_objednavku([("A", 2), ("A", 4)])?
Dohromady je potřeba 6 kusů. Při pravidle všechno, nebo nic se nesmí změnit ani první řádek.
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:
UPDATE zasoby SET kusy = kusy - :n WHERE sku = :sku AND kusy >= :n;
-- 0 změněných řádků znamená nedostatek: ROLLBACKPř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}")
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 5: upozornění na nízký stav
Přidej do Sklad:
- atributy
_posluchaciachyby_upozorneni, oba na začátku prázdné seznamy, - metodu
odebirej(posluchac), která funkci zaregistruje, - do
vydejvolání všech posluchačů jakoposluchac(produkt, kusy), a to jen když stav právě klesl pod minimum, tedy předtím byl>= minimuma 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)
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)})))
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 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 az_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)
Sklad.ze_snimku vkládá dávky přímo do karet a pohyby přes _zapis. Proč nevolá prijem a vydej?
Snímek už obsahuje výsledný stav. Obnovení ho jen vrací na místo a nesmí znovu spouštět obchodní operace.
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)
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ásada | Kde ji vidíš |
|---|---|
| S | oceňování je v Karta, formát v do_jsonu, tisk ve vypis_prehled |
| O | nový způsob upozornění je další posluchač, Sklad se nemění |
| L | NedostatekZbozi jde chytit jako ChybaSkladu a chová se stejně |
| I | posluchač je obyčejná funkce se dvěma parametry |
| D | Sklad 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.