finalize_release.py

#!/usr/bin/env python3
"""Reconcile exact source counts, global keys, and every remote bundle hash."""
import argparse
import json
import sqlite3
from collections import Counter
from datetime import datetime, timezone
from pathlib import Path

from huggingface_hub import HfApi, CommitOperationAdd, get_token

from convert_release import RECIPES, readme, status_document


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--dataset", choices=list(RECIPES), required=True)
    parser.add_argument(
        "--root", type=Path, default=Path("/root/bagpiper-sft-conversion/releases")
    )
    args = parser.parse_args()
    recipe = RECIPES[args.dataset]
    root = args.root / args.dataset
    pinned = json.loads((root / "SOURCE_MANIFEST.json").read_text())
    inventory = pinned["shards"]
    connection = sqlite3.connect(root / "conversion.sqlite3")
    records = [
        json.loads(x[0])
        for x in connection.execute(
            "SELECT record FROM shards WHERE uploaded=1 ORDER BY path"
        )
    ]
    connection.close()
    by_path = {r["source_path"]: r for r in records}
    assert (
        len(by_path) == len(records) == len(inventory)
    ), "Missing/duplicate source shards"
    assert set(by_path) == {item["path"] for item in inventory}
    for item in inventory:
        r = by_path[item["path"]]
        assert r["rows"] == item["rows"] and r["source_sha256"] == item["sha256"]
        assert r["partition"] == item["partition"]
        assert r["source_bytes"] == item["parquet_bytes"]
    assert sum(r["rows"] for r in records) == sum(r["rows"] for r in inventory)
    global_db = root / "global-validation.sqlite3"
    target = sqlite3.connect(global_db)
    target.execute("DROP TABLE IF EXISTS ids")
    target.execute("DROP TABLE IF EXISTS audio")
    target.execute("CREATE TABLE ids (row_id TEXT PRIMARY KEY,partition TEXT)")
    target.execute(
        "CREATE TABLE audio (partition TEXT,sha TEXT,suffix TEXT,size INTEGER,PRIMARY KEY(partition,sha))"
    )
    state_files = []
    if (root / "STREAM_PLAN.json").exists():
        state_files = [
            root / f"conversion-{s['stream_id']}.sqlite3"
            for s in json.loads((root / "STREAM_PLAN.json").read_text())
        ]
    else:
        state_files = list(root.glob("conversion-*.sqlite3"))
    for source in state_files:
        assert source.exists(), f"Missing conversion state: {source}"
        target.execute("ATTACH DATABASE ? AS source", (str(source),))
        assert not target.execute(
            "SELECT 1 FROM source.rows s JOIN ids i USING(row_id) "
            "WHERE s.partition != i.partition LIMIT 1"
        ).fetchone(), f"Conflicting row provenance: {source}"
        assert not target.execute(
            "SELECT 1 FROM source.audio s JOIN audio a USING(partition,sha) "
            "WHERE s.suffix != a.suffix OR s.size != a.size LIMIT 1"
        ).fetchone(), f"Conflicting audio filename/size across streams: {source}"
        for path, record in target.execute("SELECT path,record FROM source.shards"):
            assert (
                path in by_path and json.loads(record) == by_path[path]
            ), f"Conflicting source shard state: {source}:{path}"
        target.execute(
            "INSERT OR IGNORE INTO ids SELECT row_id,partition FROM source.rows"
        )
        target.execute(
            "INSERT OR IGNORE INTO audio SELECT partition,sha,suffix,size FROM source.audio"
        )
        target.commit()
        target.execute("DETACH DATABASE source")
    unique_ids = target.execute("SELECT count(*) FROM ids").fetchone()[0]
    assert unique_ids == sum(
        r["rows"] for r in records
    ), "Duplicate/missing global row IDs"
    expected_partitions = Counter()
    for record in inventory:
        expected_partitions[record["partition"]] += record["rows"]
    assert dict(
        target.execute("SELECT partition,count(*) FROM ids GROUP BY partition")
    ) == dict(expected_partitions), "Per-partition row count mismatch"
    audio_count, audio_bytes = target.execute(
        "SELECT count(*),sum(size) FROM audio"
    ).fetchone()
    partitions = {
        p: {"rows": rows, "unique_audio": count, "audio_bytes": bytes_}
        for p, rows, count, bytes_ in target.execute(
            "SELECT i.partition,i.rows,a.count,a.bytes FROM (SELECT partition,count(*) rows FROM ids GROUP BY partition) i JOIN (SELECT partition,count(*) count,sum(size) bytes FROM audio GROUP BY partition) a USING(partition)"
        )
    }
    target.close()
    api = HfApi(token=get_token())
    revision = api.repo_info(recipe["target"], repo_type="dataset").sha
    files = list(
        api.list_repo_tree(
            recipe["target"], repo_type="dataset", revision=revision, recursive=True
        )
    )
    bundles = {
        f.path: f for f in files if hasattr(f, "size") and f.path.endswith(".tar.zst")
    }
    assert set(bundles) == {
        r["archive_path"] for r in records
    }, "Missing/extra remote archives"
    for r in records:
        f = bundles[r["archive_path"]]
        assert (
            f.size == r["archive_bytes"] and f.lfs.sha256 == r["archive_sha256"]
        ), f"Hash mismatch: {f.path}"
    audit = dict(
        state="passed",
        completed_at=datetime.now(timezone.utc).isoformat(),
        source_repository=recipe["source"],
        source_revision=pinned["revision"],
        verified_remote_revision=revision,
        source_shards=len(inventory),
        verified_archive_files=len(bundles),
        source_rows=sum(x["rows"] for x in inventory),
        unique_row_ids=unique_ids,
        unique_audio_files=audio_count,
        unique_audio_bytes=audio_bytes,
        partition_statistics=partitions,
        audio_bytes_preserved=True,
        text_and_role_order_preserved=True,
        checks=[
            "All source shard paths/counts/SHA256 match pinned inventory",
            "All global row IDs reconciled across workers",
            "Per-partition row counts match the source; repeated hashes have consistent filenames/sizes across streams",
            "All remote archive sizes and LFS SHA256 match conversion records",
            "Original embedded audio SHA256 checked for every converted row; repeated hashes reuse prior validated audio",
        ],
        limitations=[
            "No full GPU training or inference validation",
            "Per-shard integrity plus source/audio hashes; remote archives are verified by LFS hash, not all redownloaded",
            "Dataset terms and paper-v1/v2 selection unchanged",
        ],
    )
    audit_file = root / "RELEASE_VALIDATION.json"
    audit_file.write_text(json.dumps(audit, indent=2) + "\n")
    status = status_document(recipe, pinned["revision"], inventory, records, "complete")
    status["unique_audio_files"] = audio_count
    status["unique_audio_bytes"] = audio_bytes
    status["unique_audio_count_scope"] = "partition_and_sha256"
    status["archive_audio_entries"] = sum(r["unique_audio_added"] for r in records)
    status["archive_audio_bytes"] = sum(r["unique_audio_bytes_added"] for r in records)
    status["validation"] = "RELEASE_VALIDATION.json"
    (root / "STATUS.json").write_text(json.dumps(status, indent=2) + "\n")
    card = readme(recipe, pinned["revision"])
    if args.dataset == "general":
        card = card.replace(
            "\nEach `.tar.zst`",
            "\n**Source selection:** this preserves the public recipe-v1 pool (including "
            "1,193,006 understanding rows). It does not reconstruct the paper-v2 filtered selection.\n\nEach `.tar.zst`",
            1,
        )
    card = card.replace(
        "**Check `STATUS.json`: the release is usable in full only when `state` is `complete`.** An explicit prefix trial is possible while conversion is in progress.",
        f"**Complete:** all {unique_ids:,} source rows and {len(bundles):,} shards are converted and uploaded. "
        "[RELEASE_VALIDATION.json](./RELEASE_VALIDATION.json) records the full source/count/hash reconciliation.",
    )
    table = "\n## Verified release counts\n\n| Partition | Preserved rows | Distinct audio files |\n| --- | ---: | ---: |\n"
    for partition, stats in sorted(partitions.items()):
        table += f"| {partition} | {stats['rows']:,} | {stats['unique_audio']:,} |\n"
    table += (
        "\nDistinct audio counts use `(partition, SHA256)` after reconciling all conversion streams. "
        "Archives may contain repeated files across streams; verified extraction merges them. "
        "Every original training row remains present.\n\n"
        "[VALIDATION.json](./VALIDATION.json) covers 3,814 original-versus-converted sample rows "
        "across all eight partitions and 24 decoded waveform comparisons using the actual ESPnet reader. "
        "The full release additionally checks every input shard hash, every embedded audio hash, "
        "all row IDs, and every uploaded archive's size and LFS SHA256. GPU training and inference "
        "have not been validated. Use `prepare_espnet.py` for local paths and manifests; "
        "these bundles are not directly loadable with `datasets.load_dataset`.\n"
    )
    card = card.replace(
        "\n## Prepare local training inputs\n",
        table + "\n## Prepare local training inputs\n",
    )
    card = card.replace(
        "For a small prefix trial, add `--max-shards 2 --allow-incomplete`.",
        "For a small prefix trial, add `--max-shards 2`.",
    )
    (root / "README.md").write_text(card)
    operations = [
        CommitOperationAdd(path_in_repo=name, path_or_fileobj=root / name)
        for name in ["STATUS.json", "RELEASE_VALIDATION.json", "README.md"]
    ]
    if (root / "STREAM_PLAN.json").exists():
        operations.append(
            CommitOperationAdd(
                path_in_repo="STREAM_PLAN.json",
                path_or_fileobj=root / "STREAM_PLAN.json",
            )
        )
    for name in ["STREAM_PLAN.before-rebalance.json", "REBALANCE.json"]:
        if (root / name).exists():
            operations.append(
                CommitOperationAdd(path_in_repo=name, path_or_fileobj=root / name)
            )
    scripts = Path(__file__).resolve().parent
    for name in [
        "prepare_espnet.py",
        "convert_release.py",
        "finalize_release.py",
        "CONVERSION.md",
        "VALIDATION.json",
        "test_converter.py",
        "validate_public_release.py",
        "PUBLIC_DOWNLOAD_VALIDATION.json",
        "rebalance_streams.py",
        "link_source_release.py",
        "commit_staged_release.py",
        "recipe-preparation.patch",
    ]:
        operations.append(
            CommitOperationAdd(path_in_repo=name, path_or_fileobj=scripts / name)
        )
    commit = api.create_commit(
        recipe["target"],
        repo_type="dataset",
        operations=operations,
        commit_message=f"Finalize verified ESPnet release: {unique_ids} unique rows, {len(bundles)} archives",
    )
    print(json.dumps(dict(**audit, final_commit=commit.oid), indent=2))


if __name__ == "__main__":
    main()