Fayllar, yo'llar va ma'lumot formatlari

import os
path = os.path.join("data", "raw", "reviews.csv")   # eski uslub

from pathlib import Path
 
DATA_DIR = Path("data")
p = DATA_DIR / "raw" / "reviews.csv"    # / operatori yo'lni birlashtiradi
 
p.name           # 'reviews.csv'
p.stem           # 'reviews'
p.suffix         # '.csv'
p.parent         # Path('data/raw')
p.with_suffix(".parquet")   # Path('data/raw/reviews.parquet')
p.parts          # ('data', 'raw', 'reviews.csv')

p.exists()                  # mavjudmi
p.is_file(), p.is_dir()
p.stat().st_size            # hajmi, baytda
p.resolve()                 # to'liq (absolyut) yo'l
 
out = Path("outputs") / "run-01"
out.mkdir(parents=True, exist_ok=True)   # ichma-ich papkalar; mavjud bo'lsa xato yo'q
 
p.read_text(encoding="utf-8")            # butun faylni satr sifatida
p.write_text("salom", encoding="utf-8")  # yozish (eski mazmun o'chadi)
p.read_bytes(), p.write_bytes(b"...")
 
p.rename(p.with_name("old.csv"))
p.unlink(missing_ok=True)                # faylni o'chirish

data = Path("data")
list(data.glob("*.csv"))           # faqat shu papkadagi .csv'lar
list(data.rglob("*.jsonl"))        # barcha ichki papkalarda ham
sorted(data.glob("img_*.png"))     # tartib kafolatlanmaydi — saralang!
 
for f in data.iterdir():           # papka ichidagilar
    if f.is_file():
        print(f.name, f.stat().st_size)

# src/myproject/config.py
from pathlib import Path
 
PROJECT_ROOT = Path(__file__).resolve().parents[2]   # config.py → myproject → src → loyiha
DATA_DIR = PROJECT_ROOT / "data"

with open("notes.txt", "w", encoding="utf-8") as f:
    f.write("Birinchi qator\n")
    f.write("Ikkinchi qator\n")
 
with open("notes.txt", encoding="utf-8") as f:      # standart rejim — "r"
    content = f.read()

with open(path, encoding="utf-8", errors="replace") as f:   # buzilgan baytlar → �
    text = f.read()

with open(path, encoding="utf-8") as f:
    text = f.read()             # butun fayl — bitta satr (kichik fayllar uchun)
 
with open(path, encoding="utf-8") as f:
    lines = f.readlines()       # qatorlar ro'yxati (\n bilan) — butun fayl xotirada
 
with open(path, encoding="utf-8") as f:
    for line in f:              # ✅ qatorma-qator — xotira tejamkor (7-bob!)
        process(line.rstrip("\n"))

import hashlib
 
 
def sha256(path: Path, chunk_size: int = 1 << 20) -> str:
    """Katta faylning hash'ini 1 MB bo'laklab hisoblaydi."""
    h = hashlib.sha256()
    with open(path, "rb") as f:
        while chunk := f.read(chunk_size):
            h.update(chunk)
    return h.hexdigest()

"Vali, kichik",92       # split(",") → ['"Vali', ' kichik"', '92'] ❌

import csv
 
with open("talabalar.csv", encoding="utf-8", newline="") as f:
    for row in csv.DictReader(f):            # har qator — lug'at
        print(row["ism"], int(row["ball"]))  # qiymatlar har doim SATR — o'zingiz aylantiring
 
rows = [{"ism": "Ali", "ball": 85}, {"ism": "Vali, kichik", "ball": 92}]
with open("natija.csv", "w", encoding="utf-8", newline="") as f:
    writer = csv.DictWriter(f, fieldnames=["ism", "ball"])
    writer.writeheader()
    writer.writerows(rows)

import json
 
data = {"ism": "Aziz", "yosh": 25, "faol": True, "telefon": None, "baholar": [5, 4]}
 
s = json.dumps(data, ensure_ascii=False, indent=2)   # obyekt → satr
obj = json.loads(s)                                  # satr → obyekt
 
with open("data.json", "w", encoding="utf-8") as f:
    json.dump(data, f, ensure_ascii=False, indent=2)  # faylga
 
with open("data.json", encoding="utf-8") as f:
    obj = json.load(f)                                # fayldan

from datetime import datetime
 
json.dumps({"vaqt": datetime(2026, 10, 1)}, default=str)
# '{"vaqt": "2026-10-01 00:00:00"}'

import json
import re
 
 
def extract_json(text: str) -> dict:
    """Model javobidan birinchi JSON obyektini ajratib oladi."""
    fenced = re.search(r"```(?:json)?\s*(\{.*?\})\s*```", text, re.DOTALL)
    candidate = fenced.group(1) if fenced else text[text.find("{"): text.rfind("}") + 1]
    try:
        return json.loads(candidate)
    except json.JSONDecodeError as e:
        raise ValueError(f"Javobda yaroqli JSON topilmadi: {text[:200]!r}") from e

{"prompt": "Poytaxt qaysi?", "completion": "Toshkent"}
{"prompt": "2+2?", "completion": "4"}
{"prompt": "Eng uzun daryo?", "completion": "Amudaryo"}

def append_jsonl(path: Path, record: dict) -> None:
    with open(path, "a", encoding="utf-8") as f:
        f.write(json.dumps(record, ensure_ascii=False) + "\n")

import pickle
 
with open("model.pkl", "wb") as f:
    pickle.dump(model, f)
 
with open("model.pkl", "rb") as f:
    model = pickle.load(f)

import tomllib
 
with open("pyproject.toml", "rb") as f:     # tomllib binary rejim talab qiladi
    cfg = tomllib.load(f)
print(cfg["project"]["name"])

import json
import os
import tempfile
from pathlib import Path
 
 
def atomic_write_json(path: Path, data) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    fd, tmp = tempfile.mkstemp(dir=path.parent, prefix=f".{path.name}.", suffix=".tmp")
    try:
        with os.fdopen(fd, "w", encoding="utf-8") as f:
            json.dump(data, f, ensure_ascii=False, indent=2)
            f.flush()
            os.fsync(f.fileno())          # diskka haqiqatan yozilganiga ishonch
        os.replace(tmp, path)             # atomik: yo eski fayl, yo yangi — oraliq holat yo'q
    except BaseException:
        Path(tmp).unlink(missing_ok=True)
        raise

import shutil
import tempfile
 
shutil.copy2("a.csv", "backup/a.csv")         # nusxa (metama'lumot bilan)
shutil.copytree("data", "data_backup")        # butun papka
shutil.rmtree("tmp_outputs")                  # papkani butunlay o'chirish — EHTIYOT!
shutil.move("a.csv", "archive/")
shutil.make_archive("results", "zip", "outputs")   # outputs/ → results.zip
shutil.disk_usage("/").free                   # bo'sh joy
 
with tempfile.TemporaryDirectory() as tmp:    # blokdan chiqqanda o'chiriladi
    work = Path(tmp) / "work.txt"
    work.write_text("vaqtinchalik", encoding="utf-8")

"""reviews.csv → train.jsonl + val.jsonl"""
 
import csv
import json
import logging
import random
from pathlib import Path
 
log = logging.getLogger(__name__)
 
ROOT = Path(__file__).resolve().parent
RAW = ROOT / "data" / "raw" / "reviews.csv"
OUT = ROOT / "data" / "processed"
VALID_LABELS = {"positive", "negative", "neutral"}
 
 
def read_reviews(path: Path):
    with open(path, encoding="utf-8-sig", newline="") as f:
        for n, row in enumerate(csv.DictReader(f), start=2):     # 1-qator — sarlavha
            text = (row.get("text") or "").strip()
            label = (row.get("label") or "").strip().lower()
            if not text or label not in VALID_LABELS:
                log.warning("%s:%d o'tkazib yuborildi (text=%r, label=%r)", path.name, n, text[:30], label)
                continue
            yield {"text": " ".join(text.split()), "label": label}
 
 
def write_jsonl(path: Path, records: list[dict]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    with open(path, "w", encoding="utf-8") as f:
        for r in records:
            f.write(json.dumps(r, ensure_ascii=False) + "\n")
 
 
def main(val_ratio: float = 0.1, seed: int = 42) -> None:
    logging.basicConfig(level=logging.INFO, format="%(levelname)s %(message)s")
    records = list(read_reviews(RAW))
    unique = list({r["text"]: r for r in records}.values())        # dublikat matnlarni olib tashlash
    log.info("%d ta yozuv, %d ta dublikat olib tashlandi", len(unique), len(records) - len(unique))
 
    random.Random(seed).shuffle(unique)
    n_val = max(1, int(len(unique) * val_ratio))
    write_jsonl(OUT / "val.jsonl", unique[:n_val])
    write_jsonl(OUT / "train.jsonl", unique[n_val:])
    log.info("train=%d, val=%d → %s", len(unique) - n_val, n_val, OUT)
 
 
if __name__ == "__main__":
    main()