OOP

from typing import ClassVar, Self
 
 
class Account:
    rate: ClassVar[float] = 0.02   # class attribute
    count = 0                      # also shared
 
    def __init__(self, owner: str, balance: float = 0):
        self.owner = owner         # instance attributes
        self.balance = balance
        Account.count += 1
 
    def deposit(self, amount: float) -> Self:
        self.balance += amount
        return self                # enables chaining
 
    def transfer(self, to: Account, amt: float) -> None:
        # 3.14: annotations are lazy, so `Account`
        # needs no quotes inside its own body
        self.balance -= amt
        to.deposit(amt)
 
 
acc = Account("zach", 50).deposit(25)

class Bad:
    tags: list[str] = []            # ONE list for all
 
a, b = Bad(), Bad()
a.tags.append("x")
b.tags                               # ['x'] (shared!)
 
class Good:
    def __init__(self) -> None:
        self.tags: list[str] = []    # one per instance

from collections.abc import Iterator
from functools import total_ordering
from math import hypot
 
 
@total_ordering
class Vec:
    __match_args__ = ("x", "y")
 
    def __init__(self, x: float, y: float) -> None:
        self.x, self.y = x, y
 
    def __repr__(self) -> str:
        return f"Vec({self.x!r}, {self.y!r})"
 
    def __eq__(self, other: object) -> bool:
        if not isinstance(other, Vec):
            return NotImplemented
        return (self.x, self.y) == (other.x, other.y)
 
    def __hash__(self) -> int:
        return hash((self.x, self.y))
 
    def __lt__(self, other: Vec) -> bool:
        return abs(self) < abs(other)
 
    def __abs__(self) -> float:
        return hypot(self.x, self.y)
 
    def __add__(self, other: Vec) -> Vec:
        return Vec(self.x + other.x, self.y + other.y)
 
    def __iter__(self) -> Iterator[float]:
        yield self.x
        yield self.y
 
 
x, y = Vec(1, 2) + Vec(2, 2)      # __add__, __iter__
sorted([Vec(3, 4), Vec(1, 0)])    # __lt__
Vec(1, 1) >= Vec(0, 1)            # from total_ordering

from functools import cached_property
from typing import Self
 
 
class Temperature:
    def __init__(self, celsius: float) -> None:
        self._c = celsius
 
    @property
    def fahrenheit(self) -> float:       # t.fahrenheit
        return self._c * 1.8 + 32
 
    @fahrenheit.setter
    def fahrenheit(self, f: float) -> None:
        self._c = (f - 32) / 1.8
 
    @cached_property
    def label(self) -> str:              # computed once
        return f"{self._c:.1f}°C"
 
    @classmethod
    def from_kelvin(cls, k: float) -> Self:
        return cls(k - 273.15)           # subclass-aware
 
    @staticmethod
    def valid(c: float) -> bool:
        return c >= -273.15

from typing import override
 
 
class Animal:
    def __init__(self, name: str) -> None:
        self.name = name
 
    def speak(self) -> str:
        return f"{self.name} makes a sound"
 
 
class Dog(Animal):
    def __init__(self, name: str, breed: str) -> None:
        super().__init__(name)        # call the parent
        self.breed = breed
 
    @override                         # checker verifies
    def speak(self) -> str:
        return f"{super().speak()}: woof"
 
 
isinstance(Dog("Rex", "lab"), Animal)  # True
issubclass(Dog, Animal)                # True

class A:
    def hi(self) -> str:
        return "A"
 
class B(A):
    def hi(self) -> str:
        return "B>" + super().hi()
 
class C(A):
    def hi(self) -> str:
        return "C>" + super().hi()
 
class D(B, C):
    def hi(self) -> str:
        return "D>" + super().hi()
 
D().hi()                          # 'D>B>C>A'
[k.__name__ for k in D.__mro__]
# ['D', 'B', 'C', 'A', 'object']

from abc import ABC, abstractmethod
from typing import Protocol, runtime_checkable
 
 
class Shape(ABC):                 # nominal: must subclass
    @abstractmethod
    def area(self) -> float: ...
 
    def describe(self) -> str:    # shared implementation
        return f"area {self.area():.2f}"
 
 
class Square(Shape):
    def __init__(self, side: float) -> None:
        self.side = side
 
    def area(self) -> float:
        return self.side**2
 
 
@runtime_checkable
class SupportsClose(Protocol):    # structural, like a
    def close(self) -> None: ...  # TS interface
 
 
class Conn:                       # no base class needed
    def close(self) -> None:
        pass
 
 
def shutdown(r: SupportsClose) -> None:
    r.close()
 
 
shutdown(Conn())                         # type-checks
isinstance(Conn(), SupportsClose)        # True

from dataclasses import (
    KW_ONLY, InitVar, asdict, dataclass, field, replace,
)
 
 
@dataclass(slots=True)
class Order:
    id: str
    items: list[str] = field(default_factory=list)
    _: KW_ONLY                        # fields below: kw-only
    net: float = 0.0
    note: str = field(default="", repr=False)
    tax: InitVar[float] = 0.2         # init-only, not stored
    gross: float = field(init=False)  # computed
 
    def __post_init__(self, tax: float) -> None:
        if self.net < 0:
            raise ValueError("net must be >= 0")
        self.gross = round(self.net * (1 + tax), 2)
 
 
o = Order("o1", ["pen"], net=10)
o  # Order(id='o1', items=['pen'], net=10, gross=12.0)
asdict(o)            # {'id': 'o1', 'items': ['pen'], ...}
replace(o, id="o2")  # new copy; reruns __post_init__

from dataclasses import dataclass, field
 
 
@dataclass(frozen=True, slots=True)
class Slug:
    raw: str
    value: str = field(init=False)
 
    def __post_init__(self) -> None:
        clean = self.raw.strip().lower().replace(" ", "-")
        # frozen: bypass __setattr__ once, in init only
        object.__setattr__(self, "value", clean)
 
 
s = Slug(" Hello World ")
s.value                    # 'hello-world'
{s}                        # hashable: usable in sets

class Point:
    __slots__ = ("x", "y")        # no per-instance __dict__
 
    def __init__(self, x: float, y: float) -> None:
        self.x, self.y = x, y
 
 
p = Point(1, 2)
# p.z = 3  -> AttributeError: no attribute 'z'

class Positive:
    def __set_name__(self, owner: type, name: str) -> None:
        self.attr = "_" + name        # 'price' -> '_price'
 
    def __get__(self, obj: object, owner: type) -> float:
        value: float = getattr(obj, self.attr)
        return value
 
    def __set__(self, obj: object, value: float) -> None:
        if value <= 0:
            raise ValueError(f"{self.attr[1:]} must be > 0")
        setattr(obj, self.attr, value)
 
 
class Product:
    price = Positive()                # reusable validation
    qty = Positive()
 
    def __init__(self, price: float, qty: int) -> None:
        self.price, self.qty = price, qty
 
 
Product(9.99, 2)
# Product(0, 1) -> ValueError: price must be > 0

from enum import Enum, Flag, StrEnum, auto
 
 
class Status(StrEnum):            # members are str
    DRAFT = auto()                # value 'draft'
    PUBLISHED = auto()
 
 
class Color(Enum):
    RED = 1
    GREEN = 2
 
    @property
    def hex(self) -> str:         # enums can have methods
        return {1: "#f00", 2: "#0f0"}[self.value]
 
 
class Perm(Flag):                 # combinable bit flags
    READ = auto()                 # 1
    WRITE = auto()                # 2
    EXEC = auto()                 # 4
 
 
rw = Perm.READ | Perm.WRITE
Perm.WRITE in rw                  # True
Status("draft") is Status.DRAFT   # by value
Color["RED"].hex                  # by name: '#f00'
[c.name for c in Color]           # ['RED', 'GREEN']
f"{Status.DRAFT}"                 # 'draft' (StrEnum)

from typing import NamedTuple, NotRequired, ReadOnly
from typing import TypedDict
 
 
class Point(NamedTuple):          # immutable tuple
    x: float
    y: float = 0.0
 
 
p = Point(1.5)
x, y = p                          # unpacks like a tuple
p._replace(y=2)                   # Point(x=1.5, y=2)
p._asdict()                       # {'x': 1.5, 'y': 0.0}
 
 
class UserDict(TypedDict):        # a plain dict at runtime
    id: ReadOnly[int]             # 3.13+
    name: str
    email: NotRequired[str]       # key may be missing
 
 
u: UserDict = {"id": 1, "name": "Ada"}
u["name"] = "Ada L."              # ok

from collections.abc import Callable
from typing import Protocol, Self
 
 
class Box[T]:                         # PEP 695 (3.12+)
    def __init__(self, value: T) -> None:
        self.value = value
 
    def map[U](self, f: Callable[[T], U]) -> Box[U]:
        return Box(f(self.value))
 
 
class HasId(Protocol):
    id: str
 
 
class Repo[T: HasId]:                 # upper bound
    def __init__(self) -> None:
        self._rows: dict[str, T] = {}
 
    def add(self, row: T) -> Self:
        self._rows[row.id] = row
        return self
 
 
class Cache[K, V = str]:              # default (3.13+)
    ...
 
 
type Pair[T] = tuple[T, T]            # generic alias
Box(2).map(str).value                 # checker: str

from dataclasses import dataclass
from decimal import Decimal
from typing import Literal
 
type Currency = Literal["EUR", "GBP", "USD"]
CENT = Decimal("0.01")
 
@dataclass(frozen=True, slots=True, order=True)
class Money:
    amount: Decimal
    currency: Currency
 
    def __post_init__(self) -> None:
        if self.amount != self.amount.quantize(CENT):
            raise ValueError("max 2 decimal places")
 
    def __add__(self, other: Money) -> Money:
        if other.currency != self.currency:
            raise TypeError("currency mismatch")
        total = self.amount + other.amount
        return Money(total, self.currency)
 
a = Money(Decimal("0.10"), "EUR")
b = Money(Decimal("0.20"), "EUR")
assert a + b == Money(Decimal("0.30"), "EUR")

from typing import override
 
class Notifier:
    def __init__(self, sender: str) -> None:
        self.sender = sender
 
    def format(self, msg: str) -> str:
        return f"[{self.sender}] {msg}"
 
    def send(self, msg: str) -> str:
        return self.format(msg)
 
class SlackNotifier(Notifier):
    def __init__(self, sender: str, channel: str) -> None:
        super().__init__(sender)
        self.channel = channel
 
    @override
    def format(self, msg: str) -> str:
        return f"#{self.channel} {super().format(msg)}"
 
SlackNotifier("ci", "deploys").send("green")
# '#deploys [ci] green'

from typing import Protocol
 
class Storage(Protocol):
    def get(self, key: str) -> bytes | None: ...
    def put(self, key: str, data: bytes) -> None: ...
 
class MemoryStorage:                  # no inheritance
    def __init__(self) -> None:
        self._d: dict[str, bytes] = {}
 
    def get(self, key: str) -> bytes | None:
        return self._d.get(key)
 
    def put(self, key: str, data: bytes) -> None:
        self._d[key] = data
 
def cache_page(s: Storage, url: str, html: str) -> None:
    s.put(url, html.encode())
 
cache_page(MemoryStorage(), "/", "<h1>hi</h1>")

import time
from types import TracebackType
from typing import Self
 
class Timer:
    def __enter__(self) -> Self:
        self.start = time.perf_counter()
        return self
 
    def __exit__(
        self,
        exc_type: type[BaseException] | None,
        exc: BaseException | None,
        tb: TracebackType | None,
    ) -> None:                        # None: don't swallow
        self.elapsed = time.perf_counter() - self.start
 
with Timer() as t:
    sum(range(1_000_000))
print(f"{t.elapsed * 1000:.1f} ms")

class AppError(Exception):
    status = 500
 
    def __init__(self, message: str, *, code: str) -> None:
        super().__init__(message)
        self.code = code
 
class NotFound(AppError):
    status = 404
 
class Conflict(AppError):
    status = 409
 
def to_status(err: Exception) -> int:
    return err.status if isinstance(err, AppError) else 500
 
try:
    raise NotFound("user 7 not found", code="USER_404")
except AppError as e:
    status = to_status(e)             # 404

from typing import ClassVar
 
class Exporter:
    registry: ClassVar[dict[str, type[Exporter]]] = {}
    ext: ClassVar[str]
 
    def __init_subclass__(
        cls, *, ext: str, **kw: object
    ) -> None:
        super().__init_subclass__(**kw)
        cls.ext = ext
        Exporter.registry[ext] = cls
 
    def export(self, rows: list[dict[str, str]]) -> str:
        raise NotImplementedError
 
class CsvExporter(Exporter, ext="csv"):
    def export(self, rows: list[dict[str, str]]) -> str:
        return "\n".join(",".join(r.values()) for r in rows)
 
Exporter.registry["csv"]().export([{"a": "1"}])  # '1'