OOP chuqurroq: dunder metodlar, dataclass, ABC, Protocol va Enum

class Point:
    def __init__(self, x, y):
        self.x, self.y = x, y
 
p = Point(1, 2)
print(p)       # <__main__.Point object at 0x104a8f2d0> — foydasiz

class Point:
    def __init__(self, x, y):
        self.x, self.y = x, y
 
    def __repr__(self) -> str:                 # dasturchi uchun: aniq, iloji bo'lsa — qayta yaratish kodi
        return f"Point(x={self.x!r}, y={self.y!r})"
 
    def __str__(self) -> str:                  # foydalanuvchi uchun: chiroyli
        return f"({self.x}, {self.y})"
 
p = Point(1, 2)
repr(p)        # 'Point(x=1, y=2)'
str(p)         # '(1, 2)'
f"{p}"         # '(1, 2)'
f"{p!r}"       # 'Point(x=1, y=2)'

class Point:
    ...
    def __eq__(self, other: object) -> bool:
        if not isinstance(other, Point):
            return NotImplemented          # "bilmayman" — Python boshqa tomonni sinab ko'radi
        return (self.x, self.y) == (other.x, other.y)
 
    def __hash__(self) -> int:
        return hash((self.x, self.y))

import math
 
 
class Vector:
    def __init__(self, *values: float) -> None:
        self.values = tuple(float(v) for v in values)
 
    def __repr__(self) -> str:
        return f"Vector{self.values}"
 
    def __len__(self) -> int:
        return len(self.values)
 
    def __getitem__(self, i):
        return self.values[i]
 
    def __iter__(self):
        return iter(self.values)
 
    def __eq__(self, other: object) -> bool:
        if not isinstance(other, Vector):
            return NotImplemented
        return self.values == other.values
 
    def __hash__(self) -> int:
        return hash(self.values)
 
    def __add__(self, other: "Vector") -> "Vector":
        if not isinstance(other, Vector):
            return NotImplemented
        return Vector(*(a + b for a, b in zip(self, other, strict=True)))
 
    def __mul__(self, k: float) -> "Vector":        # v * 2
        if not isinstance(k, (int, float)):
            return NotImplemented
        return Vector(*(a * k for a in self))
 
    __rmul__ = __mul__                               # 2 * v
 
    def __matmul__(self, other: "Vector") -> float:  # v @ w — skalyar ko'paytma
        return sum(a * b for a, b in zip(self, other, strict=True))
 
    def __abs__(self) -> float:                      # abs(v) — uzunlik
        return math.sqrt(self @ self)
 
    def __bool__(self) -> bool:                      # nol vektor — False
        return any(self.values)
 
 
v = Vector(1, 2)
w = Vector(3, 4)
v + w          # Vector(4.0, 6.0)
2 * v          # Vector(2.0, 4.0) — __rmul__
v @ w          # 11.0
abs(w)         # 5.0
v[0], len(v)   # (1.0, 2)
list(v)        # [1.0, 2.0]
v == Vector(1, 2)          # True
bool(Vector(0, 0))         # False
{v: "embedding"}           # hash bor — kalit bo'la oladi

import json
from pathlib import Path
 
 
class JsonlDataset:
    """PyTorch Dataset uslubidagi klass: len() va [i] qo'llab-quvvatlanadi."""
 
    def __init__(self, path: Path, transform=None) -> None:
        with open(path, encoding="utf-8") as f:
            self.records = [json.loads(line) for line in f if line.strip()]
        self.transform = transform
 
    def __len__(self) -> int:
        return len(self.records)
 
    def __getitem__(self, idx: int) -> dict:
        record = self.records[idx]
        return self.transform(record) if self.transform else record
 
 
ds = JsonlDataset(Path("train.jsonl"), transform=lambda r: {**r, "text": r["text"].lower()})
len(ds)           # yozuvlar soni
ds[0]             # birinchi yozuv (transform qo'llangan)
for rec in ds:    # __iter__ yo'q, lekin __getitem__ + IndexError orqali aylanish ishlaydi
    ...

class Tokenizer:
    def __init__(self, vocab: dict[str, int]) -> None:
        self.vocab = vocab
        self.unk = vocab.get("<unk>", 0)
 
    def __call__(self, text: str) -> list[int]:
        return [self.vocab.get(w, self.unk) for w in text.lower().split()]
 
 
tok = Tokenizer({"<unk>": 0, "salom": 1, "dunyo": 2})
tok("Salom dunyo!")        # [1, 0] — "dunyo!" lug'atda yo'q

from dataclasses import dataclass, field, asdict, replace
 
 
@dataclass
class TrainConfig:
    model: str = "small"
    lr: float = 3e-4
    epochs: int = 10
    batch_size: int = 32
    tags: list[str] = field(default_factory=list)    # mutable default — faqat shunday!
 
 
cfg = TrainConfig(lr=1e-3)
cfg                       # TrainConfig(model='small', lr=0.001, epochs=10, batch_size=32, tags=[])
cfg == TrainConfig(lr=1e-3)   # True — __eq__ maydonlar bo'yicha
asdict(cfg)               # {'model': 'small', 'lr': 0.001, ...} — JSON'ga saqlash uchun
replace(cfg, epochs=5)    # yangi obyekt, bitta maydon o'zgargan

@dataclass(frozen=True, slots=True)
class Point:
    x: float
    y: float
 
p = Point(1, 2)
p.x = 5                 # FrozenInstanceError — o'zgarmas
{p: "markaz"}           # frozen → avtomatik __hash__ → kalit bo'la oladi

@dataclass
class Rect:
    w: float
    h: float
    area: float = field(init=False)      # __init__ da berilmaydi
 
    def __post_init__(self) -> None:
        if self.w <= 0 or self.h <= 0:
            raise ValueError(f"O'lchamlar musbat bo'lishi kerak: {self.w}x{self.h}")
        self.area = self.w * self.h
 
 
Rect(2, 3)        # Rect(w=2, h=3, area=6)

from abc import ABC, abstractmethod
 
 
class Embedder(ABC):
    @abstractmethod
    def embed(self, texts: list[str]) -> list[list[float]]:
        """Matnlarni vektorlarga aylantiradi."""
 
    def embed_one(self, text: str) -> list[float]:        # oddiy metod — meros qilinadi
        return self.embed([text])[0]
 
 
class HashEmbedder(Embedder):
    """Test uchun oddiy embedder: so'zlar hashidan vektor."""
 
    def __init__(self, dim: int = 8) -> None:
        self.dim = dim
 
    def embed(self, texts: list[str]) -> list[list[float]]:
        out = []
        for t in texts:
            v = [0.0] * self.dim
            for w in t.lower().split():
                v[hash(w) % self.dim] += 1.0
            out.append(v)
        return out
 
 
Embedder()                      # TypeError: Can't instantiate abstract class Embedder ...
HashEmbedder().embed_one("salom dunyo")

from typing import Protocol
 
 
class SupportsEmbed(Protocol):
    def embed(self, texts: list[str]) -> list[list[float]]: ...
 
 
class OpenSourceEmbedder:                 # hech narsadan meros olmagan!
    def embed(self, texts: list[str]) -> list[list[float]]:
        return [[0.0] * 4 for _ in texts]
 
 
def build_index(embedder: SupportsEmbed, docs: list[str]) -> list[list[float]]:
    return embedder.embed(docs)
 
 
build_index(OpenSourceEmbedder(), ["a", "b"])   # ✅ mypy qabul qiladi — kerakli metod bor

from enum import Enum, StrEnum, auto
 
 
class Split(Enum):
    TRAIN = "train"
    VAL = "val"
    TEST = "test"
 
 
class Role(StrEnum):           # Python 3.11+ — qiymatlar satr sifatida ham ishlaydi
    USER = auto()              # "user"
    ASSISTANT = auto()         # "assistant"
 
 
Split.TRAIN.value              # 'train'
Split("val")                   # Split.VAL — qiymatdan
Split["TEST"]                  # Split.TEST — nomdan
list(Split)                    # hamma a'zolar
Split.TRAIN == "train"         # False — oddiy Enum satrga teng emas
 
Role.USER == "user"            # True — StrEnum
{"role": Role.USER}            # JSON'ga "user" bo'lib yoziladi

class PointSlots:
    __slots__ = ("x", "y")
    def __init__(self, x, y):
        self.x, self.y = x, y
 
p = PointSlots(1, 2)
p.z = 3            # AttributeError — yangi atribut qo'shib bo'lmaydi

from dataclasses import dataclass
from enum import StrEnum
from typing import Protocol
 
 
class Provider(StrEnum):
    ANTHROPIC = "anthropic"
    LOCAL = "local"
 
 
@dataclass(frozen=True, slots=True)
class ModelSpec:
    name: str
    provider: Provider
    context_window: int
    input_price: float        # $ / 1M token
    output_price: float
 
    def cost(self, input_tokens: int, output_tokens: int) -> float:
        return (input_tokens * self.input_price + output_tokens * self.output_price) / 1_000_000
 
 
class ChatModel(Protocol):
    spec: ModelSpec
 
    def complete(self, prompt: str) -> str: ...
 
 
class EchoModel:
    """Test uchun: javob sifatida promptni qaytaradi."""
 
    def __init__(self) -> None:
        self.spec = ModelSpec("echo", Provider.LOCAL, 1_000, 0.0, 0.0)
 
    def complete(self, prompt: str) -> str:
        return prompt[::-1]
 
 
class Registry:
    def __init__(self) -> None:
        self._models: dict[str, ChatModel] = {}
 
    def register(self, model: ChatModel) -> None:
        if model.spec.name in self._models:
            raise ValueError(f"{model.spec.name!r} allaqachon ro'yxatda")
        self._models[model.spec.name] = model
 
    def __getitem__(self, name: str) -> ChatModel:
        try:
            return self._models[name]
        except KeyError:
            raise KeyError(f"{name!r} topilmadi. Mavjudlar: {sorted(self._models)}") from None
 
    def __contains__(self, name: str) -> bool:
        return name in self._models
 
    def __len__(self) -> int:
        return len(self._models)
 
    def __repr__(self) -> str:
        return f"Registry({sorted(self._models)})"
 
 
reg = Registry()
reg.register(EchoModel())
print(reg, len(reg), "echo" in reg)       # Registry(['echo']) 1 True
print(reg["echo"].complete("salom"))      # molas
print(ModelSpec("opus", Provider.ANTHROPIC, 1_000_000, 4.0, 20.0).cost(10_000, 1_000))   # 0.06