| """Additive parallel SFT export orchestrator; pinned core sources stay unchanged. |
| |
| Each worker calls the original exporter, including full quality, language, |
| serialization and Parquet readback checks. The parent additionally verifies |
| global ID/source-group constraints and merges reports in canonical shard order. |
| Run full release work only in a Slurm allocation. |
| """ |
| from __future__ import annotations |
|
|
| import argparse |
| from collections import Counter |
| from concurrent.futures import ProcessPoolExecutor, as_completed |
| from dataclasses import dataclass |
| import hashlib |
| import inspect |
| import json |
| import multiprocessing |
| import os |
| from pathlib import Path |
| import shutil |
| import sqlite3 |
| from typing import Any, Callable |
|
|
| from barbet_bgd.export_sft_v3 import EXPORT_VERSION, DEFAULT_SPLIT_COUNTS, export_sft as original_export_sft |
| from barbet_bgd.io import iter_jsonl_gz, sha256_file, write_json_atomic |
| from barbet_bgd.quality_v2 import validate_record_quality_v2 |
| from barbet_bgd.release_v3 import native_streaming_verify as original_native_streaming_verify |
| from barbet_bgd.serializers_v3 import canonical_json_v3 |
|
|
|
|
| WRAPPER_VERSION = "barbet.sft.parallel-release/1.0.0" |
| _SOURCE = Path(__file__).resolve() |
|
|
|
|
| @dataclass(frozen=True) |
| class Task: |
| index: int |
| canonical_path: str |
| quality_path: str |
| work_root: str |
| records: int |
| split: str |
| batch_rows: int |
| batch_bytes: int |
| validate_records: bool |
|
|
|
|
| @dataclass(frozen=True) |
| class NativeTask: |
| index: int |
| source_root: str |
| work_root: str |
| shard: dict[str, Any] |
|
|
|
|
| def _worker(task: Task) -> dict[str, Any]: |
| import pyarrow as pa |
| pa.set_cpu_count(1) |
| pa.set_io_thread_count(1) |
| canonical_path, quality_path = Path(task.canonical_path), Path(task.quality_path) |
| work = Path(task.work_root) |
| (work / "canonical").mkdir(parents=True, exist_ok=False) |
| (work / "quality" / "verdicts").mkdir(parents=True, exist_ok=False) |
| os.link(canonical_path, work / "canonical" / canonical_path.name) |
| os.link(quality_path, work / "quality" / "verdicts" / quality_path.name) |
| report = original_export_sft( |
| work, work, expected_records=task.records, expected_split_counts={task.split: task.records}, |
| record_validator=validate_record_quality_v2 if task.validate_records else None, |
| batch_rows=task.batch_rows, batch_bytes=task.batch_bytes, |
| ) |
| return {"index": task.index, "work_root": str(work), "report": report, |
| "taiwan": json.loads((work / "reports" / "taiwan-usage.json").read_text(encoding="utf-8"))} |
|
|
|
|
| def _native_worker(task: NativeTask) -> dict[str, Any]: |
| import pyarrow as pa |
| pa.set_cpu_count(1) |
| pa.set_io_thread_count(1) |
| source, work = Path(task.source_root), Path(task.work_root) |
| path = Path(task.shard["path"]) |
| if path.is_absolute() or ".." in path.parts: |
| raise ValueError("invalid native shard path") |
| if sha256_file(source / path) != task.shard["parquet_sha256"]: |
| raise ValueError("native input Parquet hash mismatch") |
| (work / path.parent).mkdir(parents=True, exist_ok=False) |
| os.link(source / path, work / path) |
| report = original_native_streaming_verify(work, { |
| "shards": [task.shard], "split_counts": {task.shard["split"]: task.shard["records"]}, |
| }) |
| if sha256_file(work / path) != task.shard["parquet_sha256"]: |
| raise ValueError("native input Parquet changed during verification") |
| return {"index": task.index, "work_root": str(work), "report": report} |
|
|
|
|
| def parallel_native_streaming_verify(root: Path, report: dict, *, workers: int = 32, |
| progress: Callable[[str], None] | None = print) -> dict: |
| if not os.environ.get("SLURM_JOB_ID"): |
| raise RuntimeError("parallel native verification requires a Slurm allocation") |
| allocated = int(os.environ.get("SLURM_CPUS_PER_TASK", workers)) |
| if workers < 1 or workers > min(32, allocated): |
| raise ValueError("invalid native worker count or Slurm allocation") |
| root = Path(root).resolve() |
| work_root = root / ".parallel-native-verification" |
| output_path = root / "reports/native-streaming-verification.json" |
| if work_root.exists() or output_path.exists(): |
| raise FileExistsError("refusing to overwrite existing or partial native verification") |
| shards = report["shards"] |
| if not shards or len({item["path"] for item in shards}) != len(shards): |
| raise ValueError("native shard coverage is empty or contains duplicate paths") |
| if report.get("verified") is not True or sum(item["records"] for item in shards) != report["records"]: |
| raise ValueError("native verification requires complete verified export") |
| work_root.mkdir(exist_ok=False) |
| wrapper_hash, core_hash = sha256_file(_SOURCE), sha256_file(inspect.getfile(original_native_streaming_verify)) |
| tasks = [NativeTask(index, str(root), str(work_root / f"shard-{index:05d}"), shard) |
| for index, shard in enumerate(shards)] |
| completed = {} |
| with ProcessPoolExecutor(max_workers=workers, mp_context=multiprocessing.get_context("spawn")) as executor: |
| futures = {executor.submit(_native_worker, task): task.index for task in tasks} |
| for future in as_completed(futures): |
| result = future.result() |
| if result["index"] in completed: |
| raise ValueError("duplicate native worker result") |
| completed[result["index"]] = result |
| if progress: |
| done = sum(item["report"]["records"] for item in completed.values()) |
| progress(f"Parallel native datasets verified {len(completed)}/{len(tasks)} shards; {done} records") |
| if (set(completed) != set(range(len(tasks))) or sha256_file(_SOURCE) != wrapper_hash |
| or sha256_file(inspect.getfile(original_native_streaming_verify)) != core_hash): |
| raise ValueError("native worker coverage incomplete or source changed") |
| counts, merged_shards, pins = Counter(), [], [] |
| datasets_version = None |
| for task in tasks: |
| result = completed[task.index] |
| worker = result["report"] |
| shard = task.shard |
| expected = {"path": shard["path"], "records": shard["records"], "rows_sha256": shard["rows_sha256"]} |
| if (worker.get("verified") is not True or worker.get("records") != shard["records"] |
| or worker.get("shards") != [expected] |
| or worker.get("split_counts") != {shard["split"]: shard["records"]}): |
| raise ValueError("native worker digest/count/split mismatch") |
| if datasets_version is None: |
| datasets_version = worker["datasets_version"] |
| elif datasets_version != worker["datasets_version"]: |
| raise ValueError("native workers used different datasets versions") |
| if sha256_file(root / shard["path"]) != shard["parquet_sha256"]: |
| raise ValueError("global Parquet changed after native verification") |
| source_path = Path(result["work_root"]) / "reports/native-streaming-verification.json" |
| if canonical_json_v3(json.loads(source_path.read_text(encoding="utf-8"))) != canonical_json_v3(worker): |
| raise ValueError("native worker report changed") |
| destination = root / "reports/parallel-workers" / f"shard-{task.index:05d}" / "native-streaming-verification.json" |
| destination.parent.mkdir(parents=True, exist_ok=True) |
| if destination.exists(): |
| raise FileExistsError("refusing to overwrite native worker report") |
| shutil.copyfile(source_path, destination) |
| pins.append({"path": destination.relative_to(root).as_posix(), "sha256": sha256_file(destination)}) |
| counts.update(worker["split_counts"]) |
| merged_shards.append(expected) |
| if dict(counts) != report["split_counts"] or sum(counts.values()) != report["records"]: |
| raise ValueError("native global count/split coverage mismatch") |
| merged = {"verified": True, "records": sum(counts.values()), "split_counts": dict(counts), |
| "shards": merged_shards, "datasets_version": datasets_version, |
| "parallel_provenance": { |
| "orchestrator_version": WRAPPER_VERSION, "orchestrator_sha256": wrapper_hash, |
| "core_native_verifier_sha256": core_hash, "workers": workers, |
| "slurm_job_id": os.environ["SLURM_JOB_ID"], "worker_report_pins": pins, |
| "core_sources_modified": False, |
| }} |
| write_json_atomic(output_path, merged) |
| return merged |
|
|
|
|
| def _inspect_shards(source: Path, canonical_dir: Path, quality_dir: Path, |
| expected_records: int, expected_split_counts: dict[str, int], |
| shard_size: int | None) -> list[tuple[Path, Path, int, str]]: |
| files = sorted(canonical_dir.glob("part-*.jsonl.gz")) |
| if not files: |
| raise ValueError("No canonical shards found") |
| expected_quality = {quality_dir / path.name.replace(".jsonl.gz", ".quality.jsonl.gz") for path in files} |
| if set(quality_dir.glob("part-*.quality.jsonl.gz")) != expected_quality: |
| raise ValueError("canonical/quality shard sets do not match") |
| |
| |
| manifest_path = source / "manifest.json" |
| manifest_shards: dict[str, dict] = {} |
| if manifest_path.is_file(): |
| manifest = json.loads(manifest_path.read_text(encoding="utf-8")) |
| for item in manifest.get("shards", []): |
| name = Path(item["canonical_path"]).name |
| if name in manifest_shards: |
| raise ValueError("duplicate manifest canonical shard") |
| manifest_shards[name] = item |
| if set(manifest_shards) != {path.name for path in files}: |
| raise ValueError("manifest/canonical shard sets do not match") |
| elif shard_size is None: |
| raise ValueError("production export requires the canonical build manifest") |
| results = [] |
| counts: Counter = Counter() |
| remaining = expected_records |
| for path in files: |
| quality = quality_dir / path.name.replace(".jsonl.gz", ".quality.jsonl.gz") |
| first = next(iter_jsonl_gz(path), None) |
| if first is None or first.get("split") not in DEFAULT_SPLIT_COUNTS: |
| raise ValueError("empty shard or invalid first-row split") |
| split = first["split"] |
| records = manifest_shards[path.name]["records"] if manifest_shards else min(shard_size, remaining) |
| if not isinstance(records, int) or records <= 0: |
| raise ValueError("invalid shard record count") |
| if manifest_shards: |
| item = manifest_shards[path.name] |
| |
| for key, target in (("canonical_sha256", path), ("verdict_sha256", quality)): |
| if key in item and sha256_file(target) != item[key]: |
| raise ValueError(f"manifest source hash mismatch: {target.name}") |
| remaining -= records |
| counts[split] += records |
| results.append((path, quality, records, split)) |
| if remaining or dict(counts) != {key: value for key, value in expected_split_counts.items() if value}: |
| raise ValueError("manifest shard counts do not match expected total/splits") |
| return results |
|
|
|
|
| def _merge_taiwan(results: list[dict[str, Any]], total: int, expected_serializers: set[str]) -> dict[str, Any]: |
| decisions, findings = Counter(), Counter() |
| examples: dict[str, list] = {} |
| templates: dict[str, dict] = {} |
| records = readback = 0 |
| static = None |
| for result in results: |
| report = result["taiwan"] |
| if report.get("passed") is not True or report.get("independent_readback_identical") is not True: |
| raise ValueError("worker Taiwan usage audit not passed") |
| current_static = {key: report[key] for key in ("ruleset_version", "limitations", "reference_sources", "human_reviewed")} |
| if static is None: |
| static = current_static |
| elif canonical_json_v3(static) != canonical_json_v3(current_static): |
| raise ValueError("worker Taiwan usage static rules differ") |
| records += report["records"] |
| readback += report["readback_records"] |
| decisions.update(report["decision_counts"]) |
| findings.update(report["finding_counts"]) |
| for rule, candidates in report["examples"].items(): |
| selected = examples.setdefault(rule, []) |
| selected.extend(candidates[:max(0, 3 - len(selected))]) |
| for serializer, template in report["rendering_templates"].items(): |
| if serializer in templates and canonical_json_v3(templates[serializer]) != canonical_json_v3(template): |
| raise ValueError("worker rendering templates differ") |
| templates[serializer] = template |
| if (records != total or readback != total or sum(decisions.values()) != total |
| or decisions.get("PASS", 0) != total or decisions.get("REJECT", 0) or decisions.get("REVIEW", 0)): |
| raise ValueError("merged Taiwan usage counts did not pass") |
| if set(templates) != expected_serializers: |
| raise ValueError("Taiwan usage rendering template coverage differs from exported serializers") |
| if total == 1_000_000 and set(templates) != {"JSON", "FUNCTION_CALL", "COMPACT_TAGS", "KEY_VALUE"}: |
| raise ValueError("full release requires all four audited rendering templates") |
| return {**static, "records": records, "readback_records": readback, "passed": True, |
| "independent_readback_identical": True, "decision_counts": dict(decisions), |
| "finding_counts": dict(findings), "examples": examples, "rendering_templates": templates} |
|
|
|
|
| def parallel_export_sft( |
| canonical_root: str | Path, output_root: str | Path, *, quality_root: str | Path | None = None, |
| expected_records: int = 1_000_000, expected_split_counts: dict[str, int] | None = None, |
| record_validator: Callable | None = None, batch_rows: int = 32, batch_bytes: int = 8 * 1024 * 1024, |
| progress: Callable[[str], None] | None = None, workers: int = 32, shard_size: int | None = None, |
| ) -> dict[str, Any]: |
| if not os.environ.get("SLURM_JOB_ID"): |
| raise RuntimeError("parallel release export requires a Slurm allocation") |
| if workers < 1 or workers > 32: |
| raise ValueError("workers must be between 1 and 32") |
| allocated = int(os.environ.get("SLURM_CPUS_PER_TASK", workers)) |
| if workers > allocated: |
| raise ValueError("worker count exceeds Slurm CPU allocation") |
| import pyarrow as pa |
| pa.set_cpu_count(1) |
| pa.set_io_thread_count(1) |
| |
| if record_validator not in (None, validate_record_quality_v2): |
| raise ValueError("unsupported worker record_validator") |
| split_targets = dict(DEFAULT_SPLIT_COUNTS if expected_split_counts is None else expected_split_counts) |
| if expected_records <= 0 or sum(split_targets.values()) != expected_records: |
| raise ValueError("invalid expected record/split counts") |
| source, output = Path(canonical_root).resolve(), Path(output_root).resolve() |
| canonical_dir = source / "canonical" if (source / "canonical").is_dir() else source |
| quality_dir = Path(quality_root).resolve() if quality_root else source / "quality" / "verdicts" |
| data_dir, work_root = output / "data", output / ".parallel-sft-export" |
| report_path, taiwan_path = output / "reports/sft-export-verification.json", output / "reports/taiwan-usage.json" |
| if any(path.exists() for path in (data_dir, work_root, report_path, taiwan_path)): |
| raise FileExistsError("refusing to overwrite an existing or partial parallel SFT export") |
| source_shards = _inspect_shards(source, canonical_dir, quality_dir, expected_records, split_targets, shard_size) |
| data_dir.mkdir(parents=True, exist_ok=False) |
| work_root.mkdir(exist_ok=False) |
| wrapper_hash = sha256_file(_SOURCE) |
| core_hash = sha256_file(inspect.getfile(original_export_sft)) |
| tasks = [Task(index, str(canonical), str(quality), str(work_root / f"shard-{index:05d}"), |
| count, split, batch_rows, batch_bytes, record_validator is not None) |
| for index, (canonical, quality, count, split) in enumerate(source_shards)] |
| completed: dict[int, dict[str, Any]] = {} |
| with ProcessPoolExecutor(max_workers=workers, mp_context=multiprocessing.get_context("spawn")) as executor: |
| futures = {executor.submit(_worker, task): task.index for task in tasks} |
| for future in as_completed(futures): |
| result = future.result() |
| if result["index"] in completed: |
| raise ValueError("duplicate parallel worker result") |
| completed[result["index"]] = result |
| if progress: |
| done = sum(item["report"]["records"] for item in completed.values()) |
| progress(f"Parallel SFT verified {len(completed)}/{len(tasks)} shards; {done} records") |
| if (set(completed) != set(range(len(tasks))) or sha256_file(_SOURCE) != wrapper_hash |
| or sha256_file(inspect.getfile(original_export_sft)) != core_hash): |
| raise ValueError("worker coverage incomplete or wrapper source changed") |
| ordered = [completed[index] for index in range(len(tasks))] |
| reference = ordered[0]["report"] |
| checks, static_fields = reference["checks"], ("export_version", "messages_version", "pyarrow_version", "schema", "independent_record_validator") |
| counts, serializers, families = Counter(), Counter(), Counter() |
| merged_shards = [] |
| sqlite_path = work_root / "global-validation.sqlite" |
| connection = sqlite3.connect(sqlite_path) |
| connection.execute("PRAGMA cache_size=-8192") |
| connection.execute("PRAGMA temp_store=FILE") |
| connection.execute("CREATE TABLE ids (record_id TEXT PRIMARY KEY) WITHOUT ROWID") |
| connection.execute("CREATE TABLE groups (source_group TEXT PRIMARY KEY, split TEXT NOT NULL) WITHOUT ROWID") |
| import pyarrow.parquet as pq |
| global_rows = 0 |
| worker_report_pins = [] |
| try: |
| for task, result in zip(tasks, ordered, strict=True): |
| report, work = result["report"], Path(result["work_root"]) |
| if report.get("verified") is not True or not report["checks"] or not all(value is True for value in report["checks"].values()): |
| raise ValueError("worker export report did not pass") |
| if set(report["checks"]) != set(checks): |
| raise ValueError("worker check schemas differ") |
| for name in static_fields: |
| if report[name] != reference[name]: |
| raise ValueError(f"worker export static metadata differs: {name}") |
| if len(report["shards"]) != 1 or report["records"] != task.records or report["readback_records"] != task.records: |
| raise ValueError("worker shard coverage mismatch") |
| original_info = report["shards"][0] |
| original_path = work / original_info["path"] |
| if original_info["split"] != task.split or report["split_counts"] != {task.split: task.records}: |
| raise ValueError("worker split mismatch") |
| if sha256_file(original_path) != original_info["parquet_sha256"]: |
| raise ValueError("worker Parquet changed after verification") |
| if sha256_file(task.canonical_path) != original_info["canonical_sha256"] or sha256_file(task.quality_path) != original_info["quality_sha256"]: |
| raise ValueError("canonical/quality changed after worker verification") |
| destination = data_dir / f"{task.split}-{task.index:05d}.parquet" |
| os.link(original_path, destination) |
| local_rows = 0 |
| for batch in pq.ParquetFile(destination).iter_batches(batch_size=2048, columns=["record_id", "source_group", "split"]): |
| for row in batch.to_pylist(): |
| if row["split"] != task.split: |
| raise ValueError("global readback split mismatch") |
| try: |
| connection.execute("INSERT INTO ids VALUES (?)", (row["record_id"],)) |
| except sqlite3.IntegrityError as error: |
| raise ValueError(f"duplicate global record_id: {row['record_id']}") from error |
| previous = connection.execute("SELECT split FROM groups WHERE source_group=?", (row["source_group"],)).fetchone() |
| if previous is None: |
| connection.execute("INSERT INTO groups VALUES (?,?)", (row["source_group"], row["split"])) |
| elif previous[0] != row["split"]: |
| raise ValueError(f"global source_group crosses splits: {row['source_group']}") |
| local_rows += 1 |
| if local_rows != task.records or sha256_file(destination) != original_info["parquet_sha256"]: |
| raise ValueError("global readback row count or Parquet hash mismatch") |
| global_rows += local_rows |
| connection.commit() |
| counts.update(report["split_counts"]) |
| serializers.update(report["serializer_counts"]) |
| families.update(report["task_family_counts"]) |
| merged_shards.append({**original_info, "path": destination.relative_to(output).as_posix()}) |
| for name in ("sft-export-verification.json", "taiwan-usage.json"): |
| path = work / "reports" / name |
| expected = report if name.startswith("sft-") else result["taiwan"] |
| if canonical_json_v3(json.loads(path.read_text(encoding="utf-8"))) != canonical_json_v3(expected): |
| raise ValueError("worker report changed during aggregation") |
| public_path = output / "reports" / "parallel-workers" / f"shard-{task.index:05d}" / name |
| public_path.parent.mkdir(parents=True, exist_ok=True) |
| shutil.copyfile(path, public_path) |
| worker_report_pins.append({"path": public_path.relative_to(output).as_posix(), |
| "sha256": sha256_file(public_path), |
| "global_parquet_path": destination.relative_to(output).as_posix()}) |
| unique_ids = connection.execute("SELECT count(*) FROM ids").fetchone()[0] |
| source_groups = connection.execute("SELECT count(*) FROM groups").fetchone()[0] |
| finally: |
| connection.close() |
| if global_rows != expected_records or unique_ids != expected_records or dict(counts) != {key: value for key, value in split_targets.items() if value}: |
| raise ValueError("global total/ID/split counts failed") |
| taiwan = _merge_taiwan(ordered, expected_records, set(serializers)) |
| write_json_atomic(taiwan_path, taiwan) |
| provenance = { |
| "orchestrator_version": WRAPPER_VERSION, "orchestrator_sha256": wrapper_hash, |
| "core_exporter_sha256": core_hash, |
| "workers": workers, "slurm_job_id": os.environ["SLURM_JOB_ID"], |
| "core_sources_modified": False, "worker_report_pins": worker_report_pins, |
| "global_record_identity_rows_verified": global_rows, |
| } |
| merged = { |
| **{name: reference[name] for name in static_fields}, |
| "records": expected_records, "readback_records": expected_records, |
| "unique_record_ids": unique_ids, "source_groups": source_groups, |
| "split_counts": dict(counts), "serializer_counts": dict(serializers), |
| "task_family_counts": dict(families), "shards": merged_shards, |
| "taiwan_usage_report": taiwan_path.relative_to(output).as_posix(), |
| "taiwan_usage_report_sha256": sha256_file(taiwan_path), |
| "checks": {**checks, "parallel_worker_reports_verified": True, |
| "global_cross_shard_identity_verified": True}, |
| "verified": True, "parallel_provenance": provenance, |
| } |
| write_json_atomic(output / "reports/parallel-export-provenance.json", provenance) |
| write_json_atomic(report_path, merged) |
| return merged |
|
|
|
|
| def finalize_parallel(root: Path, workers: int) -> dict[str, Any]: |
| from barbet_bgd import release_v3 |
| release_v3.require_compute() |
| tools_dir = root / "release_tools" |
| tools_dir.mkdir(exist_ok=False) |
| shutil.copyfile(_SOURCE, tools_dir / _SOURCE.name) |
| tooling = {"version": WRAPPER_VERSION, "path": "release_tools/" + _SOURCE.name, |
| "sha256": sha256_file(_SOURCE), "original_source_snapshot_unchanged": True} |
| write_json_atomic(tools_dir / "manifest.json", tooling) |
| def configured_export(*args, **kwargs): |
| return parallel_export_sft(*args, **kwargs, workers=workers) |
| def configured_native(*args, **kwargs): |
| return parallel_native_streaming_verify(*args, **kwargs, workers=workers) |
| release_v3.export_sft = configured_export |
| release_v3.native_streaming_verify = configured_native |
| report = release_v3.finalize(root) |
| report["parallel_orchestrator"] = tooling |
| write_json_atomic(root / "reports/release-verification.json", report) |
| return report |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser() |
| parser.add_argument("command", choices=["finalize"]) |
| parser.add_argument("--output", type=Path, required=True) |
| parser.add_argument("--workers", type=int, default=32) |
| args = parser.parse_args() |
| result = finalize_parallel(args.output.resolve(), args.workers) |
| print(json.dumps(result, ensure_ascii=False, indent=2), flush=True) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
