Publish completed release report, anonymous preparation checks, and tested recovery tools

COMPLETED_PUBLIC_PREPARATION.json

@@ -0,0 +1,16 @@
+[
+  {
+    "repo": "espnet/Bagpiper_SFT_Data_ESPnet",
+    "revision": "4a258e780a1697be5b6476a14edd7c257d8df350",
+    "downloaded_helper": true,
+    "anonymous": true,
+    "completed_release_preparation": true
+  },
+  {
+    "repo": "espnet/Bagpiper_TTS_SFT_Data_ESPnet",
+    "revision": "821f04a8a4a6f4aaccc74ef7d7d39d54bc12d759",
+    "downloaded_helper": true,
+    "anonymous": true,
+    "completed_release_preparation": true
+  }
+]

CONVERSION.md

@@ -26,3 +26,17 @@ Download preparation is portable and independent of that audit workspace. Run pr
 No audio resampling, PCM conversion or lossy recompression occurs. This format conversion does not change source dataset licenses, original source selection or paper-v1/v2 alignment.
 
 Use a separate `--work-root` for a new conversion and the same directory when resuming. The finalizer also accepts `--root` pointing to that work directory. The production general-SFT run started with six fixed source ranges per partition. After completing about half the conversion, unconverted work was split into smaller ranges while copying each parent stream's validated audio and ID state. STREAM_PLAN.json records the active ranges; STREAM_PLAN.before-rebalance.json and REBALANCE.json document the transition. Rebalancing was performed with production workers stopped, and every source shard belongs to exactly one active range. Independent ranges can repeat an audio file in multiple archives; extraction verifies and merges identical content. Per-archive unique_audio_added counts are stream-local and must not be summed as the final count of distinct audio files. Final validation separately computes global unique IDs/audio hashes. Incomplete trials are restricted to contiguous uploaded prefixes.
+
+## Large-release Hub publication
+
+The full general release exceeded the Hub's hourly repository-commit allowance with small archive batches. Continue converting/preuploading without repository commits, then run the batch publisher in another terminal:
+
+```bash
+python convert_release.py --upload --dataset general --partition-parallel --lanes 6 --batch-shards 24 --download-workers 3 --defer-commit
+HF_HUB_DISABLE_XET=1 python commit_staged_release.py --dataset general --batch-shards 256 --interval 60
+python finalize_release.py --dataset general
+```
+
+The staging command does not mark blobs as publicly uploaded and never deletes its archives. `preuploads.sqlite3` checkpoints storage preuploads. The batch publisher uses standard LFS existence checks for the already-preuploaded Xet blobs, commits up to 256 files plus aggregate status, verifies remote archive sizes and SHA256, and respects server rate limits. This avoids repeating expensive Xet chunk processing during the commit step. Both processes use the same work directory. Finalize only after both finish; finalization checks every source row and remote archive before declaring a complete release. Once the workers finish and every archive has been verified on the Hub, local pending archives can be removed.
+
+Seven regression tests cover cross-shard deduplication, transactional rollback, parallel resume, parent audio references after rebalancing, commit/verification/status retries, and staging without premature uploaded flags. Public-download validation compares 5,932 rows and 12 decoded waveforms with pinned originals; these checks supplement the eight-partition sample validation and full inventory/hash reconciliation.

FINAL_REPORT.json

@@ -0,0 +1,44 @@
+{
+  "state": "complete",
+  "completed_at": "2026-10-01T01:31:49.992586+00:00",
+  "releases": [
+    {
+      "repository": "espnet/Bagpiper_SFT_Data_ESPnet",
+      "rows": 2667017,
+      "shards": 6804,
+      "archive_bytes": 719295381339,
+      "unique_audio_files": 1313767,
+      "unique_audio_scope": "partition_and_sha256",
+      "source_revision": "7dec4d68dc30e442368914619668fcd695a897f7",
+      "verified_archives_revision": "ddc7d626fecf295a0cc6c71d0515aa2e8bd2a0bf"
+    },
+    {
+      "repository": "espnet/Bagpiper_TTS_SFT_Data_ESPnet",
+      "rows": 738123,
+      "shards": 1151,
+      "archive_bytes": 252559973183,
+      "unique_audio_files": 734969,
+      "unique_audio_scope": "partition_and_sha256",
+      "source_revision": "f0eb112765d33f30ff6136a6fa5feaa84ca79880",
+      "verified_archives_revision": "589d441d96e842087a64e6f3a120e4bc78130e16"
+    }
+  ],
+  "validation": {
+    "source_and_remote_hashes": "all shards and archives verified",
+    "public_download_rows_compared": 5932,
+    "public_decoded_waveforms_compared": 12,
+    "all_partition_sample_rows_compared": 3814,
+    "all_partition_decoded_waveforms_compared": 24,
+    "converter_regression_tests_passed": 7,
+    "published_helpers_anonymously_downloaded_and_prepared": true,
+    "gpu_training_or_inference_validated": false
+  },
+  "preservation": {
+    "all_source_rows": true,
+    "original_audio_bytes": true,
+    "text_and_role_order": true,
+    "source_provenance": true,
+    "original_repositories_retained": true
+  },
+  "general_source_selection": "public recipe-v1; paper-v2 selection unchanged"
+}

FINAL_REPORT.md

@@ -0,0 +1,16 @@
+# Completed Bagpiper SFT format conversion
+
+Both original SFT datasets are fully converted and publicly uploaded in portable lossless ESPnet dialogue format.
+
+| Release | Preserved rows | Verified archives | Converted archive bytes |
+| --- | ---: | ---: | ---: |
+| [Bagpiper SFT](https://huggingface.co/datasets/espnet/Bagpiper_SFT_Data_ESPnet) | 2,667,017 | 6,804 | 719,295,381,339 |
+| [Bagpiper-TTS SFT](https://huggingface.co/datasets/espnet/Bagpiper_TTS_SFT_Data_ESPnet) | 738,123 | 1,151 | 252,559,973,183 |
+
+See FINAL_REPORT.json and each release's RELEASE_VALIDATION.json for precise statistics and pinned source revisions. Original encoded audio bytes, all rows, ordered text and roles, and provenance are preserved. Duplicate audio storage is removed within conversion streams; extraction verifies and merges identical files across streams. Original source repositories remain available. Their data cards now link directly to the converted training format.
+
+The publicly downloaded preparation helper safely extracts audio, resolves local paths, checks global IDs and provenance linkage, and writes ESPnet all/train/valid manifests. The optional suggested validation split uses audio SHA256; all.json preserves the original complete pool. Source data terms and recipe-v1/paper-v2 selection are unchanged.
+
+All source and remote archive hashes were reconciled. Actual ESPnet reading and exact original-versus-converted waveforms passed for the documented samples. Seven regression tests pass. No GPU training or inference was performed.
+
+ESPnet recipe preparation documentation is ready as local commit 22666931398cecebf7c0646ca091b26fdacc559d and recipe-preparation.patch. GitHub publication was blocked by automatic approval review because the saved credential source was not specifically authorized; the permission question remains pending. This does not affect either completed Hugging Face release.

commit_staged_release.py

@@ -0,0 +1,179 @@
+#!/usr/bin/env python3
+"""Commit preuploaded bundles in large batches, respecting Hub rate limits."""
+import argparse
+from datetime import datetime, timezone
+import json
+from pathlib import Path
+import sqlite3
+import time
+
+from huggingface_hub import CommitOperationAdd, HfApi, get_token
+from huggingface_hub.errors import HfHubHTTPError
+from huggingface_hub.utils import disable_progress_bars
+
+from convert_release import RECIPES, status_document
+
+
+def main():
+    disable_progress_bars()
+    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")
+    )
+    parser.add_argument("--batch-shards", type=int, default=256)
+    parser.add_argument("--interval", type=int, default=60)
+    args = parser.parse_args()
+    recipe = RECIPES[args.dataset]
+    root = args.root / args.dataset
+    manifest = json.loads((root / "SOURCE_MANIFEST.json").read_text())
+    inventory = manifest["shards"]
+    api = HfApi(token=get_token())
+    connection = sqlite3.connect(root / "conversion.sqlite3", timeout=120)
+    # Recover archives that were committed before a transient verification or
+    # STATUS error. Local files remain while conversion/preuploads are active.
+    remote = {
+        f.path: f
+        for f in api.list_repo_tree(
+            recipe["target"], repo_type="dataset", recursive=True
+        )
+        if hasattr(f, "size") and f.path.endswith(".tar.zst")
+    }
+    recovered = 0
+    for path, raw in connection.execute(
+        "SELECT path,record FROM shards WHERE uploaded=0"
+    ).fetchall():
+        record = json.loads(raw)
+        file = remote.get(record["archive_path"])
+        if file is not None:
+            assert (
+                file.size == record["archive_bytes"]
+                and file.lfs.sha256 == record["archive_sha256"]
+            )
+            connection.execute("UPDATE shards SET uploaded=1 WHERE path=?", (path,))
+            recovered += 1
+    connection.commit()
+    print(
+        json.dumps(dict(event="recovered_remote_commits", shards=recovered)), flush=True
+    )
+    retry_at = 0
+    while True:
+        uploaded = [
+            json.loads(r)
+            for r, in connection.execute(
+                "SELECT record FROM shards WHERE uploaded=1 ORDER BY path"
+            )
+        ]
+        if len(uploaded) == len(inventory):
+            print(
+                json.dumps(
+                    dict(
+                        event="all_archives_committed_verified",
+                        shards=len(uploaded),
+                        rows=sum(r["rows"] for r in uploaded),
+                    )
+                ),
+                flush=True,
+            )
+            return
+        pending = [
+            json.loads(r)
+            for r, in connection.execute(
+                "SELECT record FROM shards WHERE uploaded=0 ORDER BY path"
+            )
+        ]
+        staged_path = root / "preuploads.sqlite3"
+        if not staged_path.exists():
+            time.sleep(20)
+            continue
+        staged = sqlite3.connect(staged_path, timeout=120)
+        staged_rows = {
+            p: (sha, size)
+            for p, sha, size in staged.execute("SELECT path,sha,size FROM blobs")
+        }
+        staged.close()
+        ready = [
+            r
+            for r in pending
+            if staged_rows.get(r["archive_path"])
+            == (r["archive_sha256"], r["archive_bytes"])
+        ][: args.batch_shards]
+        if not ready or time.time() < retry_at:
+            time.sleep(20)
+            continue
+        status = status_document(
+            recipe, manifest["revision"], inventory, uploaded + ready, "converting"
+        )
+        operations = [
+            CommitOperationAdd(
+                path_in_repo=r["archive_path"], path_or_fileobj=root / r["archive_path"]
+            )
+            for r in ready
+        ]
+        operations.append(
+            CommitOperationAdd(
+                path_in_repo="STATUS.json",
+                path_or_fileobj=(json.dumps(status, indent=2) + "\n").encode(),
+            )
+        )
+        try:
+            commit = api.create_commit(
+                recipe["target"],
+                repo_type="dataset",
+                operations=operations,
+                commit_message=f"Publish {len(ready)} verified preuploaded bundles ({len(uploaded)+len(ready)}/{len(inventory)})",
+                num_threads=4,
+            )
+        except HfHubHTTPError as error:
+            response = error.response
+            if response is None or response.status_code != 429:
+                raise
+            # Never hammer a limited commit endpoint. Use a server-provided
+            # retry delay when available, otherwise retry only after a minute.
+            delay = max(60, float(response.headers.get("Retry-After", 60)))
+            retry_at = time.time() + delay
+            print(
+                json.dumps(
+                    dict(
+                        event="commit_rate_limited",
+                        retry_at=datetime.fromtimestamp(
+                            retry_at, timezone.utc
+                        ).isoformat(),
+                    )
+                ),
+                flush=True,
+            )
+            continue
+        files = {
+            f.path: f
+            for f in api.get_paths_info(
+                recipe["target"],
+                [r["archive_path"] for r in ready],
+                repo_type="dataset",
+                revision=commit.oid,
+            )
+        }
+        for r in ready:
+            f = files[r["archive_path"]]
+            assert f.size == r["archive_bytes"] and f.lfs.sha256 == r["archive_sha256"]
+            connection.execute(
+                "UPDATE shards SET uploaded=1 WHERE path=?", (r["source_path"],)
+            )
+        connection.commit()
+        (root / "STATUS.json").write_text(json.dumps(status, indent=2) + "\n")
+        print(
+            json.dumps(
+                dict(
+                    event="batch_committed_verified",
+                    shards=len(ready),
+                    total=len(uploaded) + len(ready),
+                    revision=commit.oid,
+                )
+            ),
+            flush=True,
+        )
+        retry_at = time.time() + args.interval
+
+
+if __name__ == "__main__":
+    main()

convert_release.py

@@ -380,6 +380,39 @@ ESPnet recipes: [Bagpiper](https://github.com/jctian98/espnet/tree/bagpiper-e2e-
 
 def upload_batch(api, recipe, revision, inventory, records, previous):
     root = Path(recipe["root"])
+    if recipe.get("defer_commit"):
+        staged = sqlite3.connect(root / "preuploads.sqlite3", timeout=120)
+        staged.execute(
+            "CREATE TABLE IF NOT EXISTS blobs (path TEXT PRIMARY KEY,sha TEXT,size INTEGER)"
+        )
+        known = {
+            p: (h, n) for p, h, n in staged.execute("SELECT path,sha,size FROM blobs")
+        }
+        additions = [
+            CommitOperationAdd(
+                path_in_repo=r["archive_path"], path_or_fileobj=root / r["archive_path"]
+            )
+            for r in records
+            if known.get(r["archive_path"]) != (r["archive_sha256"], r["archive_bytes"])
+        ]
+        if additions:
+            with UPLOAD_SLOTS:
+                api.preupload_lfs_files(
+                    recipe["target"],
+                    additions=additions,
+                    repo_type="dataset",
+                    num_threads=4,
+                )
+            staged.executemany(
+                "INSERT OR REPLACE INTO blobs VALUES (?,?,?)",
+                [
+                    (r["archive_path"], r["archive_sha256"], r["archive_bytes"])
+                    for r in records
+                ],
+            )
+            staged.commit()
+        staged.close()
+        return "preuploaded-awaiting-batched-commit"
     commit_revision = None
     for attempt in range(8):
         try:
@@ -617,15 +650,21 @@ def convert_partition(
                     pending,
                     [],
                 )
-                for r in pending:
-                    state.execute(
-                        "UPDATE shards SET uploaded=1 WHERE path=?", (r["source_path"],)
-                    )
-                state.commit()
+                if not recipe.get("defer_commit"):
+                    for r in pending:
+                        state.execute(
+                            "UPDATE shards SET uploaded=1 WHERE path=?",
+                            (r["source_path"],),
+                        )
+                    state.commit()
                 print(
                     json.dumps(
                         dict(
-                            event="uploaded",
+                            event=(
+                                "preuploaded"
+                                if recipe.get("defer_commit")
+                                else "uploaded"
+                            ),
                             partition=partition,
                             batch=len(pending),
                             commit=commit,
@@ -633,8 +672,9 @@ def convert_partition(
                     ),
                     flush=True,
                 )
-                for r in pending:
-                    (root / r["archive_path"]).unlink(missing_ok=True)
+                if not recipe.get("defer_commit"):
+                    for r in pending:
+                        (root / r["archive_path"]).unlink(missing_ok=True)
                 pending = []
     aggregate.close()
     state.close()
@@ -694,6 +734,20 @@ def run_partition_parallel(recipe, revision, inventory, workers, batch_shards, l
                 flush=True,
             )
     connection = sqlite3.connect(root / "conversion.sqlite3")
+    if recipe.get("defer_commit"):
+        count, rows = connection.execute(
+            "SELECT count(*),sum(json_extract(record,'$.rows')) FROM shards"
+        ).fetchone()
+        connection.close()
+        if count != len(inventory) or rows != sum(r["rows"] for r in inventory):
+            raise ValueError("Final staged conversion count mismatch")
+        print(
+            json.dumps(
+                dict(event="staged_conversion_finished", rows=rows, shards=count)
+            ),
+            flush=True,
+        )
+        return
     records = [
         json.loads(r[0])
         for r in connection.execute(
@@ -741,10 +795,16 @@ def main():
     parser.add_argument("--download-workers", type=int, default=4)
     parser.add_argument("--partition-parallel", action="store_true")
     parser.add_argument("--lanes", type=int, default=1)
+    parser.add_argument(
+        "--defer-commit",
+        action="store_true",
+        help="Convert/preupload only; keep archives for later batched commits",
+    )
     args = parser.parse_args()
     api = HfApi(token=get_token())
     for name in args.dataset or ["tts", "general"]:
         recipe = dict(RECIPES[name])
+        recipe["defer_commit"] = args.defer_commit
         revision, inventory = read_inventory(recipe["snapshot"])
         if args.local_samples:
             candidates = {
@@ -782,7 +842,7 @@ def main():
         pinned.write_text(json.dumps(document, indent=2) + "\n")
         (root / "README.md").write_text(readme(recipe, revision))
         scripts = Path(__file__).resolve().parent
-        if args.upload:
+        if args.upload and not args.defer_commit:
             api.create_repo(
                 recipe["target"], repo_type="dataset", private=False, exist_ok=True
             )
@@ -836,6 +896,10 @@ def main():
                 args.lanes,
             )
             continue
+        if args.defer_commit:
+            raise ValueError(
+                "--defer-commit requires production --upload --partition-parallel"
+            )
         known = {
             r[0]: bool(r[1])
             for r in connection.execute("SELECT path,uploaded FROM shards")

finalize_release.py

@@ -158,6 +158,13 @@ def main():
     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. "
@@ -197,6 +204,11 @@ def main():
                 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",
@@ -207,6 +219,10 @@ def main():
         "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)

test_converter.py

@@ -238,6 +238,7 @@ def test_upload_retry_does_not_reuse_committed_operations(
         source, inventory, tmp_path, state, "repo", "revision"
     )
     state.close()
+
     monkeypatch.setattr(converter.time, "sleep", lambda _: None)
 
     class Api:
@@ -291,3 +292,44 @@ def test_upload_retry_does_not_reuse_committed_operations(
     state = sqlite3.connect(tmp_path / "conversion.sqlite3")
     assert state.execute("SELECT uploaded FROM shards").fetchone()[0] == 1
     state.close()
+
+
+def test_staged_conversion_keeps_archives_uncommitted(tmp_path, monkeypatch):
+    source = tmp_path / "source"
+    root = tmp_path / "release"
+    root.mkdir()
+    inventory = [
+        make_source(source, "generation", i, [f"row:{i}"])[1] for i in range(2)
+    ]
+    converter.open_database(root / "conversion.sqlite3").close()
+    monkeypatch.setattr(
+        converter,
+        "download_shard",
+        lambda repo, revision, item, root, local_source: (source / item["path"], False),
+    )
+    uploaded = []
+
+    class Api:
+        def preupload_lfs_files(self, *args, additions, **kwargs):
+            uploaded.extend(op.path_in_repo for op in additions)
+
+    monkeypatch.setattr(converter, "HfApi", lambda **kwargs: Api())
+    recipe = dict(
+        root=str(root),
+        source="source",
+        target="target",
+        snapshot="sft_data",
+        defer_commit=True,
+    )
+    converter.convert_partition(recipe, "revision", inventory, "generation", 2, 2)
+    state = sqlite3.connect(root / "conversion.sqlite3")
+    records = [
+        json.loads(r)
+        for r, in state.execute("SELECT record FROM shards WHERE uploaded=0")
+    ]
+    assert len(records) == 2 and len(uploaded) == 2
+    assert all((root / r["archive_path"]).exists() for r in records)
+    staged = sqlite3.connect(root / "preuploads.sqlite3")
+    assert staged.execute("SELECT count(*) FROM blobs").fetchone()[0] == 2
+    converter.convert_partition(recipe, "revision", inventory, "generation", 2, 2)
+    assert len(uploaded) == 2