Buyruq qatori va paketlash

"""Buyruq qatori interfeysi."""
import argparse
import logging
import sys
from pathlib import Path

from . import __version__
from .chiqarish import csv_yoz, json_yoz, xulosa
from .hisob import daraja_taqsimoti, eng_yaxshi, guruh_ortachasi
from .ko_p import hammasi
from .oqish import oqi, tozala
from .sozlama import Sozlama
from .xatolar import HisobotXato, SozlamaXato

log = logging.getLogger(__name__)


def jurnalni_sozla(batafsil: int, jim: bool) -> None:
    if jim:
        daraja = logging.ERROR
    else:
        daraja = {0: logging.WARNING, 1: logging.INFO}.get(batafsil, logging.DEBUG)
    logging.basicConfig(level=daraja, stream=sys.stderr,
                        format="%(levelname)-8s %(name)s: %(message)s")


def tahlilchi() -> argparse.ArgumentParser:
    p = argparse.ArgumentParser(
        prog="hisobot",
        description="CSV fayldan talabalar hisobotini tayyorlaydi.",
        epilog="Misol:  hisobot talabalar.csv --format json --chiqish natija.json",
    )
    p.add_argument("fayllar", nargs="+", type=Path, metavar="FAYL",
                   help="bir yoki bir nechta CSV fayl")
    p.add_argument("--format", choices=["matn", "json", "csv"], default="matn",
                   help="chiqish formati (sukut: matn)")
    p.add_argument("--chiqish", type=Path, metavar="YO'L",
                   help="natijani faylga yozish (sukut: ekranga)")
    p.add_argument("--max-baho", type=int, metavar="N",
                   help="eng katta ruxsat etilgan baho (sukut: 100)")
    p.add_argument("--qatiy", action="store_true",
                   help="bitta xato qator ham butun ishni to'xtatsin")
    p.add_argument("-j", "--ishchilar", type=int, default=4, metavar="N",
                   help="parallel ishchilar soni (sukut: 4)")
    p.add_argument("-v", "--batafsil", action="count", default=0,
                   help="-v: INFO, -vv: DEBUG")
    p.add_argument("-q", "--jim", action="store_true", help="faqat xatolarni ko'rsat")
    p.add_argument("--version", action="version", version=f"hisobot {__version__}")
    return p


def main(argv: list[str] | None = None) -> int:
    args = tahlilchi().parse_args(argv)
    jurnalni_sozla(args.batafsil, args.jim)

    try:
        sozlama = Sozlama.muhitdan()
        if args.max_baho is not None:
            sozlama = Sozlama(max_baho=args.max_baho, min_baho=sozlama.min_baho,
                              chiqish_papka=sozlama.chiqish_papka, qatiy=args.qatiy or sozlama.qatiy)
            sozlama.tekshir()
    except SozlamaXato as e:
        log.error("sozlama xatosi: %s", e)
        return 2

    natijalar = hammasi(list(args.fayllar), ishchilar=args.ishchilar)
    xatolar_bor = False
    birlashgan = None

    for nom in sorted(natijalar):
        n = natijalar[nom]
        if isinstance(n, str):
            log.error("%s: %s", nom, n)
            xatolar_bor = True
            continue
        if birlashgan is None:
            birlashgan = n
        else:
            birlashgan.talabalar.extend(n.talabalar)
            birlashgan.xatolar.extend(n.xatolar)

    if birlashgan is None:
        log.error("hech qaysi fayl o'qilmadi")
        return 1
    if birlashgan.xatolar:
        xatolar_bor = True
        if sozlama.qatiy:
            log.error("qat'iy rejim: %d xato qator topildi", len(birlashgan.xatolar))
            return 1

    if args.format == "json":
        if args.chiqish:
            json_yoz(birlashgan, args.chiqish)
        else:
            import json
            print(json.dumps(xulosa(birlashgan), ensure_ascii=False, indent=2))
    elif args.format == "csv":
        if not args.chiqish:
            log.error("--format csv uchun --chiqish kerak")
            return 2
        csv_yoz(birlashgan, args.chiqish)
    else:
        chop_et(birlashgan)

    return 1 if xatolar_bor else 0


def chop_et(natija) -> None:
    print(f"jami: {natija.jami}  to'g'ri: {len(natija.talabalar)}  xato: {len(natija.xatolar)}")
    print("\nguruh bo'yicha o'rtacha:")
    for g, o in guruh_ortachasi(natija.talabalar).items():
        print(f"  {g}: {o}")
    print("\ndarajalar:")
    for d, n in daraja_taqsimoti(natija.talabalar).items():
        print(f"  {d}: {n}")
    eng = eng_yaxshi(natija.talabalar)
    if eng is not None:
        print(f"\neng yuqori: {eng.ism} ({eng.baho}, {eng.guruh})")
    for qator, ism, sabab in natija.xatolar:
        print(f"  {qator}-qator ({ism}): {sabab}", file=sys.stderr)


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

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

from .cli import main

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

.venv/bin/python3 -m hisobot --help

echo "=== 1) oddiy ishlatish ==="
.venv/bin/python3 -m hisobot sinov_malumot.csv
echo "qaytish kodi: $?"

echo "=== 2) JSON format ==="
.venv/bin/python3 -m hisobot sinov_malumot.csv --format json --jim

echo "=== 3) bir nechta fayl ==="
.venv/bin/python3 -m hisobot ko_p_sinov/f1.csv ko_p_sinov/f2.csv ko_p_sinov/f3.csv --jim
echo "qaytish kodi: $?"
echo ""
echo "=== 4) --max-baho bilan (5 balli tizim) ==="
.venv/bin/python3 -m hisobot sinov_malumot.csv --max-baho 5 --jim 2>&1 | head -12
echo "qaytish kodi: ${PIPESTATUS[0]}"

echo "=== 5) noto'g'ri argument ==="
.venv/bin/python3 -m hisobot sinov_malumot.csv --format xml
echo "qaytish kodi: $?"
echo ""
echo "=== 6) versiya ==="
.venv/bin/python3 -m hisobot --version

import pandas as pd
show(pd.DataFrame([
    {"kod": 0, "ma'nosi": "Muvaffaqiyat", "bizda": "hamma qator to'g'ri"},
    {"kod": 1, "ma'nosi": "Umumiy xato", "bizda": "xato qatorlar bor yoki fayl o'qilmadi"},
    {"kod": 2, "ma'nosi": "Noto'g'ri ishlatish", "bizda": "yomon argument yoki sozlama"},
    {"kod": 130, "ma'nosi": "Ctrl+C bilan to'xtatilgan", "bizda": "Python o'zi qaytaradi"},
]))

if .venv/bin/python3 -m hisobot ko_p_sinov/f1.csv --jim > /dev/null 2>&1; then
  echo "f1.csv: toza o'tdi -> keyingi qadamga o'tish mumkin"
else
  echo "f1.csv: muammo bor -> to'xtaymiz"
fi

if .venv/bin/python3 -m hisobot sinov_malumot.csv --jim > /dev/null 2>&1; then
  echo "sinov_malumot.csv: toza o'tdi"
else
  echo "sinov_malumot.csv: muammo bor (xato qatorlar) -> tekshirish kerak"
fi

echo "=== natija faylga, xatolar ekranga ==="
.venv/bin/python3 -m hisobot sinov_malumot.csv --format json > natija2.json
echo "--- fayl ichida faqat JSON bor: ---"
head -5 natija2.json
.venv/bin/python3 -c "import json; json.load(open('natija2.json')); print('JSON to\'g\'ri tahlil qilindi')"
rm natija2.json

[project]
name = "hisobot"
version = "1.0.0"
description = "CSV ma'lumotini tekshirib hisobot chiqaradigan asbob"
readme = "README.md"
requires-python = ">=3.10"
license = {text = "MIT"}
authors = [{name = "Kurs talabasi"}]
keywords = ["csv", "hisobot", "tahlil"]
classifiers = [
    "Programming Language :: Python :: 3",
    "License :: OSI Approved :: MIT License",
    "Operating System :: OS Independent",
]
dependencies = []

[project.optional-dependencies]
dev = [
    "pytest>=8",
    "pytest-cov>=5",
    "mypy>=1.8",
    "ruff>=0.5",
]

[project.scripts]
hisobot = "hisobot.cli:main"

[project.urls]
Homepage = "https://example.uz/hisobot"

[build-system]
requires = ["setuptools>=68"]
build-backend = "setuptools.build_meta"

[tool.pytest.ini_options]
testpaths = ["tests"]
addopts = "-q --strict-markers"

[tool.coverage.run]
source = ["hisobot"]

[tool.coverage.report]
show_missing = true
exclude_lines = [
    "pragma: no cover",
    "if __name__ == .__main__.:",
    "raise NotImplementedError",
]

# hisobot

CSV fayldan talabalar hisobotini tayyorlaydigan buyruq qatori asbobi.

## O'rnatish

## Ishlatish

## Sozlash

Muhit o'zgaruvchilari: `HISOBOT_MAX_BAHO`, `HISOBOT_MIN_BAHO`, `HISOBOT_QATIY`.

.venv/bin/python3 -m pip install --quiet -e .
ls .venv/bin/ | grep hisobot
.venv/bin/hisobot --version
.venv/bin/hisobot sinov_malumot.csv --jim

import json

import pytest

from hisobot.cli import main

TOGRI = "ism,guruh,baho,sana\nAziz,A,85,2026-09-01\nBobur,B,95,2026-09-02\n"
XATOLI = "ism,guruh,baho,sana\nAziz,A,abc,2026-09-01\n"


def _fayl(papka, nom, matn):
    y = papka / nom
    y.write_text(matn, encoding="utf-8")
    return str(y)


def test_toza_fayl_nol_qaytaradi(tmp_path, capsys):
    kod = main([_fayl(tmp_path, "a.csv", TOGRI), "--jim"])
    assert kod == 0
    assert "to'g'ri: 2" in capsys.readouterr().out


def test_xatoli_fayl_bir_qaytaradi(tmp_path):
    assert main([_fayl(tmp_path, "b.csv", XATOLI), "--jim"]) == 1


def test_fayl_yoq_bir_qaytaradi(tmp_path):
    assert main([str(tmp_path / "yoq.csv"), "--jim"]) == 1


def test_json_format(tmp_path, capsys):
    main([_fayl(tmp_path, "c.csv", TOGRI), "--format", "json", "--jim"])
    malumot = json.loads(capsys.readouterr().out)
    assert malumot["togri"] == 2
    assert malumot["guruh_ortachasi"] == {"A": 85.0, "B": 95.0}


def test_json_faylga(tmp_path):
    chiqish = tmp_path / "n.json"
    main([_fayl(tmp_path, "d.csv", TOGRI), "--format", "json", "--chiqish", str(chiqish), "--jim"])
    assert json.loads(chiqish.read_text(encoding="utf-8"))["togri"] == 2


def test_csv_chiqishsiz_ikki_qaytaradi(tmp_path):
    assert main([_fayl(tmp_path, "e.csv", TOGRI), "--format", "csv", "--jim"]) == 2


def test_max_baho_cheklovi(tmp_path):
    """85 va 95 — 5 balli tizimda ikkalasi ham xato."""
    assert main([_fayl(tmp_path, "f.csv", TOGRI), "--max-baho", "5", "--jim"]) == 1


def test_notogri_max_baho(tmp_path):
    assert main([_fayl(tmp_path, "g.csv", TOGRI), "--max-baho", "-5", "--jim"]) == 2


def test_bir_nechta_fayl(tmp_path, capsys):
    kod = main([_fayl(tmp_path, "h1.csv", TOGRI), _fayl(tmp_path, "h2.csv", TOGRI), "--jim"])
    assert kod == 0
    assert "jami: 4" in capsys.readouterr().out


def test_notogri_argument_sistemexit(tmp_path):
    with pytest.raises(SystemExit) as e:
        main([_fayl(tmp_path, "i.csv", TOGRI), "--format", "xml"])
    assert e.value.code == 2

.venv/bin/python3 -m pytest tests/test_cli.py -q 2>&1 | tail -12

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

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

log = logging.getLogger(__name__)

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)
    log.debug("fayl o'qilmoqda: %s", p)
    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)}")
    log.info("o'qildi: %d qator, fayl %s", len(qatorlar), p.name)
    return qatorlar


def tozala(qatorlar: list[dict[str, str]], sozlama: Sozlama | None = None) -> 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"), sozlama)
            sana = sanani_tekshir(q.get("sana"))
        except ValueError as e:
            log.debug("%d-qator rad etildi: %s", i, 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,
            )
        )
    if natija.xatolar:
        log.warning("%d qatordan %d tasi rad etildi", natija.jami, len(natija.xatolar))
    return natija

"""Bir nechta CSV faylni parallel qayta ishlash."""
import logging
from concurrent.futures import ThreadPoolExecutor, as_completed
from pathlib import Path

from .modellar import Natija
from .oqish import oqi, tozala
from .sozlama import Sozlama
from .xatolar import HisobotXato

log = logging.getLogger(__name__)


def bitta(yol: Path, sozlama: Sozlama | None = None) -> tuple[Path, Natija | None, str | None]:
    """Bitta faylni qayta ishlaydi. Xato otmaydi — uni qaytaradi."""
    try:
        return yol, tozala(oqi(yol), sozlama), None
    except HisobotXato as e:
        return yol, None, str(e)


def hammasi(
    yollar: list[Path], ishchilar: int = 4, sozlama: Sozlama | None = None
) -> dict[str, Natija | str]:
    """Fayllarni parallel qayta ishlaydi. Bitta faylning xatosi boshqalarni to'xtatmaydi."""
    natijalar: dict[str, Natija | str] = {}
    with ThreadPoolExecutor(max_workers=ishchilar) as p:
        kelajaklar = {p.submit(bitta, y, sozlama): y for y in yollar}
        for k in as_completed(kelajaklar):
            yol, natija, xato = k.result()
            natijalar[yol.name] = natija if natija is not None else f"XATO: {xato}"
            log.debug("tugadi: %s", yol.name)
    return natijalar

natijalar = hammasi(list(args.fayllar), ishchilar=args.ishchilar, sozlama=sozlama)

sed -i 's/hammasi(list(args.fayllar), ishchilar=args.ishchilar)/hammasi(list(args.fayllar), ishchilar=args.ishchilar, sozlama=sozlama)/' src/hisobot/cli.py
grep -n "hammasi(list" src/hisobot/cli.py

.venv/bin/python3 -m pytest tests/test_cli.py -q 2>&1 | tail -4
echo ""
echo "=== endi --max-baho haqiqatan ishlaydi ==="
.venv/bin/python3 -m hisobot sinov_malumot.csv --max-baho 5 --jim 2>&1 | head -8

.venv/bin/python3 -m pip install --quiet build
.venv/bin/python3 -m build --wheel --outdir dist_sinov 2>&1 | tail -5
ls -la dist_sinov/

.venv/bin/python3 -c "
import zipfile, glob
w = glob.glob('dist_sinov/*.whl')[0]
with zipfile.ZipFile(w) as z:
    nomlar = sorted(z.namelist())
print('wheel ichidagi fayllar:')
for n in nomlar:
    print('  ', n)
"
rm -rf dist_sinov