Finalize verified ESPnet release: 2667017 unique rows, 6804 archives

CONVERSION.md

@@ -2,7 +2,7 @@
 
 The converter streams pinned, SHA256-verified source Parquet shards into deterministic tar.zst bundles. It preserves original encoded audio bytes and every training row, including intentional reuse of audio. Audio is stored by SHA256 and deduplicated within each ordered conversion stream; identical files across streams are merged during verified extraction; conversations reference portable relative audio paths. Text content, role order and source metadata are preserved. ESPnet example IDs use the globally unique source row_id.
 
-SQLite transactions track audio deduplication, unique row IDs and completed source shards. A crash during conversion rolls back the shard. A successfully converted archive remains on disk until its Hub file size and LFS SHA256 match. Source downloads use bounded prefetch workers; completed input shards are removed after conversion. Upload batches are configurable. Each batch is committed, checked against remote file sizes and LFS SHA256, then included in the aggregate published status. Restarting the command resumes from its local state database.
+SQLite transactions track audio deduplication, unique row IDs and completed source shards. A crash during conversion rolls back the shard. A successfully converted archive remains on disk until its Hub file size and LFS SHA256 match. Source downloads use bounded prefetch workers; completed input shards are removed after conversion. Upload batches are configurable. Each batch is committed, checked against remote file sizes and LFS SHA256, then included in the aggregate published status. Six concurrent storage sessions are allowed independently of the conversion-stream count. Transient post-commit failures retry verification/status without reusing single-use upload operations; transient commit failures rebuild operations from the preserved archive files. Restarting the command resumes from its local state database.
 
 Production conversion (requires write access to the target ESPnet dataset repos):
 
@@ -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.

PUBLIC_DOWNLOAD_VALIDATION.json

@@ -0,0 +1,46 @@
+{
+  "state": "passed",
+  "checks": [
+    {
+      "repository": "espnet/Bagpiper_TTS_SFT_Data_ESPnet",
+      "revision": "e8f575605cafe6bb5526f3a9db3fa905bce48e06",
+      "partition": "classical_tts",
+      "rows": 1024,
+      "decoded_waveforms": 3,
+      "preserved_text_order_audio": true,
+      "disjoint_train_valid_audio": true
+    },
+    {
+      "repository": "espnet/Bagpiper_TTS_SFT_Data_ESPnet",
+      "revision": "96dbfa8edf77ae2698001ddfa98eebc837d1b3a6",
+      "partition": "intent_to_speech",
+      "rows": 812,
+      "decoded_waveforms": 3,
+      "preserved_text_order_audio": true,
+      "disjoint_train_valid_audio": true
+    },
+    {
+      "repository": "espnet/Bagpiper_SFT_Data_ESPnet",
+      "revision": "d6ffefe3e37326065b598bf5a6039ec9d1877eeb",
+      "partition": "generation",
+      "rows": 2048,
+      "decoded_waveforms": 3,
+      "preserved_text_order_audio": true,
+      "disjoint_train_valid_audio": true
+    },
+    {
+      "repository": "espnet/Bagpiper_SFT_Data_ESPnet",
+      "revision": "15a96eb4749323b5ac36e540c3c2390283f14640",
+      "partition": "understanding",
+      "rows": 2048,
+      "decoded_waveforms": 3,
+      "preserved_text_order_audio": true,
+      "disjoint_train_valid_audio": true
+    }
+  ],
+  "total_rows": 5932,
+  "decoded_waveforms": 12,
+  "limitations": [
+    "CPU reader verification; no GPU training or inference"
+  ]
+}

README.md

@@ -11,10 +11,23 @@ tags:
 
 # Bagpiper SFT Data in ESPnet format
 
-This release converts [espnet/Bagpiper_SFT_Data](https://huggingface.co/datasets/espnet/Bagpiper_SFT_Data) at revision `7dec4d68dc30e442368914619668fcd695a897f7` into portable, lossless ESPnet dialogue bundles. **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.
+This release converts [espnet/Bagpiper_SFT_Data](https://huggingface.co/datasets/espnet/Bagpiper_SFT_Data) at revision `7dec4d68dc30e442368914619668fcd695a897f7` into portable, lossless ESPnet dialogue bundles. **Complete:** all 2,667,017 source rows and 6,804 shards are converted and uploaded. [RELEASE_VALIDATION.json](./RELEASE_VALIDATION.json) records the full source/count/hash reconciliation.
+
+**Source selection:** this preserves the public recipe-v1 pool (including 1,193,006 understanding rows). It does not reconstruct the paper-v2 filtered selection.
 
 Each `.tar.zst` contains original encoded audio, three-element dialogue messages, and source provenance. Audio is deduplicated by SHA-256 within each ordered conversion stream; identical files across streams are verified and merged during extraction. Repeated training examples remain present. All text, message roles, and order are preserved. The original globally unique `row_id` becomes ESPnet `example_id`. No audio resampling or lossy transcoding is performed.
 
+## Verified release counts
+
+| Partition | Preserved rows | Distinct audio files |
+| --- | ---: | ---: |
+| generation | 1,474,011 | 979,274 |
+| understanding | 1,193,006 | 334,493 |
+
+Distinct 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.
+
+[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`.
+
 ## Prepare local training inputs
 
 ```bash
@@ -23,7 +36,7 @@ hf download espnet/Bagpiper_SFT_Data_ESPnet prepare_espnet.py --local-dir tools
 python tools/prepare_espnet.py --repo-id espnet/Bagpiper_SFT_Data_ESPnet --data-root /path/to/bagpiper-sft
 ```
 
-For a small prefix trial, add `--max-shards 2 --allow-incomplete`. Repeat `--partition NAME` to select application partitions. The helper verifies archive SHA-256, extracts safely, resolves audio paths, checks duplicate IDs and linkage, and writes `prepared/NAME/{all,train,valid}.json` plus `dialogues.jsonl`.
+For a small prefix trial, add `--max-shards 2`. Repeat `--partition NAME` to select application partitions. The helper verifies archive SHA-256, extracts safely, resolves audio paths, checks duplicate IDs and linkage, and writes `prepared/NAME/{all,train,valid}.json` plus `dialogues.jsonl`.
 
 The default validation fraction is 1%, chosen deterministically from the audio SHA-256. The same audio always has the same split, including across source shards and partitions. Use `all.json` to retain the original complete training pool. This suggested split is not the paper's official split. `--valid-fraction 0` assigns every row to train.
 

REBALANCE.json

@@ -0,0 +1,9 @@
+{
+  "created_at": "2026-10-01T00:46:14.901776+00:00",
+  "original_streams": 12,
+  "new_streams": 40,
+  "completed_shards": 3549,
+  "remaining_shards": 3255,
+  "max_shards_per_new_stream": 160,
+  "state_copied_before_scheduling": true
+}

RELEASE_VALIDATION.json

@@ -0,0 +1,39 @@
+{
+  "state": "passed",
+  "completed_at": "2026-10-01T01:29:04.171087+00:00",
+  "source_repository": "espnet/Bagpiper_SFT_Data",
+  "source_revision": "7dec4d68dc30e442368914619668fcd695a897f7",
+  "verified_remote_revision": "ddc7d626fecf295a0cc6c71d0515aa2e8bd2a0bf",
+  "source_shards": 6804,
+  "verified_archive_files": 6804,
+  "source_rows": 2667017,
+  "unique_row_ids": 2667017,
+  "unique_audio_files": 1313767,
+  "unique_audio_bytes": 489342164954,
+  "partition_statistics": {
+    "generation": {
+      "rows": 1474011,
+      "unique_audio": 979274,
+      "audio_bytes": 279641958307
+    },
+    "understanding": {
+      "rows": 1193006,
+      "unique_audio": 334493,
+      "audio_bytes": 209700206647
+    }
+  },
+  "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"
+  ]
+}

STATUS.json

@@ -1,15 +1,15 @@
 {
   "format": "bagpiper-espnet-lossless-dialogue-v1",
-  "state": "converting",
+  "state": "complete",
   "source_repository": "espnet/Bagpiper_SFT_Data",
   "source_revision": "7dec4d68dc30e442368914619668fcd695a897f7",
   "expected_rows": 2667017,
   "expected_source_shards": 6804,
   "uploaded_rows": 2667017,
   "uploaded_shards": 6804,
-  "unique_audio_files": 1658333,
-  "unique_audio_bytes": 824650644469,
-  "unique_audio_count_scope": "sum_of_stream_local_new_audio; see final RELEASE_VALIDATION.json for reconciled distinct counts",
+  "unique_audio_files": 1313767,
+  "unique_audio_bytes": 489342164954,
+  "unique_audio_count_scope": "partition_and_sha256",
   "uploaded_archive_bytes": 719295381339,
   "transformations": [
     "Audio bytes preserved exactly; deduplicated by SHA256 within each ordered stream; identical files merge during extraction",
@@ -102078,5 +102078,8 @@
       "unique_audio_bytes_added": 42071954,
       "logical_audio_bytes": 137233512
     }
-  ]
+  ],
+  "archive_audio_entries": 1658333,
+  "archive_audio_bytes": 824650644469,
+  "validation": "RELEASE_VALIDATION.json"
 }

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

@@ -25,6 +25,7 @@ from prepare_espnet import digest
 
 AUDIT = Path("/root/bagpiper-release-audit")
 UPLOAD_LOCK = threading.Lock()
+UPLOAD_SLOTS = threading.BoundedSemaphore(6)
 RECIPES = {
     "tts": {
         "source": "espnet/Bagpiper_TTS_SFT_Data",
@@ -379,48 +380,89 @@ ESPnet recipes: [Bagpiper](https://github.com/jctian98/espnet/tree/bagpiper-e2e-
 
 def upload_batch(api, recipe, revision, inventory, records, previous):
     root = Path(recipe["root"])
-    operations = [
-        CommitOperationAdd(
-            path_in_repo=r["archive_path"], path_or_fileobj=root / r["archive_path"]
+    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)"
         )
-        for r in records
-    ]
-    if not recipe.get("parallel"):
-        status = status_document(
-            recipe, revision, inventory, previous + records, "converting"
-        )
-        operations.append(
+        known = {
+            p: (h, n) for p, h, n in staged.execute("SELECT path,sha,size FROM blobs")
+        }
+        additions = [
             CommitOperationAdd(
-                path_in_repo="STATUS.json",
-                path_or_fileobj=(json.dumps(status, indent=2) + "\n").encode(),
+                path_in_repo=r["archive_path"], path_or_fileobj=root / r["archive_path"]
             )
-        )
-    else:
-        status = {"uploaded_shards": len(previous) + len(records)}
-    for attempt in range(8):
-        try:
-            # Upload large blobs concurrently, serialize only the small Hub
-            # commit and aggregate STATUS update to avoid lost status writes.
-            if recipe.get("parallel"):
+            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=operations,
+                    additions=additions,
                     repo_type="dataset",
                     num_threads=4,
                 )
-            with UPLOAD_LOCK:
-                commit = api.create_commit(
-                    recipe["target"],
-                    repo_type="dataset",
-                    operations=operations,
-                    commit_message=f"Convert and validate {len(records)} source shards",
-                    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:
+            if commit_revision is None:
+                # CommitOperationAdd objects are single-use and can lose their
+                # local path after preupload. A retry must create fresh objects.
+                operations = [
+                    CommitOperationAdd(
+                        path_in_repo=r["archive_path"],
+                        path_or_fileobj=root / r["archive_path"],
+                    )
+                    for r in records
+                ]
+                if not recipe.get("parallel"):
+                    status = status_document(
+                        recipe, revision, inventory, previous + records, "converting"
+                    )
+                    operations.append(
+                        CommitOperationAdd(
+                            path_in_repo="STATUS.json",
+                            path_or_fileobj=(
+                                json.dumps(status, indent=2) + "\n"
+                            ).encode(),
+                        )
+                    )
+                # Bound storage sessions independently of conversion streams.
+                if recipe.get("parallel"):
+                    with UPLOAD_SLOTS:
+                        api.preupload_lfs_files(
+                            recipe["target"],
+                            additions=operations,
+                            repo_type="dataset",
+                            num_threads=4,
+                        )
+                with UPLOAD_LOCK:
+                    commit = api.create_commit(
+                        recipe["target"],
+                        repo_type="dataset",
+                        operations=operations,
+                        commit_message=f"Convert and validate {len(records)} source shards",
+                        num_threads=4,
+                    )
+                commit_revision = str(commit.oid)
+            # Once committed, retry verification/status only. Never commit the
+            # same operations again following a transient read/status failure.
             info = api.get_paths_info(
                 recipe["target"],
                 [r["archive_path"] for r in records],
                 repo_type="dataset",
-                revision=commit.oid,
+                revision=commit_revision,
             )
             remote = {f.path: f for f in info}
             for r in records:
@@ -461,8 +503,20 @@ def upload_batch(api, recipe, revision, inventory, records, previous):
                         ).encode(),
                         commit_message=f"Verify uploaded prefix: {len(all_records)}/{len(inventory)} shards",
                     )
-            return str(commit.oid)
-        except Exception:
+            return commit_revision
+        except Exception as error:
+            print(
+                json.dumps(
+                    dict(
+                        event="upload_retry",
+                        attempt=attempt + 1,
+                        error_type=type(error).__name__,
+                        already_committed=commit_revision is not None,
+                        first_archive=records[0]["archive_path"],
+                    )
+                ),
+                flush=True,
+            )
             if attempt == 7:
                 raise
             time.sleep(min(30, 2**attempt))
@@ -596,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,
@@ -612,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()
@@ -673,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(
@@ -720,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 = {
@@ -761,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
             )
@@ -815,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

@@ -0,0 +1,240 @@
+#!/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()

link_source_release.py

@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+"""Add the completed ESPnet-format preparation entry to its original data card."""
+import argparse
+import json
+from pathlib import Path
+
+from huggingface_hub import CommitOperationAdd, HfApi, get_token, hf_hub_download
+
+from convert_release import RECIPES
+
+
+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")
+    )
+    args = parser.parse_args()
+    recipe = RECIPES[args.dataset]
+    api = HfApi(token=get_token())
+    target_revision = api.repo_info(recipe["target"], repo_type="dataset").sha
+    status = json.loads(
+        Path(
+            hf_hub_download(
+                recipe["target"],
+                "STATUS.json",
+                repo_type="dataset",
+                revision=target_revision,
+            )
+        ).read_text()
+    )
+    assert (
+        status["state"] == "complete"
+        and status.get("validation") == "RELEASE_VALIDATION.json"
+    )
+    source_revision = api.repo_info(recipe["source"], repo_type="dataset").sha
+    card = Path(
+        hf_hub_download(
+            recipe["source"], "README.md", repo_type="dataset", revision=source_revision
+        )
+    ).read_text()
+    heading = "## Prepare for ESPnet training"
+    section = f"""{heading}
+
+The complete [ESPnet-format release](https://huggingface.co/datasets/{recipe['target']})
+preserves all {status['expected_rows']:,} source rows, ordered text turns, and original
+encoded audio bytes. It converts this Parquet schema into three-element dialogue
+messages and portable audio files. Source `row_id` becomes the globally unique
+ESPnet `example_id`; repeated training examples remain present.
+
+```bash
+python -m pip install huggingface_hub zstandard
+hf download {recipe['target']} prepare_espnet.py --local-dir tools
+python tools/prepare_espnet.py \\
+    --repo-id {recipe['target']} --data-root /path/to/bagpiper-{args.dataset}-sft
+```
+
+The helper verifies archive/audio hashes, resolves local paths, and writes
+`prepared/<partition>/{{all,train,valid}}.json` plus `dialogues.jsonl`. Add
+`--max-shards 2` for a small trial and repeat `--partition NAME` to select
+applications. Audio SHA256 determines the suggested 1% validation split;
+`all.json` retains the original training pool. The split is not the paper's
+official split. Prepare token-length statistics with the checkpoint-compatible
+configuration as shown in the converted release's README.
+
+See its [full release validation](https://huggingface.co/datasets/{recipe['target']}/blob/main/RELEASE_VALIDATION.json)
+and [public download/ESPnet reader checks](https://huggingface.co/datasets/{recipe['target']}/blob/main/PUBLIC_DOWNLOAD_VALIDATION.json).
+This conversion preserves the original source selection and applicable terms.
+
+"""
+    if heading in card:
+        start = card.index(heading)
+        end = card.find("\n## ", start + len(heading))
+        card = card[:start] + section + (card[end + 1 :] if end >= 0 else "")
+    else:
+        marker = "## Loading the data"
+        assert marker in card
+        card = card.replace(marker, section + marker, 1)
+    output = args.root / "releases" / args.dataset / "SOURCE_README.updated.md"
+    output.write_text(card)
+    commit = api.create_commit(
+        recipe["source"],
+        repo_type="dataset",
+        parent_commit=source_revision,
+        operations=[
+            CommitOperationAdd(path_in_repo="README.md", path_or_fileobj=output)
+        ],
+        commit_message="Link completed lossless ESPnet training format and preparation helper",
+    )
+    print(
+        json.dumps(
+            dict(
+                source=recipe["source"],
+                commit=commit.oid,
+                converted_revision=target_revision,
+            )
+        )
+    )
+
+
+if __name__ == "__main__":
+    main()

prepare_espnet.py

@@ -89,6 +89,11 @@ def prepare_partition(root, partition, records, valid_fraction):
                         origin = json.loads(provenance_text)
                         if row["example_id"] != origin["row_id"]:
                             raise ValueError("Dialogue/provenance ID mismatch")
+                        if (
+                            origin["partition"] != partition
+                            or origin["source_shard"] != record["source_path"]
+                        ):
+                            raise ValueError("Dialogue/provenance shard mismatch")
                         connection.execute(
                             "INSERT INTO ids VALUES (?)", (row["example_id"],)
                         )
@@ -99,6 +104,14 @@ def prepare_partition(root, partition, records, valid_fraction):
                                     raise ValueError(
                                         f"Invalid relative audio path: {relative}"
                                     )
+                                if (
+                                    str(relative) != origin["relative_audio_path"]
+                                    or Path(relative.name).stem
+                                    != origin["audio_sha256"]
+                                ):
+                                    raise ValueError(
+                                        "Dialogue/provenance audio linkage mismatch"
+                                    )
                                 path = root.joinpath(*relative.parts).resolve()
                                 if (
                                     not path.is_relative_to(root.resolve())

rebalance_streams.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+"""Split only unconverted work, retaining each parent's audio and row state."""
+import argparse
+from collections import Counter
+from datetime import datetime, timezone
+import json
+from pathlib import Path
+import sqlite3
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--root", type=Path, required=True)
+    parser.add_argument("--max-shards", type=int, default=160)
+    args = parser.parse_args()
+    root = args.root
+    plan_path = root / "STREAM_PLAN.json"
+    old_plan = json.loads(plan_path.read_text())
+    aggregate = sqlite3.connect(root / "conversion.sqlite3")
+    done = {path for (path,) in aggregate.execute("SELECT path FROM shards")}
+    aggregate.close()
+    inventory = json.loads((root / "SOURCE_MANIFEST.json").read_text())["shards"]
+    assert Counter(x for s in old_plan for x in s["paths"]) == Counter(
+        r["path"] for r in inventory
+    )
+    assert not (
+        root / "STREAM_PLAN.before-rebalance.json"
+    ).exists(), "Already rebalanced"
+    new_plan = []
+    for stream in old_plan:
+        converted = [p for p in stream["paths"] if p in done]
+        remaining = [p for p in stream["paths"] if p not in done]
+        if converted:
+            new_plan.append(dict(stream, paths=converted))
+        source = sqlite3.connect(root / f"conversion-{stream['stream_id']}.sqlite3")
+        for index in range(0, len(remaining), args.max_shards):
+            name = f"{stream['stream_id']}-resume{index // args.max_shards:02}"
+            destination = root / f"conversion-{name}.sqlite3"
+            assert (
+                not destination.exists()
+            ), f"Unexpected existing stream: {destination}"
+            state = sqlite3.connect(destination)
+            source.backup(state)
+            state.close()
+            new_plan.append(
+                dict(
+                    partition=stream["partition"],
+                    stream_id=name,
+                    paths=remaining[index : index + args.max_shards],
+                    parent_stream=stream["stream_id"],
+                )
+            )
+        source.close()
+    assert Counter(x for s in new_plan for x in s["paths"]) == Counter(
+        r["path"] for r in inventory
+    )
+    plan_path.replace(root / "STREAM_PLAN.before-rebalance.json")
+    plan_path.write_text(json.dumps(new_plan, indent=2) + "\n")
+    (root / "REBALANCE.json").write_text(
+        json.dumps(
+            dict(
+                created_at=datetime.now(timezone.utc).isoformat(),
+                original_streams=len(old_plan),
+                new_streams=len(new_plan),
+                completed_shards=len(done),
+                remaining_shards=len(inventory) - len(done),
+                max_shards_per_new_stream=args.max_shards,
+                state_copied_before_scheduling=True,
+            ),
+            indent=2,
+        )
+        + "\n"
+    )
+    print((root / "REBALANCE.json").read_text())
+
+
+if __name__ == "__main__":
+    main()

recipe-preparation.patch

@@ -0,0 +1,99 @@
+diff --git a/egs2/bagpiper/speechlm1/README.md b/egs2/bagpiper/speechlm1/README.md
+index 0c702ddce..88cecaa1a 100644
+--- a/egs2/bagpiper/speechlm1/README.md
++++ b/egs2/bagpiper/speechlm1/README.md
+@@ -176,9 +176,42 @@ Training starts from prepared inputs:
+ - **Length statistics:** `stats_<task>_<name>.jsonl`, with one
+   `{"example_id": length}` record per line for each task/dataset combination.
+ 
+-Convert Hub Parquet data into these manifests and reader inputs before training.
+-Consult the [dataset card](https://huggingface.co/datasets/espnet/Bagpiper_SFT_Data)
+-for its schema and current release status.
++The public Parquet schema requires conversion before it can be passed to the
++dialogue reader. A [lossless ESPnet-format release](https://huggingface.co/datasets/espnet/Bagpiper_SFT_Data_ESPnet)
++provides the converted audio, conversations, and a portable preparation helper:
++
++```bash
++python -m pip install huggingface_hub zstandard
++hf download espnet/Bagpiper_SFT_Data_ESPnet prepare_espnet.py --local-dir tools
++python tools/prepare_espnet.py \
++    --repo-id espnet/Bagpiper_SFT_Data_ESPnet --data-root /path/to/bagpiper-sft
++```
++
++Check the converted release's `STATUS.json` for `state: complete` before using
++the full corpus. Add `--partition generation --max-shards 2` for a small trial;
++an unfinished release also requires explicit `--allow-incomplete`. The helper
++verifies checksums, resolves audio paths, and writes
++`prepared/<partition>/{all,train,valid}.json` plus `dialogues.jsonl`.
++It preserves all source rows and audio bytes, using the globally unique source
++`row_id` as `example_id`. Its suggested 1% validation split is based on audio
++SHA256; `all.json` retains the original training pool. This is a format conversion
++of the released recipe-v1 data, not a selection of the paper-v2 mixture.
++
++Collect token lengths from the ESPnet repository root using the
++checkpoint-compatible configuration and distinct dataset names:
++
++```bash
++python -m espnet2.speechlm.bin.prepare_length_stats \
++    --train-config /path/to/checkpoint-compatible.yaml \
++    --train-unregistered-specifier 'dialogue:generation_train:/path/to/bagpiper-sft/prepared/generation/train.json' \
++    --valid-unregistered-specifier 'dialogue:generation_valid:/path/to/bagpiper-sft/prepared/generation/valid.json' \
++    --output-dir /path/to/sft_stats
++```
++
++Include corresponding `understanding` specifiers for that partition. Use these
++same names and manifests with the training launcher below. The
++[original dataset card](https://huggingface.co/datasets/espnet/Bagpiper_SFT_Data)
++documents provenance, source terms, and limitations.
+ 
+ For a dialogue dataset, the manifest names its JSONL reader input and example IDs:
+ 
+diff --git a/egs2/bagpiper_tts/speechlm1/README.md b/egs2/bagpiper_tts/speechlm1/README.md
+index 97205f7a4..055d8d2a6 100644
+--- a/egs2/bagpiper_tts/speechlm1/README.md
++++ b/egs2/bagpiper_tts/speechlm1/README.md
+@@ -185,11 +185,39 @@ The TTS training conversations have the sequence:
+ user: text request → assistant: planning + rich caption → assistant: target audio
+ ```
+ 
+-Convert the [Hub Parquet dataset](https://huggingface.co/datasets/espnet/Bagpiper_TTS_SFT_Data)
+-into dialogue-reader inputs and manifests containing `data_entry` and `samples`;
+-it cannot be passed directly to the trainer. Use distinct training/validation
+-dataset names and prepare `stats_dialogue_<name>.jsonl` files. The dataset card
+-documents its schema and current release status.
++The [lossless ESPnet-format release](https://huggingface.co/datasets/espnet/Bagpiper_TTS_SFT_Data_ESPnet)
++converts the public Parquet data into dialogue-reader inputs. Download its helper
++and prepare local manifests:
++
++```bash
++python -m pip install huggingface_hub zstandard
++hf download espnet/Bagpiper_TTS_SFT_Data_ESPnet prepare_espnet.py --local-dir tools
++python tools/prepare_espnet.py \
++    --repo-id espnet/Bagpiper_TTS_SFT_Data_ESPnet --data-root /path/to/bagpiper-tts-sft
++```
++
++The helper checks hashes and preserves every row, text turn, and original audio
++byte. It writes `prepared/<partition>/{all,train,valid}.json` and
++`dialogues.jsonl` for all six applications, using source `row_id` as the globally
++unique example ID. The suggested 1% validation split is determined by audio
++SHA256; `all.json` retains the original training pool. Add
++`--partition classical_tts --max-shards 2` for a small trial.
++
++From the ESPnet repository root, prepare exact token lengths with the
++checkpoint-compatible configuration:
++
++```bash
++python -m espnet2.speechlm.bin.prepare_length_stats \
++    --train-config /path/to/checkpoint-compatible.yaml \
++    --train-unregistered-specifier 'dialogue:classical_tts_train:/path/to/bagpiper-tts-sft/prepared/classical_tts/train.json' \
++    --valid-unregistered-specifier 'dialogue:classical_tts_valid:/path/to/bagpiper-tts-sft/prepared/classical_tts/valid.json' \
++    --output-dir /path/to/tts_stats
++```
++
++Add specifiers with distinct names for the other applications and use the same
++names/manifests when launching training. The
++[original dataset card](https://huggingface.co/datasets/espnet/Bagpiper_TTS_SFT_Data)
++documents provenance and source terms.
+ 
+ ### Recipe defaults
+ 

test_converter.py

@@ -0,0 +1,335 @@
+import io
+import hashlib
+import json
+import sqlite3
+import wave
+from pathlib import Path
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+import pytest
+
+import convert_release as converter
+from prepare_espnet import digest, safe_extract
+
+
+def create_audio():
+    out = io.BytesIO()
+    with wave.open(out, "wb") as wav:
+        wav.setnchannels(1)
+        wav.setsampwidth(2)
+        wav.setframerate(8000)
+        wav.writeframes(bytes(160))
+    return out.getvalue()
+
+
+def make_source(root, partition, index, ids):
+    path = root / f"{partition}/train-{index:05}.parquet"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    audio = create_audio()
+    sha = hashlib.sha256(audio).hexdigest()
+    rows = [
+        dict(
+            row_id=key,
+            example_id="same-local-id",
+            partition=partition,
+            source_revision="source-revision",
+            audio={"bytes": audio, "path": "display.wav"},
+            audio_bytes=len(audio),
+            audio_sha256=sha,
+            audio_format="wav",
+            messages=[
+                dict(
+                    role="user",
+                    modality="text",
+                    content="unchanged\ntext",
+                    audio_index=-1,
+                ),
+                dict(
+                    role="assistant",
+                    modality="audio",
+                    content="display.wav",
+                    audio_index=0,
+                ),
+            ],
+        )
+        for key in ids
+    ]
+    pq.write_table(pa.Table.from_pylist(rows), path)
+    return path, dict(
+        path=str(path.relative_to(root)),
+        partition=partition,
+        rows=len(rows),
+        sha256=digest(path),
+        parquet_bytes=path.stat().st_size,
+    )
+
+
+def test_cross_shard_dedup_and_transaction_rollback(tmp_path):
+    state = converter.open_database(tmp_path / "state.sqlite3")
+    first, one = make_source(
+        tmp_path / "sources", "generation", 0, ["source:a", "source:b"]
+    )
+    second, two = make_source(tmp_path / "sources", "generation", 1, ["source:c"])
+    r1 = converter.convert_shard(
+        first, one, tmp_path / "output", state, "repo", "revision"
+    )
+    r2 = converter.convert_shard(
+        second, two, tmp_path / "output", state, "repo", "revision"
+    )
+    assert r1["unique_audio_added"] == 1 and r2["unique_audio_added"] == 0
+    for r in [r1, r2]:
+        safe_extract(tmp_path / "output" / r["archive_path"], tmp_path / "relocated")
+    dialogues = [
+        json.loads(l)
+        for r in [r1, r2]
+        for l in (tmp_path / "relocated" / r["dialogue_path"]).read_text().splitlines()
+    ]
+    assert [x["example_id"] for x in dialogues] == ["source:a", "source:b", "source:c"]
+    assert len({x["messages"][1][2] for x in dialogues}) == 1
+    assert dialogues[0]["messages"][0][2] == "unchanged\ntext"
+    assert (
+        tmp_path / "relocated" / dialogues[-1]["messages"][1][2]
+    ).read_bytes() == create_audio()
+    bad, inventory = make_source(
+        tmp_path / "sources", "generation", 2, ["new-id", "source:a"]
+    )
+    with pytest.raises(sqlite3.IntegrityError):
+        converter.convert_shard(
+            bad, inventory, tmp_path / "output", state, "repo", "revision"
+        )
+    assert (
+        state.execute("SELECT count(*) FROM rows WHERE row_id='new-id'").fetchone()[0]
+        == 0
+    )
+    assert state.execute("SELECT count(*) FROM shards").fetchone()[0] == 2
+
+
+def test_parallel_partitions_resume_local_and_aggregate_state(tmp_path, monkeypatch):
+    source = tmp_path / "sources"
+    root = tmp_path / "release"
+    root.mkdir()
+    inventory = []
+    for partition in ["generation", "understanding"]:
+        for index in range(2):
+            _, record = make_source(source, partition, index, [f"{partition}:{index}"])
+            inventory.append(record)
+    converter.open_database(root / "conversion.sqlite3").close()
+    monkeypatch.setattr(
+        converter,
+        "download_shard",
+        lambda repo, revision, item, root, local_source: (source / item["path"], False),
+    )
+
+    def fake_upload(api, recipe, revision, full_inventory, records, previous):
+        connection = sqlite3.connect(root / "conversion.sqlite3", timeout=120)
+        for r in records:
+            connection.execute(
+                "UPDATE shards SET uploaded=1 WHERE path=?", (r["source_path"],)
+            )
+        connection.commit()
+        connection.close()
+        return "mock-remote-verified"
+
+    monkeypatch.setattr(converter, "upload_batch", fake_upload)
+    from concurrent.futures import ThreadPoolExecutor
+
+    recipe = dict(root=str(root), source="repo", target="target", snapshot="sft_data")
+    with ThreadPoolExecutor(max_workers=2) as pool:
+        results = [
+            pool.submit(
+                converter.convert_partition, recipe, "revision", inventory, p, 2, 2
+            )
+            for p in ["generation", "understanding"]
+        ]
+        assert {r.result() for r in results} == {"generation", "understanding"}
+    connection = sqlite3.connect(root / "conversion.sqlite3")
+    assert (
+        connection.execute("SELECT count(*) FROM shards WHERE uploaded=1").fetchone()[0]
+        == 4
+    )
+    for p in ["generation", "understanding"]:
+        converter.convert_partition(recipe, "revision", inventory, p, 2, 2)
+        local = sqlite3.connect(root / f"conversion-{p}.sqlite3")
+        assert local.execute("SELECT count(*) FROM audio").fetchone()[0] == 1
+        assert (
+            local.execute("SELECT count(*) FROM shards WHERE uploaded=1").fetchone()[0]
+            == 2
+        )
+
+
+def test_rebalanced_streams_retain_parent_audio_dependencies(tmp_path, monkeypatch):
+    import rebalance_streams
+    import sys
+
+    root = tmp_path / "release"
+    root.mkdir()
+    inventory = []
+    for index in range(3):
+        _, item = make_source(
+            tmp_path / "sources", "generation", index, [f"row:{index}"]
+        )
+        inventory.append(item)
+    state = converter.open_database(root / "conversion-generation-lane00.sqlite3")
+    first = converter.convert_shard(
+        tmp_path / "sources" / inventory[0]["path"],
+        inventory[0],
+        root,
+        state,
+        "repo",
+        "revision",
+    )
+    state.close()
+    aggregate = converter.open_database(root / "conversion.sqlite3")
+    aggregate.execute(
+        "INSERT INTO shards VALUES (?,?,1)", (first["source_path"], json.dumps(first))
+    )
+    aggregate.commit()
+    aggregate.close()
+    (root / "SOURCE_MANIFEST.json").write_text(json.dumps(dict(shards=inventory)))
+    (root / "STREAM_PLAN.json").write_text(
+        json.dumps(
+            [
+                dict(
+                    partition="generation",
+                    stream_id="generation-lane00",
+                    paths=[x["path"] for x in inventory],
+                )
+            ]
+        )
+    )
+    monkeypatch.setattr(
+        sys, "argv", ["rebalance_streams.py", "--root", str(root), "--max-shards", "1"]
+    )
+    rebalance_streams.main()
+    plan = json.loads((root / "STREAM_PLAN.json").read_text())
+    assert [x for s in plan for x in s["paths"]] == [x["path"] for x in inventory]
+    records = [first]
+    for stream, item in zip(plan[1:], inventory[1:]):
+        state = converter.open_database(
+            root / f"conversion-{stream['stream_id']}.sqlite3"
+        )
+        assert state.execute("SELECT count(*) FROM rows").fetchone()[0] == 1
+        record = converter.convert_shard(
+            tmp_path / "sources" / item["path"], item, root, state, "repo", "revision"
+        )
+        assert record["unique_audio_added"] == 0
+        records.append(record)
+        state.close()
+    for record in records:
+        safe_extract(root / record["archive_path"], tmp_path / "relocated")
+        output = json.loads(
+            (tmp_path / "relocated" / record["dialogue_path"]).read_text()
+        )
+        assert (
+            tmp_path / "relocated" / output["messages"][1][2]
+        ).read_bytes() == create_audio()
+
+
+@pytest.mark.parametrize("failure_phase", ["commit", "verify", "status"])
+def test_upload_retry_does_not_reuse_committed_operations(
+    tmp_path, monkeypatch, failure_phase
+):
+    from types import SimpleNamespace
+
+    source, inventory = make_source(tmp_path / "source", "generation", 0, ["row:0"])
+    state = converter.open_database(tmp_path / "conversion.sqlite3")
+    record = converter.convert_shard(
+        source, inventory, tmp_path, state, "repo", "revision"
+    )
+    state.close()
+
+    monkeypatch.setattr(converter.time, "sleep", lambda _: None)
+
+    class Api:
+        def __init__(self):
+            self.commits = 0
+            self.verifications = 0
+            self.status_updates = 0
+            self.operation_ids = set()
+
+        def preupload_lfs_files(self, *args, additions, **kwargs):
+            for operation in additions:
+                assert id(operation) not in self.operation_ids
+                self.operation_ids.add(id(operation))
+
+        def create_commit(self, *args, operations, **kwargs):
+            self.commits += 1
+            for operation in operations:
+                operation.path_or_fileobj = b""
+            if failure_phase == "commit" and self.commits == 1:
+                raise ConnectionError("Commit response unavailable")
+            return SimpleNamespace(oid="committed-revision")
+
+        def get_paths_info(self, *args, **kwargs):
+            self.verifications += 1
+            if failure_phase == "verify" and self.verifications == 1:
+                raise ConnectionError("Transient verification failure")
+            return [
+                SimpleNamespace(
+                    path=record["archive_path"],
+                    size=record["archive_bytes"],
+                    lfs=SimpleNamespace(sha256=record["archive_sha256"]),
+                )
+            ]
+
+        def upload_file(self, *args, **kwargs):
+            self.status_updates += 1
+            if failure_phase == "status" and self.status_updates == 1:
+                raise ConnectionError("Transient status failure")
+
+    api = Api()
+    result = converter.upload_batch(
+        api,
+        dict(root=str(tmp_path), target="repo", source="source", parallel=True),
+        "revision",
+        [inventory],
+        [record],
+        [],
+    )
+    assert result == "committed-revision"
+    assert api.commits == (2 if failure_phase == "commit" else 1)
+    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

validate_public_release.py

@@ -0,0 +1,124 @@
+#!/usr/bin/env python3
+"""Compare prepared public bundles with source rows and the actual ESPnet reader."""
+import argparse
+import hashlib
+import io
+import json
+from pathlib import Path
+import sys
+
+import numpy as np
+import pyarrow.parquet as pq
+import soundfile as sf
+
+from prepare_espnet import split_for_hash
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--root", type=Path, default=Path("/root/bagpiper-sft-conversion")
+    )
+    parser.add_argument(
+        "--espnet", type=Path, default=Path("/root/bagpiper-release-audit/espnet")
+    )
+    args = parser.parse_args()
+    sys.path.insert(0, str(args.espnet))
+    from espnet2.speechlm.dataloader.dataset import SingleDataset
+
+    report = []
+    for folder, dataset, snapshot, partition, shards in [
+        ("tts", "tts", "general_tts_data", "classical_tts", 1),
+        ("tts2", "tts", "general_tts_data", "intent_to_speech", 1),
+        ("general", "general", "sft_data", "generation", 2),
+        ("understanding", "general", "sft_data", "understanding", 2),
+    ]:
+        root = args.root / "remote-trial" / folder
+        preparation = json.loads((root / "PREPARATION.json").read_text())
+        status = json.loads(
+            (args.root / "releases" / dataset / "SOURCE_MANIFEST.json").read_text()
+        )
+        records = [r for r in status["shards"] if r["partition"] == partition][:shards]
+        prepared = root / "prepared" / partition
+        native = SingleDataset(str(prepared / "all.json"))
+        converted = [
+            json.loads(line)
+            for line in (prepared / "dialogues.jsonl").read_text().splitlines()
+        ]
+        originals = []
+        for record in records:
+            path = (
+                Path("/root/bagpiper-release-audit/sample-shards")
+                / snapshot
+                / record["path"]
+            )
+            if not path.exists():
+                from convert_release import download_shard
+
+                path, _ = download_shard(
+                    status["source_repository"],
+                    status["revision"],
+                    record,
+                    args.root / "public-validation-sources" / dataset,
+                )
+            assert hashlib.sha256(path.read_bytes()).hexdigest() == record["sha256"]
+            originals.extend(pq.read_table(path).to_pylist())
+        assert len(native) == len(converted) == len(originals)
+        train = set(json.loads((prepared / "train.json").read_text())["samples"])
+        valid = set(json.loads((prepared / "valid.json").read_text())["samples"])
+        assert not train & valid
+        assert train | valid == set(native.sample_ids)
+        audio_hashes = {"train": set(), "valid": set()}
+        for original, output in zip(originals, converted):
+            assert output["example_id"] == original["row_id"]
+            assert len(output["messages"]) == len(original["messages"])
+            for before, after in zip(original["messages"], output["messages"]):
+                assert after[:2] == [before["role"], before["modality"]]
+                if before["modality"] == "text":
+                    assert after[2] == before["content"]
+                else:
+                    assert Path(after[2]).read_bytes() == original["audio"]["bytes"]
+            split = "train" if original["row_id"] in train else "valid"
+            assert split == split_for_hash(original["audio_sha256"])
+            audio_hashes[split].add(original["audio_sha256"])
+        assert not audio_hashes["train"] & audio_hashes["valid"]
+        decoded = 0
+        for index in sorted({0, len(originals) // 2, len(originals) - 1}):
+            original = originals[index]
+            for role, modality, content in native[original["row_id"]]["dialogue"]:
+                if modality == "audio":
+                    waveform, rate = content
+                    expected, expected_rate = sf.read(
+                        io.BytesIO(original["audio"]["bytes"]),
+                        dtype="float32",
+                        always_2d=True,
+                    )
+                    assert rate == expected_rate == original["sample_rate"]
+                    np.testing.assert_array_equal(waveform, expected.T)
+                    decoded += 1
+        report.append(
+            dict(
+                repository=preparation["repo_id"],
+                revision=preparation["revision"],
+                partition=partition,
+                rows=len(originals),
+                decoded_waveforms=decoded,
+                preserved_text_order_audio=True,
+                disjoint_train_valid_audio=True,
+            )
+        )
+    result = dict(
+        state="passed",
+        checks=report,
+        total_rows=sum(r["rows"] for r in report),
+        decoded_waveforms=sum(r["decoded_waveforms"] for r in report),
+        limitations=["CPU reader verification; no GPU training or inference"],
+    )
+    (args.root / "PUBLIC_DOWNLOAD_VALIDATION.json").write_text(
+        json.dumps(result, indent=2) + "\n"
+    )
+    print(json.dumps(result, indent=2))
+
+
+if __name__ == "__main__":
+    main()