27.5-dars: Model versiyalash va registr

                 +-----------+
                 |    KOD    |  git commit (a1b2c3d), toza ishchi daraxt
                 +-----+-----+
                       |
   +-----------+       v        +-------------+
   | MA'LUMOT  | ---> O'RGATISH <--- | KONFIG+MUHIT|  seed, giperparametrlar,
   | xesh 9f3e |       |        | requirements.lock 27.2-bob
   +-----------+       v        +-------------+
                 +-----------+
                 |   MODEL   |  artefakt xeshi, metrikalar
                 +-----------+

MODEL VERSIYASI = (kod versiyasi, ma'lumot xeshi, konfig, muhit) -> artefakt

QOIDA: uchlikdan bittasi noma'lum bo'lsa - model QAYTA QURILMAYDI

{
  "model": "mijoz_ketishi",
  "versiya": "1.2.0",
  "kod_versiyasi": "a1b2c3d",          <- git commit
  "malumot_xeshi": "9f3e41c07b2a",     <- o'rgatish ma'lumoti
  "konfig": {"C": 1.0, "seed": 7},
  "muhit": "requirements.lock xeshi",
  "model_xeshi": "5d0c8e1a44f2",       <- artefakt fayli
  "metrikalar": {"auc": 0.81},
  "run_id": "run-0042"                 <- eksperiment kuzatuvi 27.4-bob
}

XOM XESH:  sha256(fayl baytlari)
  + oddiy, tez
  - qatorlar tartibi o'zgarsa  -> boshqa xesh (mazmun o'sha!)
  - float yozilishi 0.1 vs 0.10000000001 -> boshqa xesh
  - CSV da \r\n vs \n (Windows!)         -> boshqa xesh

KANONIK XESH:
  1. ustunlar nomi bo'yicha tartiblanadi
  2. qatorlar kalit (id) bo'yicha tartiblanadi
  3. sonlar bir xil formatda (%.6f)
  4. qator oxiri bir xil (\n)
  5. sha256 -> birinchi 12 belgi (ko'rsatish uchun)

QACHON QAYSI:
  fayl ombori (DVC)     -> xom xesh (fayl aynan saqlanadi)
  "mazmun bir xilmi?"   -> kanonik xesh

MAJOR (1.x.x -> 2.0.0)  - SHARTNOMA buzildi, iste'molchi kodini o'zgartirishi kerak:
  yangi MAJBURIY kirish ustuni, ustun olib tashlandi
  chiqish ma'nosi o'zgardi (ehtimol -> sinf, yangi sinflar)
  birlik o'zgardi (so'm -> ming so'm)

MINOR (1.2.x -> 1.3.0)  - shartnoma o'sha, xatti-harakat o'zgardi:
  yangi ma'lumot bilan qayta o'qitish
  giperparametr yoki algoritm almashdi
  ixtiyoriy (sukut qiymatli) yangi ustun

PATCH (1.2.3 -> 1.2.4)  - bashoratlar o'zgarmaydi:
  metadata, model kartasi, hujjat tuzatildi
  paketlash tuzatildi (bir xil bashorat)

REGISTR YOZUVI (nom, versiya):
  nom             "mijoz_ketishi"
  versiya         3                   (avtomatik, o'sib boradi)
  bosqich         None | Staging | Production | Archived
  metrikalar      {"auc": 0.84, "log_loss": 0.41}
  kelib chiqish (lineage):
    malumot_xeshi   "9f3e41c07b2a"
    kod_versiyasi   "a1b2c3d"
    run_id          "run-0042"        -> eksperiment kuzatuvidagi to'liq yozuv
  artefakt        ombordagi fayl + uning xeshi
  model kartasi   maqsad, cheklovlar, adolatlilik 26.10-bob

AUDIT JADVALI (hech qachon o'chirilmaydi, faqat qo'shiladi):
  soat | nom | versiya | eski bosqich | yangi bosqich | kim | sabab

            ro'yxatga olish
                  |
                  v
               [None] ---------------------+
                  |                        |
                  v                        v
             [Staging] ---- rad ----> [Archived]
                  |                     ^    |
          DARVOZA |                     |    | rollback
                  v                     |    | (maxsus yo'l)
           [Production] --- almashdi ---+    |
                  ^                          |
                  +--------------------------+

RUXSAT ETILGAN O'TISHLAR:
  None -> Staging, None -> Archived
  Staging -> Production (faqat DARVOZA orqali)
  Staging -> Archived
  Production -> Archived (yangisi chiqqanda avtomatik)
  Archived -> Staging (qayta ko'rib chiqish)
  Archived -> Production - FAQAT rollback, audit sababi bilan

TAQIQLANGAN:
  None -> Production  ("to'g'ridan-to'g'ri prodga")
  bitta nomda ikkita Production

DARVOZA (misoldagi):
  1. MUTLAQ CHEGARA:   AUC(nomzod) >= 0.70    (biznes bilan kelishilgan)
  2. NISBIY SHART:     nomzod joriy Production dan SEZILARLI YOMON EMAS

  2-shartni tekshirish - JUFTLASHGAN taqqoslash, bir xil validatsiya to'plamida:
    har namuna i uchun:  d_i = logloss_nomzod(i) - logloss_prod(i)
    o'rtacha d,  SE = std(d) / sqrt(n)
    o'rtacha d > 2*SE  -> nomzod sezilarli YOMON -> RAD
    aks holda          -> o'tadi

QO'SHIMCHA (haqiqiy loyihalarda):
  sxema mosligi 27.6-bob, kechikish byudjeti 27.8-bob, adolatlilik metrikalari,
  segmentlar bo'yicha (yangi mijozlar, hududlar) regressiya yo'qligi

ROLLBACK:
  1. joriy Production -> Archived  (sabab: "rollback: <nima bo'ldi>")
  2. OLDINGI Production -> Production
       "oldingi" = auditda oxirgi marta Production -> Archived bo'lgan
                   boshqa versiya
  3. ikkala qadam BITTA tranzaksiyada (yarim holat bo'lmaydi)

NEGA TEZ: artefakt registrda turibdi, qayta o'qitish shart emas
NEGA DARVOZASIZ: oldingi versiya allaqachon ishlab chiqarishda sinalgan
                 (lekin sabab va kim - auditga MAJBURIY)

AUDIT BERADIGAN JAVOBLAR:
  "hozir qaysi versiya?"              -> versiyalar jadvali
  "5-mart kuni qaysi versiya edi?"    -> audit, shu vaqtgacha oxirgi Production
  "bu ma'lumotdan qaysi modellar?"    -> lineage bo'yicha so'rov
  "kim prodga chiqargan va nega?"     -> audit.kim, audit.sabab

ISHCHI PAPKA                     OMBOR (kesh / masofaviy)
  data/mijozlar.csv      --->      ab/12cd34...   (fayl xeshi = manzil)
  data/mijozlar.csv.dvc            5f/9e01aa...
     outs:
       - path: mijozlar.csv
         sha256: ab12cd34...       <- GIT FAQAT SHU KICHIK FAYLNI SAQLAYDI
         size: 81234

XOSSALAR:
  bir xil mazmun -> bir xil xesh -> BIR marta saqlanadi (dedup)
  mazmun o'zgarsa -> yangi xesh -> yangi obyekt, eskisi joyida
  "checkout" = ko'rsatkichdagi xesh bo'yicha fayl ombordan tiklanadi
  butunlik: ombordagi obyekt xeshi nomiga mos emas -> buzilgan
  gc: hech bir ko'rsatkich ishora qilmagan obyektlar o'chiriladi

dvc init
dvc add data/mijozlar.csv          # data/mijozlar.csv.dvc yaratiladi
git add data/mijozlar.csv.dvc data/.gitignore
git commit -m "ma'lumot v1"
dvc push                           # obyektlar masofaviy omborga
git checkout v1 && dvc checkout    # ma'lumot v1 holatiga qaytadi
dvc repro                          # dvc.yaml dagi quvurni kerak joyidan qayta ishlatadi

stages:
  tayyorla:
    cmd: python tayyorla.py
    deps: [tayyorla.py, data/mijozlar.csv]
    outs: [data/tayyor.csv]
  orgat:
    cmd: python orgat.py
    deps: [orgat.py, data/tayyor.csv]
    params: [orgat.C, orgat.seed]
    outs: [model/model.joblib]
    metrics: [natija/metrikalar.json]

import mlflow
from mlflow import MlflowClient

natija = mlflow.register_model("runs:/run-0042/model", "mijoz_ketishi")
mijoz = MlflowClient()
mijoz.set_model_version_tag("mijoz_ketishi", natija.version,
                            "malumot_xeshi", "9f3e41c07b2a")
mijoz.set_registered_model_alias("mijoz_ketishi", "champion", natija.version)
model = mlflow.pyfunc.load_model("models:/mijoz_ketishi@champion")

MODEL KARTASI (qisqa):
  maqsad va iste'molchi      "ketish ehtimoli, marketing uchun, kredit qarori UCHUN EMAS"
  o'rgatish ma'lumoti        malumot_xeshi, davr, hajm, segmentlar
  metrikalar                 umumiy + segmentlar bo'yicha
  cheklovlar                 "yangi mijozlarda (oylar < 3) sinalmagan"
  adolatlilik                guruhlar bo'yicha farqlar
  egasi va aloqa             jamoa, navbatchi

import hashlib
import json
import sqlite3


def malumot_xeshi(df, kalit="mijoz_id"):
    kanonik = df[sorted(df.columns)].sort_values(kalit)
    matn = kanonik.to_csv(index=False, float_format="%.6f", lineterminator="\n")
    return hashlib.sha256(matn.encode("utf-8")).hexdigest()[:12]


def keyingi_versiya(joriy, ozgarish):
    katta, orta, kichik = map(int, joriy.split("."))
    if ozgarish == "MAJOR":
        return f"{katta + 1}.0.0"
    if ozgarish == "MINOR":
        return f"{katta}.{orta + 1}.0"
    return f"{katta}.{orta}.{kichik + 1}"


RUXSAT = {("None", "Staging"), ("None", "Archived"), ("Staging", "Production"),
          ("Staging", "Archived"), ("Production", "Archived"),
          ("Archived", "Staging")}

db = sqlite3.connect(":memory:")
db.execute("CREATE TABLE audit (id INTEGER PRIMARY KEY, nom TEXT, versiya INT,"
           " eski TEXT, yangi TEXT, kim TEXT, sabab TEXT)")
with db:                                   # tranzaksiya: hammasi yoki hech narsa
    db.execute("INSERT INTO audit (nom, versiya, eski, yangi, kim, sabab)"
               " VALUES (?, ?, ?, ?, ?, ?)",
               ("mijoz_ketishi", 1, "Staging", "Production", "ali", "darvoza"))

model versiyasi = kod (git) + ma'lumot (xesh) + konfig/muhit -> artefakt (xesh)
semver: MAJOR shartnoma / MINOR xatti-harakat / PATCH bashorat o'zgarmaydi
registr: nom, versiya, bosqich, metrikalar, lineage, karta + audit (append-only)
None -> Staging -> [darvoza] -> Production -> Archived; rollback - maxsus yo'l
darvoza: mutlaq chegara + juftlashgan "sezilarli yomon emas" (2*SE)
DVC: fayl xeshi -> ombor manzili, git da faqat kichik ko'rsatkich

"""Kod + ma'lumot + model: xeshlar, manifest, qayta tiklash, semantik versiya."""

import hashlib
import inspect
import io
import json

import joblib
import numpy as np
import pandas as pd
from sklearn.compose import ColumnTransformer
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import roc_auc_score
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import OneHotEncoder, StandardScaler

SONLI = ["oylar", "tolov", "shikoyat"]
KATEGORIAL = ["tarif"]


def malumot(n, seed):
    rng = np.random.default_rng(seed)
    df = pd.DataFrame({
        "mijoz_id": np.arange(n),
        "oylar": rng.integers(1, 72, n),
        "tolov": rng.normal(60, 20, n).clip(10, 150).round(2),
        "shikoyat": rng.poisson(0.8, n),
        "tarif": rng.choice(["oylik", "yillik", "ikki_yillik"], n,
                            p=[0.55, 0.3, 0.15]),
    })
    logit = (-1.0 - 0.04 * df["oylar"] + 0.02 * (df["tolov"] - 60)
             + 0.5 * df["shikoyat"]
             + np.where(df["tarif"] == "oylik", 1.0, -0.5))
    df["ketdi"] = (rng.random(n) < 1 / (1 + np.exp(-logit))).astype(int)
    return df


def xesh(baytlar):
    return hashlib.sha256(baytlar).hexdigest()[:12]


def malumot_xeshi(df, kanonik=True):
    if kanonik:
        df = df[sorted(df.columns)].sort_values("mijoz_id")
    matn = df.to_csv(index=False, float_format="%.6f", lineterminator="\n")
    return xesh(matn.encode("utf-8"))


def orgat(df, konfig):
    pre = ColumnTransformer([
        ("son", StandardScaler(), SONLI),
        ("kat", OneHotEncoder(handle_unknown="ignore"), KATEGORIAL),
    ])
    model = Pipeline([("pre", pre),
                      ("clf", LogisticRegression(C=konfig["C"], max_iter=1000))])
    return model.fit(df[SONLI + KATEGORIAL], df["ketdi"])


def orgat_muvozanatli(df, konfig):
    pre = ColumnTransformer([
        ("son", StandardScaler(), SONLI),
        ("kat", OneHotEncoder(handle_unknown="ignore"), KATEGORIAL),
    ])
    model = Pipeline([("pre", pre),
                      ("clf", LogisticRegression(C=konfig["C"], max_iter=1000,
                                                 class_weight="balanced"))])
    return model.fit(df[SONLI + KATEGORIAL], df["ketdi"])


def kod_versiyasi(funksiya):
    # haqiqiy loyihada: git commit xeshi (toza ishchi daraxt bilan)
    return xesh(inspect.getsource(funksiya).encode("utf-8"))


def konfig_xeshi(konfig):
    return xesh(json.dumps(konfig, sort_keys=True).encode("utf-8"))


def model_xeshi(model):
    bufer = io.BytesIO()
    joblib.dump(model, bufer)
    return xesh(bufer.getvalue())


def keyingi_versiya(joriy, ozgarish):
    katta, orta, kichik = map(int, joriy.split("."))
    if ozgarish == "MAJOR":
        return f"{katta + 1}.0.0"
    if ozgarish == "MINOR":
        return f"{katta}.{orta + 1}.0"
    return f"{katta}.{orta}.{kichik + 1}"


def main() -> None:
    konfig = {"C": 1.0, "seed": 7}
    df = malumot(4000, seed=konfig["seed"])
    orgatish, sinov = df.iloc[:3000], df.iloc[3000:]

    print("=== 1. Ma'lumot xeshi ===")
    h1 = malumot_xeshi(orgatish)
    h2 = malumot_xeshi(malumot(4000, seed=7).iloc[:3000])
    aralash = orgatish.sample(frac=1.0, random_state=0)
    bitta = orgatish.copy()
    bitta.loc[bitta.index[5], "tolov"] += 0.01
    print(f"  asl ma'lumot:                  {h1}")
    print(f"  qayta generatsiya:             {h2}  teng: {h1 == h2}")
    print(f"  qatorlar aralashgan, xom:      "
          f"{malumot_xeshi(aralash, kanonik=False)}")
    print(f"  qatorlar aralashgan, kanonik:  {malumot_xeshi(aralash)}  "
          f"teng: {malumot_xeshi(aralash) == h1}")
    print(f"  bitta qiymat +0.01:            {malumot_xeshi(bitta)}  "
          f"teng: {malumot_xeshi(bitta) == h1}")

    print("\n=== 2. Manifest: uchlik bitta joyda ===")
    model = orgat(orgatish, konfig)
    p = model.predict_proba(sinov[SONLI + KATEGORIAL])[:, 1]
    manifest = {
        "model": "mijoz_ketishi",
        "versiya": "1.0.0",
        "malumot_xeshi": h1,
        "qatorlar": len(orgatish),
        "kod_versiyasi": kod_versiyasi(orgat),
        "konfig": konfig,
        "konfig_xeshi": konfig_xeshi(konfig),
        "model_xeshi": model_xeshi(model),
        "metrikalar": {"auc": round(float(roc_auc_score(sinov["ketdi"], p)), 4)},
    }
    for kalit, qiymat in manifest.items():
        print(f"  {kalit:<14} {qiymat}")

    print("\n=== 3. Manifestdan qayta qurish ===")
    qayta_df = malumot(4000, seed=manifest["konfig"]["seed"]).iloc[:3000]
    print(f"  ma'lumot xeshi mos: "
          f"{malumot_xeshi(qayta_df) == manifest['malumot_xeshi']}")
    qayta = orgat(qayta_df, manifest["konfig"])
    print(f"  kod versiyasi mos:  "
          f"{kod_versiyasi(orgat) == manifest['kod_versiyasi']}")
    print(f"  konfig xeshi mos:   "
          f"{konfig_xeshi(manifest['konfig']) == manifest['konfig_xeshi']}")
    print(f"  model xeshi mos:    "
          f"{model_xeshi(qayta) == manifest['model_xeshi']}")
    farq = np.abs(qayta.predict_proba(sinov[SONLI + KATEGORIAL])[:, 1] - p).max()
    print(f"  bashoratlar max farqi: {farq:.1e}")

    print("\n=== 4. Qaysi o'zgarish qaysi xeshni o'zgartiradi ===")
    yangi_df = malumot(3500, seed=8)
    variantlar = [
        ("hech narsa", orgat, orgatish, konfig),
        ("yangi ma'lumot (3500)", orgat, yangi_df, konfig),
        ("konfig: C=0.1", orgat, orgatish, {**konfig, "C": 0.1}),
        ("kod: class_weight", orgat_muvozanatli, orgatish, konfig),
    ]
    asos = (h1, manifest["kod_versiyasi"], manifest["konfig_xeshi"],
            manifest["model_xeshi"])
    sarlavha = "o'zgarish"
    print(f"  {sarlavha:<22} {'malumot':<9} {'kod':<9} {'konfig':<9} model")
    for nom, funksiya, d, k in variantlar:
        joriy = (malumot_xeshi(d), kod_versiyasi(funksiya), konfig_xeshi(k),
                 model_xeshi(funksiya(d, k)))
        b = ["o'zgardi" if x != y else "-" for x, y in zip(joriy, asos)]
        print(f"  {nom:<22} {b[0]:<9} {b[1]:<9} {b[2]:<9} {b[3]}")

    print("\n=== 5. Semantik versiya ===")
    stsenariylar = [
        ("MINOR", "yangi oy ma'lumoti bilan qayta o'qitish"),
        ("PATCH", "model kartasidagi imlo tuzatildi"),
        ("MINOR", "C giperparametri o'zgardi"),
        ("MAJOR", "yangi MAJBURIY kirish ustuni: hudud"),
        ("PATCH", "paket metadata si tuzatildi"),
        ("MAJOR", "chiqish: ehtimol o'rniga sinf"),
    ]
    versiya = manifest["versiya"]
    for ozgarish, tavsif in stsenariylar:
        yangi = keyingi_versiya(versiya, ozgarish)
        print(f"  {versiya:>6} -> {yangi:<6} {ozgarish:<6} {tavsif}")
        versiya = yangi
    print("  ⭐ Versiya = kod + ma'lumot + konfig; manifest ularni bog'laydi")


if __name__ == "__main__":
    main()

=== 1. Ma'lumot xeshi ===
  asl ma'lumot:                  390d116cced9
  qayta generatsiya:             390d116cced9  teng: True
  qatorlar aralashgan, xom:      7e81c712e469
  qatorlar aralashgan, kanonik:  390d116cced9  teng: True
  bitta qiymat +0.01:            e9a117d03277  teng: False

=== 2. Manifest: uchlik bitta joyda ===
  model          mijoz_ketishi
  versiya        1.0.0
  malumot_xeshi  390d116cced9
  qatorlar       3000
  kod_versiyasi  2a9d7b89de90
  konfig         {'C': 1.0, 'seed': 7}
  konfig_xeshi   df1e7446ded1
  model_xeshi    23453b260206
  metrikalar     {'auc': 0.7721}

=== 3. Manifestdan qayta qurish ===
  ma'lumot xeshi mos: True
  kod versiyasi mos:  True
  konfig xeshi mos:   True
  model xeshi mos:    True
  bashoratlar max farqi: 0.0e+00

=== 4. Qaysi o'zgarish qaysi xeshni o'zgartiradi ===
  o'zgarish              malumot   kod       konfig    model
  hech narsa             -         -         -         -
  yangi ma'lumot (3500)  o'zgardi  -         -         o'zgardi
  konfig: C=0.1          -         -         o'zgardi  o'zgardi
  kod: class_weight      -         o'zgardi  -         o'zgardi

=== 5. Semantik versiya ===
   1.0.0 -> 1.1.0  MINOR  yangi oy ma'lumoti bilan qayta o'qitish
   1.1.0 -> 1.1.1  PATCH  model kartasidagi imlo tuzatildi
   1.1.1 -> 1.2.0  MINOR  C giperparametri o'zgardi
   1.2.0 -> 2.0.0  MAJOR  yangi MAJBURIY kirish ustuni: hudud
   2.0.0 -> 2.0.1  PATCH  paket metadata si tuzatildi
   2.0.1 -> 3.0.0  MAJOR  chiqish: ehtimol o'rniga sinf
  ⭐ Versiya = kod + ma'lumot + konfig; manifest ularni bog'laydi

"""sqlite ustida model registr: versiyalar, bosqichlar, lineage, audit."""

import json
import sqlite3
import tempfile
from pathlib import Path

RUXSAT = {
    ("None", "Staging"), ("None", "Archived"),
    ("Staging", "Production"), ("Staging", "Archived"),
    ("Production", "Archived"), ("Archived", "Staging"),
}

SXEMA = """
CREATE TABLE IF NOT EXISTS versiyalar (
    nom TEXT NOT NULL,
    versiya INTEGER NOT NULL,
    bosqich TEXT NOT NULL,
    metrikalar TEXT NOT NULL,
    malumot_xeshi TEXT NOT NULL,
    kod_versiyasi TEXT NOT NULL,
    run_id TEXT NOT NULL,
    PRIMARY KEY (nom, versiya)
);
CREATE TABLE IF NOT EXISTS audit (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    soat INTEGER NOT NULL,
    nom TEXT NOT NULL,
    versiya INTEGER NOT NULL,
    eski TEXT,
    yangi TEXT NOT NULL,
    kim TEXT NOT NULL,
    sabab TEXT NOT NULL
);
"""


class Registr:
    def __init__(self, yol):
        self.db = sqlite3.connect(yol)
        self.db.executescript(SXEMA)
        # virtual soat: haqiqiy vaqt o'rniga o'sib boruvchi hisoblagich
        self.soat = self.db.execute(
            "SELECT COALESCE(MAX(soat), 0) FROM audit").fetchone()[0]

    def _audit(self, nom, versiya, eski, yangi, kim, sabab):
        self.soat += 1
        self.db.execute(
            "INSERT INTO audit (soat, nom, versiya, eski, yangi, kim, sabab)"
            " VALUES (?, ?, ?, ?, ?, ?, ?)",
            (self.soat, nom, versiya, eski, yangi, kim, sabab))

    def royxatga_ol(self, nom, metrikalar, malumot_xeshi, kod_versiyasi,
                    run_id, kim):
        with self.db:
            versiya = self.db.execute(
                "SELECT COALESCE(MAX(versiya), 0) + 1 FROM versiyalar"
                " WHERE nom = ?", (nom,)).fetchone()[0]
            self.db.execute(
                "INSERT INTO versiyalar VALUES (?, ?, ?, ?, ?, ?, ?)",
                (nom, versiya, "None", json.dumps(metrikalar, sort_keys=True),
                 malumot_xeshi, kod_versiyasi, run_id))
            self._audit(nom, versiya, None, "None", kim, "ro'yxatga olindi")
        return versiya

    def bosqich(self, nom, versiya):
        return self.db.execute(
            "SELECT bosqich FROM versiyalar WHERE nom = ? AND versiya = ?",
            (nom, versiya)).fetchone()[0]

    def otkaz(self, nom, versiya, yangi, kim, sabab):
        eski = self.bosqich(nom, versiya)
        if (eski, yangi) not in RUXSAT:
            raise ValueError(f"ruxsat yo'q: {eski} -> {yangi}")
        with self.db:
            if yangi == "Production":
                joriylar = self.db.execute(
                    "SELECT versiya FROM versiyalar WHERE nom = ?"
                    " AND bosqich = 'Production'", (nom,)).fetchall()
                for (joriy,) in joriylar:
                    self.db.execute(
                        "UPDATE versiyalar SET bosqich = 'Archived'"
                        " WHERE nom = ? AND versiya = ?", (nom, joriy))
                    self._audit(nom, joriy, "Production", "Archived", kim,
                                f"v{versiya} bilan almashtirildi")
            self.db.execute(
                "UPDATE versiyalar SET bosqich = ? WHERE nom = ? AND versiya = ?",
                (yangi, nom, versiya))
            self._audit(nom, versiya, eski, yangi, kim, sabab)

    def jadval(self, nom):
        return self.db.execute(
            "SELECT versiya, bosqich, metrikalar, malumot_xeshi, run_id"
            " FROM versiyalar WHERE nom = ? ORDER BY versiya", (nom,)).fetchall()


def main() -> None:
    with tempfile.TemporaryDirectory() as papka:
        yol = Path(papka) / "registr.db"
        reg = Registr(yol)

        print("=== 1. Ro'yxatga olish ===")
        yozuvlar = [
            ({"auc": 0.781, "log_loss": 0.482}, "9f3e41c07b2a", "a1b2c3d",
             "run-0007"),
            ({"auc": 0.804, "log_loss": 0.463}, "4c7d20e9b815", "a1b2c3d",
             "run-0012"),
            ({"auc": 0.809, "log_loss": 0.458}, "4c7d20e9b815", "e5f6a7b",
             "run-0019"),
        ]
        for metrikalar, mx, kv, run in yozuvlar:
            v = reg.royxatga_ol("mijoz_ketishi", metrikalar, mx, kv, run, "ali")
            print(f"  v{v}: run {run}, ma'lumot {mx}, kod {kv}")

        print("\n=== 2. Bosqich o'tishlari ===")
        reg.otkaz("mijoz_ketishi", 1, "Staging", "ali", "sinov uchun")
        reg.otkaz("mijoz_ketishi", 1, "Production", "vali", "birinchi chiqish")
        reg.otkaz("mijoz_ketishi", 2, "Staging", "ali", "yangi ma'lumot")
        reg.otkaz("mijoz_ketishi", 2, "Production", "vali", "auc yaxshiroq")
        for v in (1, 2, 3):
            print(f"  v{v}: {reg.bosqich('mijoz_ketishi', v)}")

        print("\n=== 3. Taqiqlangan o'tish ===")
        for v, yangi in [(3, "Production"), (1, "Production")]:
            try:
                reg.otkaz("mijoz_ketishi", v, yangi, "shoshqaloq", "tezroq")
                print(f"  v{v} -> {yangi}: bajarildi (kutilmagan)")
            except ValueError as xato:
                print(f"  v{v} -> {yangi}: ValueError - {xato}")
        reg.otkaz("mijoz_ketishi", 3, "Staging", "ali", "kod yangilandi")

        print("\n=== 4. Diskdan qayta ochish ===")
        reg.db.close()
        reg2 = Registr(yol)
        for v, bosq, metr, mx, run in reg2.jadval("mijoz_ketishi"):
            auc = json.loads(metr)["auc"]
            print(f"  v{v:<2} {bosq:<11} auc {auc:.3f}  {mx}  {run}")
        prod_soni = reg2.db.execute(
            "SELECT COUNT(*) FROM versiyalar WHERE bosqich = 'Production'"
        ).fetchone()[0]
        print(f"  Production soni: {prod_soni} (invariant: 1 dan oshmaydi)")

        print("\n=== 5. Lineage so'rovlari ===")
        v, mx, kv, run = reg2.db.execute(
            "SELECT versiya, malumot_xeshi, kod_versiyasi, run_id"
            " FROM versiyalar WHERE nom = 'mijoz_ketishi'"
            " AND bosqich = 'Production'").fetchone()
        print(f"  Production: v{v}, ma'lumot {mx}, kod {kv}, run {run}")
        tasirlangan = reg2.db.execute(
            "SELECT versiya, bosqich FROM versiyalar WHERE malumot_xeshi = ?"
            " ORDER BY versiya", ("4c7d20e9b815",)).fetchall()
        print(f"  ma'lumot 4c7d20e9b815 da muammo -> ta'sirlangan: "
              f"{[f'v{a} ({b})' for a, b in tasirlangan]}")

        print("\n=== 6. Audit tarixi ===")
        for soat, v, eski, yangi, kim, sabab in reg2.db.execute(
                "SELECT soat, versiya, eski, yangi, kim, sabab FROM audit"
                " ORDER BY id"):
            print(f"  t={soat:<2} v{v} {str(eski):<10} -> {yangi:<10} "
                  f"{kim:<5} {sabab}")
        reg2.db.close()
        print("  ⭐ Qoidalar registr kodida; audit faqat qo'shiladi")


if __name__ == "__main__":
    main()

=== 1. Ro'yxatga olish ===
  v1: run run-0007, ma'lumot 9f3e41c07b2a, kod a1b2c3d
  v2: run run-0012, ma'lumot 4c7d20e9b815, kod a1b2c3d
  v3: run run-0019, ma'lumot 4c7d20e9b815, kod e5f6a7b

=== 2. Bosqich o'tishlari ===
  v1: Archived
  v2: Production
  v3: None

=== 3. Taqiqlangan o'tish ===
  v3 -> Production: ValueError - ruxsat yo'q: None -> Production
  v1 -> Production: ValueError - ruxsat yo'q: Archived -> Production

=== 4. Diskdan qayta ochish ===
  v1  Archived    auc 0.781  9f3e41c07b2a  run-0007
  v2  Production  auc 0.804  4c7d20e9b815  run-0012
  v3  Staging     auc 0.809  4c7d20e9b815  run-0019
  Production soni: 1 (invariant: 1 dan oshmaydi)

=== 5. Lineage so'rovlari ===
  Production: v2, ma'lumot 4c7d20e9b815, kod a1b2c3d, run run-0012
  ma'lumot 4c7d20e9b815 da muammo -> ta'sirlangan: ['v2 (Production)', 'v3 (Staging)']

=== 6. Audit tarixi ===
  t=1  v1 None       -> None       ali   ro'yxatga olindi
  t=2  v2 None       -> None       ali   ro'yxatga olindi
  t=3  v3 None       -> None       ali   ro'yxatga olindi
  t=4  v1 None       -> Staging    ali   sinov uchun
  t=5  v1 Staging    -> Production vali  birinchi chiqish
  t=6  v2 None       -> Staging    ali   yangi ma'lumot
  t=7  v1 Production -> Archived   vali  v2 bilan almashtirildi
  t=8  v2 Staging    -> Production vali  auc yaxshiroq
  t=9  v3 None       -> Staging    ali   kod yangilandi
  ⭐ Qoidalar registr kodida; audit faqat qo'shiladi

"""Production darvozasi (juftlashgan taqqoslash), rollback va audit."""

import sqlite3

import numpy as np
import pandas as pd
from sklearn.ensemble import HistGradientBoostingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import roc_auc_score
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler

USTUNLAR = ["oylar", "tolov", "shikoyat", "oylik_tarif"]


def malumot(n, seed):
    rng = np.random.default_rng(seed)
    df = pd.DataFrame({
        "oylar": rng.integers(1, 72, n),
        "tolov": rng.normal(60, 20, n).clip(10, 150),
        "shikoyat": rng.poisson(0.8, n),
        "oylik_tarif": (rng.random(n) < 0.55).astype(int),
    })
    yangi_qimmat = (df["tolov"] > 75) & (df["oylar"] < 18)
    norozi_oylik = (df["shikoyat"] >= 3) & (df["oylik_tarif"] == 1)
    logit = (-1.5 - 0.02 * df["oylar"] + 0.5 * df["shikoyat"]
             + 1.0 * df["oylik_tarif"] + 3.0 * yangi_qimmat
             + 1.5 * norozi_oylik)
    df["ketdi"] = (rng.random(n) < 1 / (1 + np.exp(-logit))).astype(int)
    return df


def log_loss_har(y, p):
    p = np.clip(p, 1e-6, 1 - 1e-6)
    return -(y * np.log(p) + (1 - y) * np.log(1 - p))


def darvoza_yasa(X, y, min_auc):
    """Chegaralar natijadan OLDIN belgilanadi."""
    def darvoza(nomzod, prod):
        p = nomzod.predict_proba(X)[:, 1]
        auc = roc_auc_score(y, p)
        if auc < min_auc:
            return False, f"AUC {auc:.4f} < {min_auc}"
        if prod is None:
            return True, f"AUC {auc:.4f} >= {min_auc}, Production yo'q"
        d = log_loss_har(y, p) - log_loss_har(y, prod.predict_proba(X)[:, 1])
        ort, se = d.mean(), d.std(ddof=1) / np.sqrt(len(d))
        if ort > 2 * se:
            return False, f"log loss farqi {ort:+.4f} > 2*SE {2 * se:.4f}"
        return True, f"AUC {auc:.4f}, log loss farqi {ort:+.4f} (2*SE {2 * se:.4f})"
    return darvoza


class Registr:
    def __init__(self, darvoza):
        self.db = sqlite3.connect(":memory:")
        self.db.executescript(
            "CREATE TABLE versiyalar (nom TEXT, versiya INT, bosqich TEXT,"
            " izoh TEXT, PRIMARY KEY (nom, versiya));"
            "CREATE TABLE audit (id INTEGER PRIMARY KEY AUTOINCREMENT,"
            " soat INT, nom TEXT, versiya INT, eski TEXT, yangi TEXT,"
            " kim TEXT, sabab TEXT);")
        self.soat = 0
        self.artefakt = {}          # haqiqiyda: fayl ombori (4-misol)
        self.darvoza = darvoza

    def _audit(self, nom, v, eski, yangi, kim, sabab):
        self.soat += 1
        self.db.execute("INSERT INTO audit (soat, nom, versiya, eski, yangi,"
                        " kim, sabab) VALUES (?, ?, ?, ?, ?, ?, ?)",
                        (self.soat, nom, v, eski, yangi, kim, sabab))

    def _qoy(self, nom, v, yangi, kim, sabab):
        eski = self.bosqich(nom, v)
        self.db.execute("UPDATE versiyalar SET bosqich = ? WHERE nom = ?"
                        " AND versiya = ?", (yangi, nom, v))
        self._audit(nom, v, eski, yangi, kim, sabab)

    def bosqich(self, nom, v):
        return self.db.execute("SELECT bosqich FROM versiyalar WHERE nom = ?"
                               " AND versiya = ?", (nom, v)).fetchone()[0]

    def production(self, nom):
        r = self.db.execute("SELECT versiya FROM versiyalar WHERE nom = ?"
                            " AND bosqich = 'Production'", (nom,)).fetchone()
        return r[0] if r else None

    def royxatga_ol(self, nom, model, izoh, kim):
        with self.db:
            v = self.db.execute("SELECT COALESCE(MAX(versiya), 0) + 1 FROM"
                                " versiyalar WHERE nom = ?", (nom,)).fetchone()[0]
            self.db.execute("INSERT INTO versiyalar VALUES (?, ?, 'None', ?)",
                            (nom, v, izoh))
            self._audit(nom, v, None, "None", kim, izoh)
            self._qoy(nom, v, "Staging", kim, "sinovga")
        self.artefakt[(nom, v)] = model
        return v

    def kotar(self, nom, v, kim):
        joriy = self.production(nom)
        otdi, hisobot = self.darvoza(self.artefakt[(nom, v)],
                                     self.artefakt.get((nom, joriy)))
        with self.db:
            if not otdi:
                self._qoy(nom, v, "Archived", kim, "darvoza RAD: " + hisobot)
                return False, hisobot
            if joriy is not None:
                self._qoy(nom, joriy, "Archived", kim, f"v{v} bilan almashdi")
            self._qoy(nom, v, "Production", kim, "darvoza: " + hisobot)
        return True, hisobot

    def rollback(self, nom, kim, sabab):
        joriy = self.production(nom)
        r = self.db.execute(
            "SELECT versiya FROM audit WHERE nom = ? AND eski = 'Production'"
            " AND yangi = 'Archived' AND versiya != ? ORDER BY id DESC LIMIT 1",
            (nom, joriy)).fetchone()
        if r is None:
            raise RuntimeError("qaytish uchun oldingi Production yo'q")
        with self.db:                       # ikkala qadam - bitta tranzaksiya
            self._qoy(nom, joriy, "Archived", kim, "rollback: " + sabab)
            self._qoy(nom, r[0], "Production", kim, f"rollback: v{joriy} dan")
        return r[0]


def main() -> None:
    orgatish = malumot(4000, seed=1)
    val = malumot(3000, seed=2)
    Xo, yo = orgatish[USTUNLAR], orgatish["ketdi"]
    Xv, yv = val[USTUNLAR], val["ketdi"]

    buzilgan = orgatish.copy()
    buzilgan["oylar"] = buzilgan["oylar"].sample(
        frac=1.0, random_state=3).to_numpy()        # noto'g'ri join
    yangi = malumot(4000, seed=4)                   # keyingi oy ma'lumoti
    nomzodlar = {
        "logistik": make_pipeline(StandardScaler(),
                                  LogisticRegression()).fit(Xo, yo),
        "gradient boosting": HistGradientBoostingClassifier(
            max_iter=100, learning_rate=0.05, max_depth=3,
            random_state=0).fit(Xo, yo),
        "logistik (buzilgan join)": make_pipeline(
            StandardScaler(), LogisticRegression()).fit(buzilgan[USTUNLAR],
                                                        buzilgan["ketdi"]),
        "logistik (yangi oy)": make_pipeline(
            StandardScaler(), LogisticRegression()).fit(yangi[USTUNLAR],
                                                        yangi["ketdi"]),
    }

    print("=== 1. Nomzodlar validatsiyada ===")
    for nom, m in nomzodlar.items():
        p = m.predict_proba(Xv)[:, 1]
        print(f"  {nom:<26} AUC {roc_auc_score(yv, p):.4f}  "
              f"log loss {log_loss_har(yv.to_numpy(), p).mean():.4f}")

    reg = Registr(darvoza_yasa(Xv, yv.to_numpy(), min_auc=0.70))
    nom = "mijoz_ketishi"

    print("\n=== 2. Darvoza orqali chiqarish ===")
    for model_nomi, m in nomzodlar.items():
        v = reg.royxatga_ol(nom, m, model_nomi, "ali")
        otdi, hisobot = reg.kotar(nom, v, "ci")
        print(f"  v{v} {model_nomi:<26} {'OTDI' if otdi else 'RAD '}  {hisobot}")
    print(f"  hozirgi Production: v{reg.production(nom)}")

    print("\n=== 3. Incident va orqaga qaytarish ===")
    print(f"  v{reg.production(nom)} da muammo: yangi segmentda shikoyatlar")
    qaytgan = reg.rollback(nom, "navbatchi", "segment xatosi, tahlil kerak")
    print(f"  rollback -> v{qaytgan}, hozirgi Production: v{reg.production(nom)}")
    print(f"  qayta o'qitish kerak bo'ldimi: yo'q (artefakt registrda edi)")

    print("\n=== 4. Registr holati ===")
    for v, bosq, izoh in reg.db.execute(
            "SELECT versiya, bosqich, izoh FROM versiyalar ORDER BY versiya"):
        print(f"  v{v} {bosq:<11} {izoh}")

    print("\n=== 5. Audit tarixi ===")
    for soat, v, eski, yangi, kim, sabab in reg.db.execute(
            "SELECT soat, versiya, eski, yangi, kim, sabab FROM audit"
            " ORDER BY id"):
        print(f"  t={soat:<2} v{v} {str(eski):<10} -> {yangi:<10} {kim:<9} "
              f"{sabab[:44]}")

    print("\n=== 6. 'Soat t da qaysi versiya prodda edi?' ===")
    for soat in (4, 8, 15):
        r = reg.db.execute(
            "SELECT versiya FROM audit WHERE yangi = 'Production'"
            " AND soat <= ? ORDER BY soat DESC LIMIT 1", (soat,)).fetchone()
        print(f"  t={soat:<2} -> v{r[0]}")
    print("  javob auditdan, bitta so'rov bilan")
    print("  ⭐ Darvoza regressiyani to'xtatadi, rollback - bir qadam")


if __name__ == "__main__":
    main()

=== 1. Nomzodlar validatsiyada ===
  logistik                   AUC 0.7334  log loss 0.5269
  gradient boosting          AUC 0.7568  log loss 0.5003
  logistik (buzilgan join)   AUC 0.6654  log loss 0.5623
  logistik (yangi oy)        AUC 0.7332  log loss 0.5265

=== 2. Darvoza orqali chiqarish ===
  v1 logistik                   OTDI  AUC 0.7334 >= 0.7, Production yo'q
  v2 gradient boosting          OTDI  AUC 0.7568, log loss farqi -0.0265 (2*SE 0.0080)
  v3 logistik (buzilgan join)   RAD   AUC 0.6654 < 0.7
  v4 logistik (yangi oy)        RAD   log loss farqi +0.0262 > 2*SE 0.0080
  hozirgi Production: v2

=== 3. Incident va orqaga qaytarish ===
  v2 da muammo: yangi segmentda shikoyatlar
  rollback -> v1, hozirgi Production: v1
  qayta o'qitish kerak bo'ldimi: yo'q (artefakt registrda edi)

=== 4. Registr holati ===
  v1 Production  logistik
  v2 Archived    gradient boosting
  v3 Archived    logistik (buzilgan join)
  v4 Archived    logistik (yangi oy)

=== 5. Audit tarixi ===
  t=1  v1 None       -> None       ali       logistik
  t=2  v1 None       -> Staging    ali       sinovga
  t=3  v1 Staging    -> Production ci        darvoza: AUC 0.7334 >= 0.7, Production yo'q
  t=4  v2 None       -> None       ali       gradient boosting
  t=5  v2 None       -> Staging    ali       sinovga
  t=6  v1 Production -> Archived   ci        v2 bilan almashdi
  t=7  v2 Staging    -> Production ci        darvoza: AUC 0.7568, log loss farqi -0.0265
  t=8  v3 None       -> None       ali       logistik (buzilgan join)
  t=9  v3 None       -> Staging    ali       sinovga
  t=10 v3 Staging    -> Archived   ci        darvoza RAD: AUC 0.6654 < 0.7
  t=11 v4 None       -> None       ali       logistik (yangi oy)
  t=12 v4 None       -> Staging    ali       sinovga
  t=13 v4 Staging    -> Archived   ci        darvoza RAD: log loss farqi +0.0262 > 2*SE 0
  t=14 v2 Production -> Archived   navbatchi rollback: segment xatosi, tahlil kerak
  t=15 v1 Archived   -> Production navbatchi rollback: v2 dan

=== 6. 'Soat t da qaysi versiya prodda edi?' ===
  t=4  -> v1
  t=8  -> v2
  t=15 -> v1
  javob auditdan, bitta so'rov bilan
  ⭐ Darvoza regressiyani to'xtatadi, rollback - bir qadam

"""Fayl xeshi -> ombor manzili: add, dedup, checkout, butunlik, gc."""

import hashlib
import tempfile
from pathlib import Path

import numpy as np
import pandas as pd
import yaml


class Ombor:
    def __init__(self, ildiz):
        self.ildiz = ildiz

    def _yol(self, xesh):
        return self.ildiz / xesh[:2] / xesh[2:]

    def qosh(self, fayl):
        """dvc add: faylni omborga, yoniga .dvc ko'rsatkich."""
        baytlar = fayl.read_bytes()
        xesh = hashlib.sha256(baytlar).hexdigest()
        yol = self._yol(xesh)
        yangi = not yol.exists()
        if yangi:
            yol.parent.mkdir(parents=True, exist_ok=True)
            yol.write_bytes(baytlar)
        korsatkich = {"outs": [{"path": fayl.name, "sha256": xesh,
                                "size": len(baytlar)}]}
        matn = yaml.safe_dump(korsatkich, sort_keys=False)
        (fayl.parent / (fayl.name + ".dvc")).write_text(matn, encoding="utf-8")
        return matn, yangi

    def chiqar(self, korsatkich_matni, papka):
        """dvc checkout: ko'rsatkich bo'yicha faylni tiklash (tekshirib)."""
        chiqish = yaml.safe_load(korsatkich_matni)["outs"][0]
        baytlar = self._yol(chiqish["sha256"]).read_bytes()
        if hashlib.sha256(baytlar).hexdigest() != chiqish["sha256"]:
            raise ValueError("ombordagi obyekt buzilgan")
        (papka / chiqish["path"]).write_bytes(baytlar)
        return chiqish["path"]

    def obyektlar(self):
        return sorted(p for p in self.ildiz.rglob("*") if p.is_file())

    def tekshir(self):
        buzilgan = []
        for p in self.obyektlar():
            kutilgan = p.parent.name + p.name
            if hashlib.sha256(p.read_bytes()).hexdigest() != kutilgan:
                buzilgan.append(kutilgan[:12])
        return buzilgan

    def gc(self, korsatkichlar):
        kerak = {yaml.safe_load(k)["outs"][0]["sha256"] for k in korsatkichlar}
        ochirildi = 0
        for p in self.obyektlar():
            if p.parent.name + p.name not in kerak:
                p.unlink()
                ochirildi += 1
        return ochirildi


def malumot(n, seed):
    rng = np.random.default_rng(seed)
    return pd.DataFrame({
        "mijoz_id": np.arange(n),
        "oylar": rng.integers(1, 72, n),
        "tolov": rng.normal(60, 20, n).round(2),
        "ketdi": rng.integers(0, 2, n),
    })


def holat(ombor):
    obyektlar = ombor.obyektlar()
    return len(obyektlar), sum(p.stat().st_size for p in obyektlar)


def main() -> None:
    with tempfile.TemporaryDirectory() as t:
        ish = Path(t) / "ish"
        ish.mkdir()
        ombor = Ombor(Path(t) / "ombor")
        fayl = ish / "mijozlar.csv"
        git_tarixi = []          # (commit xabari, ko'rsatkich matni)

        print("=== 1. dvc add: birinchi versiya ===")
        v1 = malumot(2000, seed=0)
        v1.to_csv(fayl, index=False, lineterminator="\n")
        matn, yangi = ombor.qosh(fayl)
        git_tarixi.append(("ma'lumot v1", matn))
        print("  mijozlar.csv.dvc:")
        for qator in matn.splitlines():
            if "sha256" in qator:
                qator = f"{qator[:22]}(+{len(qator) - 22} belgi)"
            print(f"    {qator}")
        n, hajm = holat(ombor)
        korsatkich_hajmi = (ish / "mijozlar.csv.dvc").stat().st_size
        print(f"  omborda: {n} obyekt, {hajm} bayt; git dagi ko'rsatkich: "
              f"{korsatkich_hajmi} bayt")

        print("\n=== 2. Dedup: bir xil mazmun - bitta obyekt ===")
        nusxa = ish / "mijozlar_nusxa.csv"
        nusxa.write_bytes(fayl.read_bytes())
        _, yangi = ombor.qosh(nusxa)
        print(f"  nusxa qo'shildi, yangi obyekt yaratildimi: {yangi}")
        print(f"  omborda: {holat(ombor)[0]} obyekt")
        nusxa.unlink()
        (ish / "mijozlar_nusxa.csv.dvc").unlink()

        print("\n=== 3. Ma'lumot o'zgardi: ikkinchi versiya ===")
        v2 = pd.concat([v1, malumot(500, seed=1).assign(
            mijoz_id=lambda d: d["mijoz_id"] + 2000)], ignore_index=True)
        v2.to_csv(fayl, index=False, lineterminator="\n")
        matn2, yangi = ombor.qosh(fayl)
        git_tarixi.append(("ma'lumot v2: +500 mijoz", matn2))
        n, hajm = holat(ombor)
        print(f"  yangi obyekt: {yangi}; omborda: {n} obyekt, {hajm} bayt")
        for xabar, k in git_tarixi:
            x = yaml.safe_load(k)["outs"][0]
            print(f"  commit '{xabar}': sha256 {x['sha256'][:12]}, "
                  f"{x['size']} bayt")

        print("\n=== 4. Checkout: v1 ga qaytish ===")
        ombor.chiqar(git_tarixi[0][1], ish)
        tiklangan = pd.read_csv(fayl)
        print(f"  ishchi fayl qatorlari: {len(tiklangan)}")
        print(f"  v1 bilan aynan teng: {tiklangan.equals(v1)}")
        ombor.chiqar(git_tarixi[1][1], ish)
        print(f"  yana v2 ga: {len(pd.read_csv(fayl))} qator")

        print("\n=== 5. gc: ishora qilinmagan obyektlar ===")
        (ish / "sinov.csv").write_text("a,b\n1,2\n", encoding="utf-8")
        ombor.qosh(ish / "sinov.csv")          # commit qilinmagan tajriba
        print(f"  gc dan oldin: {holat(ombor)[0]} obyekt")
        ochdi = ombor.gc([k for _, k in git_tarixi])
        print(f"  o'chirildi: {ochdi}; qoldi: {holat(ombor)[0]} obyekt")

        print("\n=== 6. Butunlik tekshiruvi ===")
        print(f"  buzilgan obyektlar: {ombor.tekshir()}")
        birinchi = ombor.obyektlar()[0]
        baytlar = bytearray(birinchi.read_bytes())
        baytlar[100] ^= 1                       # bitta bit o'zgardi
        birinchi.write_bytes(bytes(baytlar))
        print(f"  bitta bit o'zgargandan keyin: {ombor.tekshir()}")
        buzilgan_xesh = birinchi.parent.name + birinchi.name
        for xabar, k in git_tarixi:
            if yaml.safe_load(k)["outs"][0]["sha256"] == buzilgan_xesh:
                try:
                    ombor.chiqar(k, ish)
                except ValueError as xato:
                    print(f"  checkout '{xabar}': ValueError - {xato}")
        print("  ⭐ Manzil = mazmun xeshi: dedup, tiklash va butunlik bepul")


if __name__ == "__main__":
    main()

=== 1. dvc add: birinchi versiya ===
  mijozlar.csv.dvc:
    outs:
    - path: mijozlar.csv
      sha256: 525cd44cd353(+52 belgi)
      size: 30524
  omborda: 1 obyekt, 30524 bayt; git dagi ko'rsatkich: 120 bayt

=== 2. Dedup: bir xil mazmun - bitta obyekt ===
  nusxa qo'shildi, yangi obyekt yaratildimi: False
  omborda: 1 obyekt

=== 3. Ma'lumot o'zgardi: ikkinchi versiya ===
  yangi obyekt: True; omborda: 2 obyekt, 68945 bayt
  commit 'ma'lumot v1': sha256 525cd44cd353, 30524 bayt
  commit 'ma'lumot v2: +500 mijoz': sha256 90707916b0aa, 38421 bayt

=== 4. Checkout: v1 ga qaytish ===
  ishchi fayl qatorlari: 2000
  v1 bilan aynan teng: True
  yana v2 ga: 2500 qator

=== 5. gc: ishora qilinmagan obyektlar ===
  gc dan oldin: 3 obyekt
  o'chirildi: 1; qoldi: 2 obyekt

=== 6. Butunlik tekshiruvi ===
  buzilgan obyektlar: []
  bitta bit o'zgargandan keyin: ['525cd44cd353']
  checkout 'ma'lumot v1': ValueError - ombordagi obyekt buzilgan
  ⭐ Manzil = mazmun xeshi: dedup, tiklash va butunlik bepul

joblib.dump(model, "modellar/model_final.pkl")                     # ⚠️
joblib.dump(model, f"modellar/{nom}/{versiya}/model.joblib")       # ✅ + registr

manifest = {"malumot": "data/iyun.csv"}                            # ⚠️
manifest = {"malumot": "data/iyun.csv",
            "malumot_xeshi": malumot_xeshi(df)}                    # ✅

kod_versiyasi = "main"                                             # ⚠️ o'zgaradi
kod_versiyasi = git_commit + ("-dirty" if ozgargan_fayllar else "")  # ✅

reg.otkaz(nom, v, "Production", kim, "shoshilinch")                # ⚠️ None -> Production
reg.otkaz(nom, v, "Staging", kim, "sinov"); reg.kotar(nom, v, kim)  # ✅ darvoza orqali

otdi = auc_nomzod > auc_prod                                       # ⚠️ shovqin
d = ll_nomzod - ll_prod; otdi = d.mean() <= 2 * d.std(ddof=1) / np.sqrt(len(d))  # ✅

model = orgat(eski_malumot, eski_konfig)                           # ⚠️ soatlar, boshqa natija
reg.rollback(nom, "navbatchi", "incident #123")                    # ✅ soniyalar, aynan o'sha

db.execute("DELETE FROM audit WHERE kim = 'men'")                  # ⚠️
# audit faqat INSERT; tuzatish - yangi yozuv bilan                  # ✅

1.  # model versiyasining uchligi nimalardan iborat?
2.  # qatorlar aralashtirilsa, xom xesh o'zgaradimi? kanonik-chi?
3.  # yangi majburiy kirish ustuni - qaysi semver qismi?
4.  # yangi ma'lumot bilan qayta o'qitish - qaysi qismi?
5.  # model kartasidagi imlo tuzatilsa?
6.  # None -> Production ruxsatmi?
7.  # yangi versiya Production ga chiqsa, eskisi nima bo'ladi?
8.  # darvozaning ikki sharti?
9.  # nega darvozada juftlashgan farq?
10. # rollback nega tez?
11. # DVC da git nimani saqlaydi?
12. # bir xil fayl ikki marta qo'shilsa, omborda nechta obyekt?

1.  joblib.dump(model, "model_final.pkl")

2.  manifest = {"malumot": "data/iyun.csv"}

3.  reg.otkaz("churn", 5, "Production", "men", "tez kerak")

4.  otdi = auc_yangi > auc_eski

5.  db.execute("DELETE FROM audit WHERE versiya = 3")