Xatolar: istisno dizayni

.venv/bin/python3 -m hisobot yoq_fayl.csv

# 1. Yalang'och except — hamma narsani yutadi
def yomon_1(x):
    try:
        return int(x)
    except:                      # Ctrl+C va SystemExit ni ham ushlaydi!
        return 0

# 2. Xatoni jim yutish
def yomon_2(yol):
    try:
        with open(yol) as f:
            return f.read()
    except Exception:
        return None              # nima bo'ldi? hech kim bilmaydi

# 3. Xato o'rniga sehrli qiymat
def yomon_3(x):
    try:
        return int(x)
    except ValueError:
        return -1                # -1 haqiqiy natijami yoki xatomi?

print("yomon_1('abc') =", yomon_1("abc"), "  <- xato 0 ga aylandi")
print("yomon_2('yoq') =", yomon_2("yoq"), "  <- fayl yo'qmi yoki bo'shmi?")
print("yomon_3('abc') =", yomon_3("abc"), " <- -5 baho ham -1 emas, lekin...")
print("yomon_3('-1')  =", yomon_3("-1"), " <- bu haqiqiy qiymat, farqi yo'q!")

"""Loyihaning istisno oilasi.

Hammasi HisobotXato dan meros oladi — foydalanuvchi bitta except bilan ushlay oladi.
"""


class HisobotXato(Exception):
    """Barcha hisobot xatolarining ildizi."""


class FaylXato(HisobotXato):
    """Fayl o'qib bo'lmadi."""

    def __init__(self, yol: str, sabab: str) -> None:
        self.yol = yol
        self.sabab = sabab
        super().__init__(f"faylni o'qib bo'lmadi: {yol} ({sabab})")


class QatorXato(HisobotXato):
    """Bitta qator qoidaga mos emas."""

    def __init__(self, qator: int, maydon: str, sabab: str) -> None:
        self.qator = qator
        self.maydon = maydon
        self.sabab = sabab
        super().__init__(f"{qator}-qator, '{maydon}' maydoni: {sabab}")


class SozlamaXato(HisobotXato):
    """Konfiguratsiya noto'g'ri (11-bob)."""

"""CSV o'qish va qatorlarni tekshirib modelga aylantirish."""
import csv
from pathlib import Path

from .modellar import Natija, Talaba
from .tekshiruv import bahoni_tekshir, sanani_tekshir
from .xatolar import FaylXato, QatorXato

KERAKLI_USTUNLAR = {"ism", "guruh", "baho", "sana"}


def oqi(yol: str | Path) -> list[dict[str, str]]:
    """CSV ni o'qiydi. Har qanday muammoda FaylXato qaytaradi."""
    p = Path(yol)
    try:
        matn = p.read_text(encoding="utf-8")
    except FileNotFoundError:
        raise FaylXato(str(p), "fayl topilmadi") from None
    except PermissionError:
        raise FaylXato(str(p), "o'qishga ruxsat yo'q") from None
    except UnicodeDecodeError as e:
        raise FaylXato(str(p), f"matn UTF-8 emas ({e.reason})") from None

    qatorlar = list(csv.DictReader(matn.splitlines()))
    if not qatorlar:
        raise FaylXato(str(p), "fayl bo'sh yoki faqat sarlavha bor")
    yetishmayotgan = KERAKLI_USTUNLAR - set(qatorlar[0])
    if yetishmayotgan:
        raise FaylXato(str(p), f"ustunlar yetishmaydi: {sorted(yetishmayotgan)}")
    return qatorlar


def tozala(qatorlar: list[dict[str, str]]) -> Natija:
    """Xom lug'atlarni Talaba obyektlariga aylantiradi. Xatolar to'planadi, otilmaydi."""
    natija = Natija()
    for i, q in enumerate(qatorlar, start=2):
        try:
            baho = bahoni_tekshir(q.get("baho"))
        except ValueError as e:
            natija.xatolar.append((i, q.get("ism", "?"), str(e)))
            continue
        try:
            sana = sanani_tekshir(q.get("sana"))
        except ValueError as e:
            natija.xatolar.append((i, q.get("ism", "?"), str(e)))
            continue
        natija.talabalar.append(Talaba(
            ism=q.get("ism", "").strip(),
            guruh=q.get("guruh", "").strip(),
            baho=baho,
            sana=sana,
        ))
    return natija

.venv/bin/python3 -c "
from hisobot.oqish import oqi
from hisobot.xatolar import FaylXato, HisobotXato

for yol in ['yoq_fayl.csv', 'sinov_malumot.csv']:
    try:
        q = oqi(yol)
        print(f'{yol}: {len(q)} qator o\\'qildi')
    except FaylXato as e:
        print(f'{yol}: XATO -> {e}')
        print(f'   ma\\'lumot: yol={e.yol!r}, sabab={e.sabab!r}')
"

ism,guruh,ball
Aziz,A,85

ism,guruh,baho,sana

.venv/bin/python3 -c "
from hisobot.oqish import oqi
from hisobot.xatolar import FaylXato

for yol in ['buzuq_ustun.csv', 'bosh.csv']:
    try:
        oqi(yol)
    except FaylXato as e:
        print(f'{yol:18} -> {e.sabab}')
"

.venv/bin/python3 -m pytest tests/test_oqish.py -q

import pytest

from hisobot.oqish import oqi, tozala
from hisobot.xatolar import FaylXato


def test_oqi_qatorlar_soni(csv_fayl):
    qatorlar = oqi(csv_fayl)
    assert len(qatorlar) == 3
    assert qatorlar[0]["ism"] == "Aziz"


def test_tozala_xatoni_ajratadi(csv_fayl):
    n = tozala(oqi(csv_fayl))
    assert len(n.talabalar) == 2
    assert len(n.xatolar) == 1
    assert n.jami == 3


def test_xato_qator_raqami(csv_fayl):
    n = tozala(oqi(csv_fayl))
    qator, ism, sabab = n.xatolar[0]
    assert qator == 4                      # sarlavha 1-qator, ma'lumot 2 dan boshlanadi
    assert ism == "Xato"
    assert "son emas" in sabab


def test_fayl_yoq(tmp_path):
    """Endi FaylXato kutamiz — FileNotFoundError emas."""
    with pytest.raises(FaylXato, match="topilmadi"):
        oqi(tmp_path / "yoq.csv")

.venv/bin/python3 -m pytest tests/test_oqish.py -q

def xom():
    return int("abc")

print("1) from None — ichki xato YASHIRILADI:")
try:
    try:
        xom()
    except ValueError:
        raise RuntimeError("tashqi xato") from None
except RuntimeError as e:
    print("   __cause__:", e.__cause__, "| __context__:", type(e.__context__).__name__ if e.__context__ else None)

print("2) from e — sabab SAQLANADI:")
try:
    try:
        xom()
    except ValueError as e:
        raise RuntimeError("tashqi xato") from e
except RuntimeError as e:
    print("   __cause__:", type(e.__cause__).__name__, "-", e.__cause__)

import pandas as pd
show(pd.DataFrame([
    {"tur": "Davom etib bo'lmaydi", "misol": "fayl yo'q, ustun yetishmaydi",
     "nima qilish": "Darhol `raise` — ish ma'nosiz"},
    {"tur": "Qisman muvaffaqiyat", "misol": "1000 qatordan 3 tasi buzuq",
     "nima qilish": "To'plang, davom eting, oxirida hisobot bering"},
]))

import pandas as pd
show(pd.DataFrame([
    {"yomon": "try ichida 20 qator kod", "nega": "Qaysi biri xato berdi — noma'lum; keraksiz xatolar ham ushlanadi"},
    {"yomon": "except Exception", "nega": "Dasturlash xatolari (NameError, TypeError) ham yutiladi"},
    {"yomon": "except (A, B, C, D, E)", "nega": "Ehtimol umumiy ota-sinf bor — o'shani ishlating"},
    {"yomon": "try/except ichida yana try/except", "nega": "Odatda funksiyaga ajratish kerak"},
]))

import tempfile, os

yol = os.path.join(tempfile.gettempdir(), "sinov_finally.txt")

def finally_bilan():
    f = open(yol, "w")
    try:
        f.write("ma'lumot")
        raise RuntimeError("xato yuz berdi")
    finally:
        f.close()
        print("   fayl yopildi:", f.closed)

def with_bilan():
    with open(yol, "w") as f:
        f.write("ma'lumot")
        raise RuntimeError("xato yuz berdi")

for nom, fn in [("finally", finally_bilan), ("with", with_bilan)]:
    print(f"{nom}:")
    try:
        fn()
    except RuntimeError as e:
        print("   xato o'tdi:", e)
os.unlink(yol)

from contextlib import contextmanager
import time

@contextmanager
def vaqtni_olch(nom):
    t0 = time.perf_counter()
    try:
        yield
    finally:
        print(f"   [{nom}] {(time.perf_counter() - t0) * 1000:.1f} ms")

with vaqtni_olch("muvaffaqiyatli ish"):
    sum(range(200_000))

try:
    with vaqtni_olch("xato bilan tugagan ish"):
        sum(range(100_000))
        raise ValueError("to'xtadi")
except ValueError:
    print("   xato ushlandi, lekin vaqt baribir o'lchandi")

"""python3 -m hisobot bilan ishga tushadi."""
import sys

from .hisob import daraja_taqsimoti, guruh_ortachasi
from .oqish import oqi, tozala
from .xatolar import HisobotXato


def main(argv: list[str] | None = None) -> int:
    argv = sys.argv[1:] if argv is None else argv
    if not argv:
        print("ishlatish: python3 -m hisobot <fayl.csv>", file=sys.stderr)
        return 2
    try:
        n = tozala(oqi(argv[0]))
    except HisobotXato as e:
        print(f"xato: {e}", file=sys.stderr)
        return 1

    print(f"jami: {n.jami}, to'g'ri: {len(n.talabalar)}, xato: {len(n.xatolar)}")
    for g, o in guruh_ortachasi(n.talabalar).items():
        print(f"  {g}: {o}")
    print("darajalar:", daraja_taqsimoti(n.talabalar))
    for qator, ism, sabab in n.xatolar:
        print(f"  {qator}-qator ({ism}): {sabab}", file=sys.stderr)
    return 0 if not n.xatolar else 1


if __name__ == "__main__":
    sys.exit(main())

.venv/bin/python3 -m hisobot yoq_fayl.csv
echo "--- qaytish kodi: $? ---"
.venv/bin/python3 -m hisobot buzuq_ustun.csv
echo "--- qaytish kodi: $? ---"
.venv/bin/python3 -m hisobot sinov_malumot.csv
echo "--- qaytish kodi: $? ---"

import pytest

from hisobot.oqish import oqi, tozala
from hisobot.xatolar import FaylXato, HisobotXato, QatorXato


def test_fayl_yoq(tmp_path):
    with pytest.raises(FaylXato, match="topilmadi"):
        oqi(tmp_path / "yoq.csv")


def test_fayl_xato_hisobot_xato_ham():
    """FaylXato — HisobotXato ning bolasi, demak umumiy except ishlaydi."""
    assert issubclass(FaylXato, HisobotXato)
    assert issubclass(QatorXato, HisobotXato)


def test_xato_malumot_saqlaydi(tmp_path):
    yol = tmp_path / "yoq.csv"
    try:
        oqi(yol)
    except FaylXato as e:
        assert e.yol == str(yol)
        assert e.sabab == "fayl topilmadi"
    else:
        pytest.fail("FaylXato kutilgandi")


def test_ustun_yetishmaydi(tmp_path):
    yol = tmp_path / "x.csv"
    yol.write_text("ism,guruh\nA,B\n", encoding="utf-8")
    with pytest.raises(FaylXato, match="ustunlar yetishmaydi"):
        oqi(yol)


def test_bosh_fayl(tmp_path):
    yol = tmp_path / "bosh.csv"
    yol.write_text("ism,guruh,baho,sana\n", encoding="utf-8")
    with pytest.raises(FaylXato, match="bo'sh"):
        oqi(yol)


def test_tozala_xato_otmaydi():
    """Buzuq qator istisno otmaydi, to'planadi."""
    n = tozala([{"ism": "A", "guruh": "X", "baho": "abc", "sana": "2026-01-01"}])
    assert n.talabalar == []
    assert len(n.xatolar) == 1

.venv/bin/python3 -m pytest -q
python3 -m mypy