Fayllar va formatlar: pathlib, JSON, CSV, SQLite

import os
from pathlib import Path

eski = os.path.join("malumot", "2026", "hisobot.csv")
yangi = Path("malumot") / "2026" / "hisobot.csv"
print("os.path.join:", eski)
print("pathlib     :", yangi)

p = Path("/uy/talaba/malumot/hisobot.2026.csv")
print("\nqismlari:")
for nom, qiymat in [("nomi", p.name), ("kengaytma", p.suffix), ("hamma kengaytmalar", p.suffixes),
                    ("kengaytmasiz", p.stem), ("papka", p.parent), ("ildiz", p.parts[:2])]:
    print(f"  {nom:20} {qiymat}")

from pathlib import Path
import tempfile

papka = Path(tempfile.mkdtemp())
(papka / "ichki").mkdir(parents=True, exist_ok=True)
(papka / "a.csv").write_text("ism,baho\nAziz,85\n", encoding="utf-8")
(papka / "b.csv").write_text("ism,baho\nBobur,90\n", encoding="utf-8")
(papka / "ichki" / "c.csv").write_text("ism,baho\nDilnoza,70\n", encoding="utf-8")
(papka / "eslatma.txt").write_text("bu CSV emas", encoding="utf-8")

print("faqat shu papkadagi CSV lar:", sorted(p.name for p in papka.glob("*.csv")))
print("ichkilari bilan birga      :", sorted(str(p.relative_to(papka)) for p in papka.rglob("*.csv")))
print("\nbor-yo'qligi:", (papka / "a.csv").exists(), "| papkami:", (papka / "ichki").is_dir())
print("hajmi:", (papka / "a.csv").stat().st_size, "bayt")
print("\no'qish bir qatorda:", (papka / "a.csv").read_text(encoding="utf-8").strip())

import shutil; shutil.rmtree(papka)

import tempfile, os
from pathlib import Path

p = Path(tempfile.mkdtemp()) / "uzbek.txt"
p.write_text("O'zbekiston — Toshkent shahri\n", encoding="utf-8")

print("utf-8 bilan   :", repr(p.read_text(encoding="utf-8").strip()))
try:
    print("latin-1 bilan :", repr(p.read_text(encoding="latin-1").strip()))
except UnicodeDecodeError as e:
    print("latin-1 bilan : XATO -", e)
import shutil; shutil.rmtree(p.parent)

"""Natijani turli formatlarda yozish."""
import csv
import json
import logging
from pathlib import Path
from typing import Any

from .hisob import daraja_taqsimoti, guruh_ortachasi
from .modellar import Natija

log = logging.getLogger(__name__)


def xulosa(natija: Natija) -> dict[str, Any]:
    """Natijadan JSON ga yaroqli lug'at yasaydi."""
    return {
        "jami": natija.jami,
        "togri": len(natija.talabalar),
        "xato": len(natija.xatolar),
        "guruh_ortachasi": guruh_ortachasi(natija.talabalar),
        "darajalar": daraja_taqsimoti(natija.talabalar),
        "xatolar": [{"qator": q, "ism": i, "sabab": s} for q, i, s in natija.xatolar],
    }


def json_yoz(natija: Natija, yol: str | Path) -> None:
    p = Path(yol)
    p.write_text(json.dumps(xulosa(natija), ensure_ascii=False, indent=2), encoding="utf-8")
    log.info("JSON yozildi: %s", p)


def csv_yoz(natija: Natija, yol: str | Path) -> None:
    p = Path(yol)
    with p.open("w", encoding="utf-8", newline="") as f:
        yozuvchi = csv.DictWriter(f, fieldnames=["ism", "guruh", "baho", "sana", "daraja"])
        yozuvchi.writeheader()
        for t in natija.talabalar:
            yozuvchi.writerow({"ism": t.ism, "guruh": t.guruh, "baho": t.baho,
                               "sana": t.sana, "daraja": t.daraja.value})
    log.info("CSV yozildi: %s", p)

.venv/bin/python3 -c "
from hisobot.oqish import oqi, tozala
from hisobot.chiqarish import json_yoz, csv_yoz
n = tozala(oqi('sinov_malumot.csv'))
json_yoz(n, 'natija.json')
csv_yoz(n, 'natija.csv')
"
cat natija.json
echo "--- CSV ---"
cat natija.csv

import json
malumot = {"ism": "Feruza", "daraja": "a'lo", "izoh": "o'qishni tugatdi"}
print("ensure_ascii=True (sukut):", json.dumps(malumot))
print("ensure_ascii=False       :", json.dumps(malumot, ensure_ascii=False))

import json
from datetime import date, datetime
from decimal import Decimal

sinovlar = [
    ("matn", "salom"), ("son", 42), ("kasr", 3.14), ("mantiqiy", True), ("yo'q", None),
    ("ro'yxat", [1, 2]), ("lug'at", {"a": 1}),
    ("sana", date(2026, 9, 1)), ("to'plam", {1, 2, 3}), ("Decimal", Decimal("10.5")),
    ("kortej", (1, 2)),
]
for nom, qiymat in sinovlar:
    try:
        natija = json.dumps(qiymat)
        print(f"  {nom:10} -> {natija}")
    except TypeError as e:
        print(f"  {nom:10} -> XATO: {e}")

import json
from datetime import date, datetime
from decimal import Decimal

def aylantir(x):
    if isinstance(x, (date, datetime)):
        return x.isoformat()
    if isinstance(x, set):
        return sorted(x)
    if isinstance(x, Decimal):
        return str(x)
    raise TypeError(f"JSON ga aylantirib bo'lmaydi: {type(x).__name__}")

malumot = {"sana": date(2026, 9, 1), "guruhlar": {"B", "A"}, "narx": Decimal("10.50")}
print(json.dumps(malumot, default=aylantir, ensure_ascii=False))

import csv, io

xom = 'ism,izoh,baho\nAziz,"yaxshi, lekin kech topshirdi",85\nBobur,"u ""ajoyib"" dedi",90\n'
print("xom matn:")
print(xom)
print("csv moduli bilan o'qilgani:")
for q in csv.DictReader(io.StringIO(xom)):
    print("  ", q)

print("\nqo'lda split(',') bilan (XATO):")
for qator in xom.strip().splitlines()[1:]:
    print("  ", qator.split(","))

import csv, io, tempfile, os
from pathlib import Path

papka = Path(tempfile.mkdtemp())
for nom, newline in [("newline_yoq.csv", None), ("newline_bor.csv", "")]:
    with open(papka / nom, "w", encoding="utf-8", newline=newline) as f:
        w = csv.writer(f)
        w.writerow(["ism", "baho"])
        w.writerow(["Aziz", 85])
    xom = (papka / nom).read_bytes()
    print(f"{nom:18} bayt: {xom!r}")
import shutil; shutil.rmtree(papka)

import sqlite3, tempfile, time
from pathlib import Path

yol = Path(tempfile.mkdtemp()) / "talabalar.db"
con = sqlite3.connect(yol)
con.execute("""
    CREATE TABLE talaba (
        id INTEGER PRIMARY KEY,
        ism TEXT NOT NULL,
        guruh TEXT NOT NULL,
        baho INTEGER NOT NULL CHECK (baho BETWEEN 0 AND 100)
    )
""")

qatorlar = [(f"Talaba{i}", "ABC"[i % 3], 50 + (i * 7) % 51) for i in range(10_000)]
t0 = time.perf_counter()
con.executemany("INSERT INTO talaba (ism, guruh, baho) VALUES (?, ?, ?)", qatorlar)
con.commit()
yozish_ms = (time.perf_counter() - t0) * 1000

t0 = time.perf_counter()
natija = con.execute(
    "SELECT guruh, COUNT(*), ROUND(AVG(baho), 2) FROM talaba GROUP BY guruh ORDER BY guruh"
).fetchall()
soro_ms = (time.perf_counter() - t0) * 1000

print(f"10 000 qator yozildi: {yozish_ms:.0f} ms | fayl hajmi: {yol.stat().st_size // 1024} KB")
print(f"guruh bo'yicha so'rov: {soro_ms:.1f} ms")
for guruh, soni, ortacha in natija:
    print(f"  {guruh}: {soni} talaba, o'rtacha {ortacha}")
con.close()
import shutil; shutil.rmtree(yol.parent)

import sqlite3
con = sqlite3.connect(":memory:")
con.execute("CREATE TABLE t (baho INTEGER CHECK (baho BETWEEN 0 AND 100))")
for qiymat in (85, 150):
    try:
        con.execute("INSERT INTO t VALUES (?)", (qiymat,))
        print(f"  {qiymat}: qabul qilindi")
    except sqlite3.IntegrityError as e:
        print(f"  {qiymat}: rad etildi — {e}")
con.close()

import sqlite3
con = sqlite3.connect(":memory:")
con.execute("CREATE TABLE t (ism TEXT, sir TEXT)")
con.executemany("INSERT INTO t VALUES (?, ?)", [("Aziz", "maxfiy1"), ("Bobur", "maxfiy2")])

xavfli_kirish = "' OR '1'='1"
print("1) Matn qo'shish bilan (XAVFLI):")
soro = f"SELECT * FROM t WHERE ism = '{xavfli_kirish}'"
print("   so'rov:", soro)
print("   natija:", con.execute(soro).fetchall())

print("\n2) Parametr bilan (XAVFSIZ):")
print("   natija:", con.execute("SELECT * FROM t WHERE ism = ?", (xavfli_kirish,)).fetchall())
con.close()

import csv, json, sqlite3, tempfile, time
from pathlib import Path

papka = Path(tempfile.mkdtemp())
malumot = [{"ism": f"Talaba{i}", "guruh": "ABC"[i % 3], "baho": 50 + (i * 7) % 51}
           for i in range(20_000)]

# CSV
t0 = time.perf_counter()
with (papka / "d.csv").open("w", encoding="utf-8", newline="") as f:
    w = csv.DictWriter(f, fieldnames=["ism", "guruh", "baho"]); w.writeheader(); w.writerows(malumot)
csv_yoz = (time.perf_counter() - t0) * 1000

# JSON
t0 = time.perf_counter()
(papka / "d.json").write_text(json.dumps(malumot, ensure_ascii=False), encoding="utf-8")
json_yoz = (time.perf_counter() - t0) * 1000

# SQLite
t0 = time.perf_counter()
con = sqlite3.connect(papka / "d.db")
con.execute("CREATE TABLE t (ism TEXT, guruh TEXT, baho INTEGER)")
con.executemany("INSERT INTO t VALUES (:ism, :guruh, :baho)", malumot)
con.commit(); con.close()
db_yoz = (time.perf_counter() - t0) * 1000

import pandas as pd
show(pd.DataFrame([
    {"format": "CSV", "yozish, ms": round(csv_yoz), "hajm, KB": (papka / "d.csv").stat().st_size // 1024,
     "tuzilma": "tekis jadval", "so'rov": "yo'q — hammasini o'qish kerak"},
    {"format": "JSON", "yozish, ms": round(json_yoz), "hajm, KB": (papka / "d.json").stat().st_size // 1024,
     "tuzilma": "ichma-ich", "so'rov": "yo'q — hammasini o'qish kerak"},
    {"format": "SQLite", "yozish, ms": round(db_yoz), "hajm, KB": (papka / "d.db").stat().st_size // 1024,
     "tuzilma": "jadvallar + indeks", "so'rov": "SQL, indeks bilan tez"},
]))
import shutil; shutil.rmtree(papka)

import json

from hisobot.chiqarish import csv_yoz, json_yoz, xulosa


def test_xulosa_tuzilishi(talabalar):
    from hisobot.modellar import Natija
    x = xulosa(Natija(talabalar=talabalar, xatolar=[(5, "X", "baho son emas")]))
    assert x["jami"] == 4
    assert x["togri"] == 3
    assert x["xato"] == 1
    assert x["guruh_ortachasi"] == {"A": 90.0, "B": 70.0}
    assert x["xatolar"][0]["qator"] == 5


def test_json_yoz_oqiladi(tmp_path, talabalar):
    from hisobot.modellar import Natija
    yol = tmp_path / "n.json"
    json_yoz(Natija(talabalar=talabalar), yol)
    qayta = json.loads(yol.read_text(encoding="utf-8"))
    assert qayta["togri"] == 3


def test_json_uzbekcha_harflar(tmp_path):
    from hisobot.modellar import Natija, Talaba
    yol = tmp_path / "n.json"
    json_yoz(Natija(talabalar=[Talaba("Feruza", "A", 95, "2026-09-01")]), yol)
    matn = yol.read_text(encoding="utf-8")
    assert "a'lo" in matn
    assert "\\u" not in matn


def test_csv_yoz_sarlavha(tmp_path, talabalar):
    from hisobot.modellar import Natija
    yol = tmp_path / "n.csv"
    csv_yoz(Natija(talabalar=talabalar), yol)
    qatorlar = yol.read_text(encoding="utf-8").splitlines()
    assert qatorlar[0] == "ism,guruh,baho,sana,daraja"
    assert len(qatorlar) == 4

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