Type hint'lar, mypy va Pydantic

def narx(soni: int, narxi: int) -> int:
    return soni * narxi

uv add --dev mypy
uv run mypy src/

main.py:7: error: Argument 1 to "narx" has incompatible type "str"; expected "int"  [arg-type]

# O'zgaruvchilar (odatda shart emas — tip xulosa qilinadi)
max_tokens: int = 1024
model_name: str = "claude-opus-5-5"
 
# Funksiyalar — eng muhim joy
def greet(name: str, excited: bool = False) -> str:
    return f"Salom, {name}{'!' if excited else '.'}"
 
def log(msg: str) -> None:        # hech narsa qaytarmaydi
    print(msg)

scores: list[float] = [0.9, 0.85]
counts: dict[str, int] = {"a": 1}
unique: set[str] = {"x"}
point: tuple[float, float] = (1.0, 2.0)        # aniq 2 element
shape: tuple[int, ...] = (32, 3, 224, 224)     # istalgan uzunlik, hammasi int
matrix: list[list[float]] = [[1.0, 2.0]]

def find_user(user_id: int) -> User | None:      # Python 3.10+
    ...
 
def find_user(user_id: int) -> Optional[User]:   # eski yozuv, xuddi shu ma'no
    ...

def get_count(d: dict[str, int], key: str) -> int:
    v = d.get(key)          # v: int | None
    return v + 1            # ❌ mypy: Unsupported operand types for + ("None" and "int")

def get_count(d: dict[str, int], key: str) -> int:
    v = d.get(key)
    if v is None:
        return 0
    return v + 1            # ✅ bu yerda mypy v ni int deb biladi ("type narrowing")

def to_text(value: str | bytes | int) -> str:
    if isinstance(value, bytes):
        return value.decode("utf-8")
    return str(value)

from collections.abc import Iterable, Sequence, Mapping, Callable, Iterator
 
 
def total(values: Iterable[float]) -> float:        # list, tuple, set, generator — hammasi bo'ladi
    return sum(values)
 
 
def first(items: Sequence[str]) -> str:             # indeks kerak: list, tuple, str
    return items[0]
 
 
def render(params: Mapping[str, str]) -> str:       # o'qish uchun lug'atga o'xshash narsa
    return ", ".join(f"{k}={v}" for k, v in params.items())

from collections.abc import Callable
 
def apply(fn: Callable[[str], int], items: list[str]) -> list[int]:
    return [fn(x) for x in items]
 
apply(len, ["a", "bb"])        # ✅
 
Metric = Callable[[list[int], list[int]], float]   # tip taxallusi

def first[T](items: Sequence[T]) -> T | None:      # Python 3.12+ sintaksisi
    return items[0] if items else None
 
 
x = first([1, 2, 3])        # mypy: x — int | None
y = first(["a", "b"])       # mypy: y — str | None

from typing import TypeVar
 
T = TypeVar("T")
 
def first(items: Sequence[T]) -> T | None: ...

class Cache[K, V]:
    def __init__(self) -> None:
        self._data: dict[K, V] = {}
 
    def get(self, key: K) -> V | None:
        return self._data.get(key)
 
    def set(self, key: K, value: V) -> None:
        self._data[key] = value
 
 
emb_cache: Cache[str, list[float]] = Cache()

type Vector = list[float]                 # Python 3.12+
type Messages = list[dict[str, str]]
 
def cosine(a: Vector, b: Vector) -> float: ...

from typing import Literal, NotRequired, TypedDict
 
 
class Message(TypedDict):
    role: Literal["user", "assistant"]    # faqat shu ikki qiymat
    content: str
    name: NotRequired[str]                # ixtiyoriy kalit
 
 
msg: Message = {"role": "user", "content": "Salom"}          # ✅
bad: Message = {"role": "system", "content": "..."}         # ❌ mypy: "system" ruxsat etilmagan

from typing import Protocol
 
 
class SupportsComplete(Protocol):
    def complete(self, prompt: str, *, max_tokens: int = ...) -> str: ...
 
 
def summarize(llm: SupportsComplete, text: str) -> str:
    return llm.complete(f"Qisqacha xulosa:\n{text}", max_tokens=200)

from typing import Any, Final, Self, cast, override, TYPE_CHECKING
 
MAX_RETRIES: Final = 5               # qayta tayinlash — mypy xatosi
 
def load(raw: Any) -> dict: ...      # Any — "tekshirma" (qochish yo'li; kam ishlating)
 
class Builder:
    def set_model(self, m: str) -> Self:    # voris klasslarda ham to'g'ri tip
        self.model = m
        return self
 
class MyModel(BaseModel):
    @override                         # ota klassda bunday metod bo'lmasa — mypy xatosi
    def predict(self, x): ...
 
if TYPE_CHECKING:                     # faqat tekshiruv uchun import (aylanma importdan qochish)
    from .models import Classifier

# pyproject.toml
[tool.mypy]
python_version = "3.12"
strict = true                     # eng qattiq rejim — yangi loyihalar uchun tavsiya
warn_unused_ignores = true
plugins = ["pydantic.mypy"]
 
[[tool.mypy.overrides]]
module = ["some_untyped_lib.*"]
ignore_missing_imports = true

uv add pydantic

from typing import Literal
 
from pydantic import BaseModel, Field, ValidationError
 
 
class Review(BaseModel):
    text: str = Field(min_length=1)
    rating: int = Field(ge=1, le=5)                        # 1 ≤ rating ≤ 5
    sentiment: Literal["positive", "negative", "neutral"]
    tags: list[str] = []                                   # Pydantic'da bu xavfsiz — har obyektga nusxa
 
 
r = Review.model_validate({"text": "Zo'r", "rating": "5", "sentiment": "positive"})
r.rating, type(r.rating)       # (5, <class 'int'>) — "5" satri int'ga aylantirildi

try:
    Review(text="", rating=7, sentiment="good")
except ValidationError as e:
    print(e)

3 validation errors for Review
text
  String should have at least 1 character [type=string_too_short, input_value='', input_type=str]
rating
  Input should be less than or equal to 5 [type=less_than_equal, input_value=7, input_type=int]
sentiment
  Input should be 'positive', 'negative' or 'neutral' [type=literal_error, input_value='good', input_type=str]

Review.model_validate(data_dict)           # lug'atdan
Review.model_validate_json(json_string)    # JSON satrdan (tezroq — parse + validate birga)
r.model_dump()                             # → dict
r.model_dump_json()                        # → JSON satr
r.model_copy(update={"rating": 4})         # o'zgartirilgan nusxa
Review.model_json_schema()                 # → JSON Schema (LLM'ga berish uchun!)

from pydantic import BaseModel, field_validator, model_validator
 
 
class TrainingExample(BaseModel):
    prompt: str
    completion: str
    language: str = "uz"
 
    @field_validator("prompt", "completion")
    @classmethod
    def strip_and_check(cls, v: str) -> str:
        v = v.strip()
        if not v:
            raise ValueError("bo'sh bo'lmasligi kerak")
        return v                                   # o'zgartirilgan qiymat saqlanadi
 
    @model_validator(mode="after")
    def different(self) -> "TrainingExample":
        if self.prompt == self.completion:
            raise ValueError("prompt va completion bir xil")
        return self

class Strict(BaseModel):
    model_config = {"strict": True}
    n: int
 
Strict(n="5")      # ValidationError: int_type

from pydantic_settings import BaseSettings, SettingsConfigDict   # uv add pydantic-settings
 
 
class Settings(BaseSettings):
    model_config = SettingsConfigDict(env_file=".env")
 
    anthropic_api_key: str                 # majburiy — yo'q bo'lsa, ishga tushishda aniq xato
    model: str = "claude-opus-5-5"
    max_tokens: int = 1024                 # ".env"dagi "2048" satri int'ga aylanadi
    debug: bool = False                    # "1", "true", "yes" → True
 
 
settings = Settings()                      # muhit o'zgaruvchilari + .env dan o'qiydi

from typing import Literal
 
from pydantic import BaseModel, Field
 
 
class Entity(BaseModel):
    name: str
    type: Literal["person", "organization", "location"]
 
 
class Extraction(BaseModel):
    summary: str = Field(description="1-2 gaplik xulosa")
    sentiment: Literal["positive", "negative", "neutral"]
    entities: list[Entity]
 
 
schema = Extraction.model_json_schema()
# → bu sxema API'ga beriladi (23-bobda Anthropic SDK'ning structured outputs imkoniyati)
 
raw = '{"summary": "Kompaniya yangi ofis ochdi.", "sentiment": "positive", "entities": [{"name": "Toshkent", "type": "location"}]}'
result = Extraction.model_validate_json(raw)
result.entities[0].name        # 'Toshkent' — muharrir avtomatik to'ldiradi, mypy tekshiradi