Jurnal (logging): print dan chiqish

import logging, sys

logging.basicConfig(level=logging.DEBUG, format="%(levelname)-8s %(message)s", stream=sys.stdout, force=True)
log = logging.getLogger("namuna")

log.debug("tafsilot: 3-qator o'qildi")
log.info("hisobot tayyor: 6 qator")
log.warning("2 qator tashlab yuborildi")
log.error("fayl o'qilmadi")
log.critical("ma'lumotlar bazasi javob bermayapti")

import logging, sys
logging.basicConfig(level=logging.WARNING, format="%(levelname)-8s %(message)s", stream=sys.stdout, force=True)
log = logging.getLogger("namuna")

log.debug("bu ko'rinmaydi")
log.info("bu ham ko'rinmaydi")
log.warning("bu ko'rinadi")
log.error("bu ham ko'rinadi")
print("--- faqat WARNING va yuqorisi chiqdi ---")

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

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

log = logging.getLogger(__name__)          # "hisobot.oqish" — modul nomi bilan

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]]) -> 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"))
            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

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

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

log = logging.getLogger(__name__)


def jurnalni_sozla(batafsil: int) -> None:
    """Faqat DASTUR sozlaydi, kutubxona emas."""
    daraja = {0: logging.WARNING, 1: logging.INFO}.get(batafsil, logging.DEBUG)
    logging.basicConfig(
        level=daraja,
        format="%(asctime)s %(levelname)-8s %(name)s: %(message)s",
        datefmt="%H:%M:%S",
        stream=sys.stderr,
    )


def main(argv: list[str] | None = None) -> int:
    p = argparse.ArgumentParser(prog="hisobot", description="CSV dan hisobot")
    p.add_argument("fayl", help="CSV fayl yo'li")
    p.add_argument("-v", "--batafsil", action="count", default=0,
                   help="-v: INFO, -vv: DEBUG")
    args = p.parse_args(argv)
    jurnalni_sozla(args.batafsil)

    try:
        n = tozala(oqi(args.fayl))
    except HisobotXato as e:
        log.error("%s", e)
        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))
    return 0 if not n.xatolar else 1


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

echo "=== sukut bo'yicha (faqat WARNING+) ==="
.venv/bin/python3 -m hisobot sinov_malumot.csv
echo ""
echo "=== -v (INFO) ==="
.venv/bin/python3 -m hisobot -v sinov_malumot.csv
echo ""
echo "=== -vv (DEBUG) ==="
.venv/bin/python3 -m hisobot -vv sinov_malumot.csv

import logging, sys, time
logging.basicConfig(level=logging.WARNING, format="%(message)s", stream=sys.stdout, force=True)
log = logging.getLogger("tezlik")

def qimmat():
    time.sleep(0.0005)
    return "hisoblangan qiymat"

t0 = time.perf_counter()
for _ in range(200):
    log.debug(f"natija: {qimmat()}")            # f-string HAR DOIM hisoblanadi
fstring_ms = (time.perf_counter() - t0) * 1000

t0 = time.perf_counter()
for _ in range(200):
    log.debug("natija: %s", qimmat())           # bu ham hisoblanadi (argument!)
lazy_ms = (time.perf_counter() - t0) * 1000

t0 = time.perf_counter()
for _ in range(200):
    if log.isEnabledFor(logging.DEBUG):
        log.debug("natija: %s", qimmat())       # bu hisoblanmaydi
shart_ms = (time.perf_counter() - t0) * 1000

print(f"f-string           : {fstring_ms:6.1f} ms")
print(f"%s bilan           : {lazy_ms:6.1f} ms")
print(f"isEnabledFor bilan : {shart_ms:6.1f} ms")
print("(DEBUG o'chiq, ya'ni bu xabarlarning birortasi ham chop etilmadi)")

import logging, tempfile, os
from logging.handlers import RotatingFileHandler

papka = tempfile.mkdtemp()
yol = os.path.join(papka, "hisobot.log")

log = logging.getLogger("fayl_namuna")
log.setLevel(logging.INFO)
log.handlers.clear()
h = RotatingFileHandler(yol, maxBytes=500, backupCount=3, encoding="utf-8")
h.setFormatter(logging.Formatter("%(asctime)s %(levelname)s %(message)s", datefmt="%H:%M:%S"))
log.addHandler(h)
log.propagate = False

for i in range(60):
    log.info("qator %d qayta ishlandi, natija tayyor", i)
h.close()

fayllar = sorted(os.listdir(papka))
print("yaratilgan fayllar:", fayllar)
for f in fayllar:
    print(f"  {f}: {os.path.getsize(os.path.join(papka, f))} bayt")
print("\noxirgi faylning birinchi qatori:")
with open(os.path.join(papka, "hisobot.log"), encoding="utf-8") as f:
    print("  ", f.readline().strip())
import shutil; shutil.rmtree(papka)

import logging, sys
logging.basicConfig(level=logging.ERROR, format="%(levelname)s %(message)s", stream=sys.stdout, force=True)
log = logging.getLogger("istisno")

def yiqiladi():
    return 1 / 0

print("1) log.error — iz YO'Q:")
try:
    yiqiladi()
except ZeroDivisionError as e:
    log.error("hisob bajarilmadi: %s", e)

print("\n2) log.exception — iz BOR (faqat except ichida ishlaydi):")
try:
    yiqiladi()
except ZeroDivisionError:
    log.exception("hisob bajarilmadi")

import logging

from hisobot.oqish import tozala


def test_xato_bolsa_ogohlantiradi(caplog):
    qatorlar = [
        {"ism": "A", "guruh": "X", "baho": "85", "sana": "2026-01-01"},
        {"ism": "B", "guruh": "X", "baho": "abc", "sana": "2026-01-01"},
    ]
    with caplog.at_level(logging.WARNING, logger="hisobot.oqish"):
        n = tozala(qatorlar)
    assert len(n.xatolar) == 1
    assert "rad etildi" in caplog.text


def test_hammasi_togri_bolsa_ogohlantirmaydi(caplog):
    qatorlar = [{"ism": "A", "guruh": "X", "baho": "85", "sana": "2026-01-01"}]
    with caplog.at_level(logging.WARNING, logger="hisobot.oqish"):
        tozala(qatorlar)
    assert caplog.text == ""

.venv/bin/python3 -m pytest tests/test_jurnal.py -v