Testlash, debugging va kod sifati

uv add --dev pytest

myproject/
├── textutils.py
├── classify.py
└── tests/
    ├── conftest.py          # umumiy fixture'lar
    ├── test_textutils.py
    └── test_classify.py

# textutils.py
import json
import re
from pathlib import Path
 
_APOSTROPHES = str.maketrans({"ʻ": "'", "‘": "'", "’": "'", "`": "'", "ʼ": "'"})
 
 
def clean_text(text: str) -> str:
    text = text.translate(_APOSTROPHES)
    return re.sub(r"\s+", " ", text).strip()
 
 
def chunk_text(text: str, size: int, overlap: int = 0) -> list[str]:
    if size <= 0:
        raise ValueError("size musbat bo'lishi kerak")
    if not 0 <= overlap < size:
        raise ValueError("overlap 0 va size orasida bo'lishi kerak")
    if not text:
        return []
    step = size - overlap
    return [text[i:i + size] for i in range(0, max(len(text) - overlap, 1), step)]
 
 
def save_jsonl(path: Path, records: list[dict]) -> int:
    with open(path, "w", encoding="utf-8") as f:
        for r in records:
            f.write(json.dumps(r, ensure_ascii=False) + "\n")
    return len(records)

# tests/test_textutils.py
from textutils import clean_text
 
 
def test_clean_text_normalizes_apostrophes():
    assert clean_text("Oʻzbekiston") == "O'zbekiston"
 
 
def test_clean_text_collapses_whitespace():
    assert clean_text("  a \n\t b  ") == "a b"

    def test_clean_text_collapses_whitespace():
>       assert clean_text("  a \n\t b  ") == "a  b"
E       AssertionError: assert 'a b' == 'a  b'
E         - a  b
E         ?  -
E         + a b

def test_save_jsonl_roundtrip(tmp_path):
    # Arrange — tayyorlash
    path = tmp_path / "out.jsonl"
    records = [{"text": "salom"}, {"text": "dunyo"}]
 
    # Act — bitta amal
    n = save_jsonl(path, records)
 
    # Assert — natijani tekshirish
    assert n == 2
    lines = path.read_text(encoding="utf-8").splitlines()
    assert [json.loads(line) for line in lines] == records

import pytest
 
 
def test_chunk_text_rejects_zero_size():
    with pytest.raises(ValueError, match="musbat"):
        chunk_text("abc", size=0)

assert 0.1 + 0.2 == pytest.approx(0.3)
assert compute_metrics(...)["f1"] == pytest.approx(0.8571, abs=1e-4)

@pytest.mark.parametrize(
    ("text", "size", "overlap", "expected"),
    [
        ("abcdefghij", 4, 0, ["abcd", "efgh", "ij"]),
        ("abcdefghij", 4, 1, ["abcd", "defg", "ghij"]),
        ("abc", 10, 0, ["abc"]),
        ("", 4, 0, []),
    ],
)
def test_chunk_text(text, size, overlap, expected):
    assert chunk_text(text, size, overlap) == expected
 
 
@pytest.mark.parametrize(("size", "overlap"), [(0, 0), (4, 4), (4, -1)])
def test_chunk_text_rejects_bad_params(size, overlap):
    with pytest.raises(ValueError, match="bo'lishi kerak"):
        chunk_text("abc", size, overlap)

# tests/conftest.py — bu fayldagi fixture'lar hamma testlarga ko'rinadi
import pytest
 
 
@pytest.fixture
def sample_records():
    return [
        {"text": "Zo'r mahsulot", "label": "positive"},
        {"text": "Yomon xizmat", "label": "negative"},
    ]
 
 
@pytest.fixture
def jsonl_file(tmp_path, sample_records):          # fixture boshqa fixture'larni ishlatishi mumkin
    path = tmp_path / "data.jsonl"
    save_jsonl(path, sample_records)
    return path

def test_read_back(jsonl_file, sample_records):
    assert read_jsonl(jsonl_file) == sample_records

@pytest.fixture
def db():
    conn = connect(":memory:")
    yield conn              # ← test shu yerda ishlaydi
    conn.close()            # test tugagach (xato bo'lsa ham) — tozalash

def test_reads_api_key_from_env(monkeypatch):
    monkeypatch.setenv("ANTHROPIC_API_KEY", "test-key")
    monkeypatch.delenv("DEBUG", raising=False)
    settings = load_settings()
    assert settings.api_key == "test-key"
# test tugagach muhit avvalgi holatiga qaytadi
 
 
def test_warns_on_bad_row(caplog):
    process_lines(['{"text": "ok"}', "buzilgan"])
    assert "o'tkazib yuborildi" in caplog.text

# classify.py
from typing import Protocol
 
 
class LLM(Protocol):
    def complete(self, prompt: str) -> str: ...
 
 
LABELS = {"positive", "negative", "neutral"}
 
 
def classify(llm: LLM, text: str) -> str:
    answer = llm.complete(f"Sentiment (positive/negative/neutral): {text}").strip().lower()
    return answer if answer in LABELS else "neutral"

# tests/conftest.py
import pytest
 
 
class FakeLLM:
    def __init__(self, reply: str) -> None:
        self.reply = reply
        self.prompts: list[str] = []          # nima yuborilganini ham tekshirish uchun
 
    def complete(self, prompt: str) -> str:
        self.prompts.append(prompt)
        return self.reply
 
 
@pytest.fixture
def fake_llm():
    return FakeLLM              # fabrika: testning o'zi javobni tanlaydi

# tests/test_classify.py
import pytest
 
from classify import classify
 
 
@pytest.mark.parametrize(("reply", "expected"), [
    ("positive", "positive"),
    ("  NEGATIVE\n", "negative"),            # bo'sh joy va katta harf
    ("Menimcha bu ijobiy", "neutral"),       # model formatga rioya qilmadi
])
def test_classify_parses_reply(fake_llm, reply, expected):
    assert classify(fake_llm(reply), "Zo'r mahsulot") == expected
 
 
def test_classify_sends_text_in_prompt(fake_llm):
    llm = fake_llm("positive")
    classify(llm, "Zo'r mahsulot")
    assert "Zo'r mahsulot" in llm.prompts[0]

# weather.py
import httpx
 
 
def get_temperature(city: str) -> float:
    resp = httpx.get("https://api.example.com/weather", params={"city": city}, timeout=10)
    resp.raise_for_status()
    return resp.json()["temp_c"]

# tests/test_weather.py
from unittest.mock import Mock, patch
 
import weather
 
 
def test_get_temperature_parses_response():
    fake_resp = Mock()
    fake_resp.json.return_value = {"temp_c": 18.5}
 
    with patch("weather.httpx.get", return_value=fake_resp) as fake_get:
        assert weather.get_temperature("Toshkent") == 18.5
 
    fake_get.assert_called_once()
    assert fake_get.call_args.kwargs["params"] == {"city": "Toshkent"}

@pytest.mark.eval        # pyproject.toml'da ro'yxatdan o'tkaziladi
def test_sentiment_accuracy(real_llm, golden_set):
    correct = sum(classify(real_llm, ex["text"]) == ex["label"] for ex in golden_set)
    assert correct / len(golden_set) >= 0.85

uv add --dev pytest-cov
uv run pytest --cov=src --cov-report=term-missing

Name                 Stmts   Miss  Cover   Missing
--------------------------------------------------
src/textutils.py        18      2    89%   21-22
src/classify.py          7      0   100%

def compute_loss(preds, labels):
    diffs = [p - l for p, l in zip(preds, labels)]
    breakpoint()            # dastur shu yerda to'xtaydi va interaktiv debugger ochiladi
    return sum(d * d for d in diffs) / len(diffs)

uv add --dev ruff
uv run ruff check .            # muammolarni topish
uv run ruff check . --fix      # avtomatik tuzatiladiganlarini tuzatish
uv run ruff format .           # formatlash (black uslubida)

# pyproject.toml
[tool.ruff]
line-length = 100
target-version = "py312"
 
[tool.ruff.lint]
select = [
    "E", "F",      # pycodestyle, pyflakes — asosiy xatolar (ishlatilmagan import, noma'lum nom)
    "I",           # importlarni tartiblash
    "B",           # bugbear — mutable default, except: pass va boshqa tuzoqlar
    "UP",          # pyupgrade — eskirgan sintaksisni yangilash
    "SIM",         # soddalashtirish takliflari
    "RUF",         # ruff'ning o'z qoidalari
]

uv add --dev pre-commit

# .pre-commit-config.yaml
repos:
  - repo: https://github.com/astral-sh/ruff-pre-commit
    rev: v0.8.0
    hooks:
      - id: ruff
        args: [--fix]
      - id: ruff-format
  - repo: https://github.com/pre-commit/pre-commit-hooks
    rev: v5.0.0
    hooks:
      - id: check-added-large-files     # tasodifan 2 GB datasetni commit qilishdan himoya
      - id: detect-private-key
      - id: end-of-file-fixer

uv run pre-commit install       # bir marta — endi har `git commit` dan oldin ishlaydi