Classes and OOP

from dataclasses import dataclass
@dataclass
class Item:
    id: str
    qty: int = 1
Item("a")              # Item(id='a', qty=1)
Item("a", 2) == Item("a", 2)   # True

class Temp:
    def __init__(self, c: float) -> None:
        self._c = c
    @property
    def f(self) -> float:
        return self._c * 9 / 5 + 32
Temp(0).f    # 32.0
Temp(100).f  # 212.0

@dataclass
class User:
    id: str
    name: str
    @classmethod
    def from_pair(cls, a: str, b: str) -> "User":
        return cls(id=f"{a}:{b}", name=a)
User.from_pair("Ada", "L")   # User(id='Ada:L', name='Ada')

@dataclass(slots=True)
class Point:
    x: float
    y: float
p = Point(1.0, 2.0)
p.x          # 1.0
# p.z = 3    # AttributeError

from typing import Protocol
class Closer(Protocol):
    def close(self) -> str: ...
class File:
    def close(self) -> str: return "closed"
def shutdown(x: Closer) -> str:
    return x.close()
shutdown(File())   # 'closed'

class User:
    def __init__(self, id: str, name: str) -> None:
        self.id, self.name = id, name
    def __repr__(self) -> str:
        return f"User(id={self.id!r})"
    def __str__(self) -> str:
        return self.name
u = User("1", "Ada")
repr(u)   # "User(id='1')"
str(u)    # 'Ada'

@dataclass(frozen=True)
class Key:
    tenant: str
    id: str
{Key("t", "1"): "ok"}[Key("t", "1")]   # 'ok'

class User:
    def __init__(self, id: str, name: str) -> None:
        self.id, self.name = id, name
class Admin(User):
    def __init__(self, id: str, name: str) -> None:
        super().__init__(id, name)
        self.roles = ["admin"]
Admin("1", "Ada").roles   # ['admin']

from abc import ABC, abstractmethod
class Repo(ABC):
    @abstractmethod
    def get(self, id: str) -> str: ...
class MemRepo(Repo):
    def get(self, id: str) -> str: return id
MemRepo().get("x")   # 'x'
# Repo()             # TypeError: can't instantiate abstract class

from enum import Enum
class Status(Enum):
    OPEN = "open"
    CLOSED = "closed"
Status.OPEN.value     # 'open'
Status("open")        # <Status.OPEN: 'open'>

class Tag:
    def __enter__(self):
        return "in"
    def __exit__(self, *exc):
        return False
with Tag() as t:
    t   # 'in'

from dataclasses import dataclass, field
@dataclass
class Bag:
    items: list[str] = field(default_factory=list)
a, b = Bag(), Bag()
a.items.append("x")
b.items    # []  (not shared)

class Obj: ...
obj = Obj()
setattr(obj, "name", "Ada")
getattr(obj, "name", None)    # 'Ada'
getattr(obj, "missing", 0)    # 0

class Node:
    __slots__ = ("value", "next")
    def __init__(self, value: int) -> None:
        self.value = value
        self.next = None
Node(1).value   # 1
# Node(1).extra = 2  # AttributeError

import json
class JsonMixin:
    def to_json(self) -> str:
        return json.dumps(self.__dict__)
class User(JsonMixin):
    def __init__(self, name: str) -> None:
        self.name = name
User("Ada").to_json()   # '{"name": "Ada"}'