"""Small compute-only multi-shard equivalence and global leak regressions.""" from itertools import islice import json import os from pathlib import Path import time import unittest from barbet_bgd.io import iter_jsonl_gz, sha256_file, write_json_atomic, write_jsonl_gz_atomic from barbet_bgd.export_sft_v3 import export_sft from barbet_bgd.quality_v2 import validate_record_quality_v2 from barbet_bgd.release_v3 import native_streaming_verify from barbet_bgd.serializers_v3 import canonical_json_v3 from parallel_release import parallel_export_sft, parallel_native_streaming_verify ROOT = Path("/groups/voidful/barbet-sft") / ("parallel-bench-" + os.environ.get("SLURM_JOB_ID", "NO_JOB")) def _minimal(index, split, group=None, record_id=None): record = { "record_id": record_id or f"row:{index}", "source_group": group or f"group:{index}", "split": split, "primitive": "COPY", "task_family": "FAITHFUL_OCR", "locale": "zh-TW", "task_spec": {"query": "請保留來源文字。", "requested_schema": {}}, "inputs": [{"id": "src", "units": [{"id": "src:u01", "text": "臺灣資料。"}]}], "target": {"decision": "COPIED", "evidence": ["src:u01"], "output_text": "臺灣資料。"}, "presentation": {"serializer": "JSON"}, } import hashlib verdict = {"record_id": record["record_id"], "record_sha256": hashlib.sha256(canonical_json_v3(record).encode()).hexdigest(), "disposition": "KEEP", "training_ready": True, "hard_failures": [], "pipeline_checks": {"test": True}} return record, verdict class ParallelReleaseTests(unittest.TestCase): @classmethod def setUpClass(cls): if not os.environ.get("SLURM_JOB_ID"): raise RuntimeError("Slurm compute allocation required") ROOT.mkdir(exist_ok=False) def test_real_three_split_equivalence_and_native_streaming(self): import pyarrow.parquet as pq source = ROOT / "real-source" original = Path("/groups/voidful/barbet-sft/release_v3") for dest_index, source_index in enumerate((0, 98, 99)): canonical = list(islice(iter_jsonl_gz(original / "canonical" / f"part-{source_index:05d}.jsonl.gz"), 20)) quality = list(islice(iter_jsonl_gz(original / "quality/verdicts" / f"part-{source_index:05d}.quality.jsonl.gz"), 20)) write_jsonl_gz_atomic(source / "canonical" / f"part-{dest_index:05d}.jsonl.gz", canonical) write_jsonl_gz_atomic(source / "quality/verdicts" / f"part-{dest_index:05d}.quality.jsonl.gz", quality) sizes = {"train": 20, "validation": 20, "test": 20} start = time.perf_counter() serial = export_sft(source, ROOT / "serial", expected_records=60, expected_split_counts=sizes, record_validator=validate_record_quality_v2) serial_seconds = time.perf_counter() - start start = time.perf_counter() parallel = parallel_export_sft(source, ROOT / "parallel", expected_records=60, expected_split_counts=sizes, record_validator=validate_record_quality_v2, workers=3, shard_size=20, progress=print) parallel_seconds = time.perf_counter() - start for name in ("records", "readback_records", "unique_record_ids", "source_groups", "split_counts", "serializer_counts", "task_family_counts", "schema"): self.assertEqual(serial[name], parallel[name], name) self.assertTrue(all(parallel["checks"].values())) for first, second in zip(serial["shards"], parallel["shards"], strict=True): for name in ("path", "canonical_sha256", "quality_sha256", "rows_sha256", "records", "split", "first_record_id", "last_record_id"): self.assertEqual(first[name], second[name], name) self.assertEqual(pq.read_table(ROOT / "serial" / first["path"]).to_pylist(), pq.read_table(ROOT / "parallel" / second["path"]).to_pylist()) self.assertEqual(json.loads((ROOT / "serial/reports/taiwan-usage.json").read_text()), json.loads((ROOT / "parallel/reports/taiwan-usage.json").read_text())) serial_native = native_streaming_verify(ROOT / "serial", serial) native = parallel_native_streaming_verify(ROOT / "parallel", parallel, workers=3) self.assertTrue(native["verified"]) for name in ("records", "split_counts", "shards", "datasets_version"): self.assertEqual(serial_native[name], native[name], name) self.assertEqual(len(native["parallel_provenance"]["worker_report_pins"]), 3) write_json_atomic(ROOT / "equivalence.json", {"verified": True, "records": 60, "serial_seconds": serial_seconds, "parallel_seconds": parallel_seconds, "native_verified": native["verified"]}) with self.assertRaises(FileExistsError): parallel_export_sft(source, ROOT / "parallel", expected_records=60, expected_split_counts=sizes, workers=3, shard_size=20) def test_global_duplicate_record_ids_across_workers_fail(self): source = ROOT / "duplicate-source" for index in range(2): record, quality = _minimal(index, "train", record_id="same-id") write_jsonl_gz_atomic(source / "canonical" / f"part-{index:05d}.jsonl.gz", [record]) write_jsonl_gz_atomic(source / "quality/verdicts" / f"part-{index:05d}.quality.jsonl.gz", [quality]) with self.assertRaisesRegex(ValueError, "duplicate global record_id"): parallel_export_sft(source, ROOT / "duplicate-output", expected_records=2, expected_split_counts={"train": 2}, workers=2, shard_size=1) self.assertFalse((ROOT / "duplicate-output/reports/sft-export-verification.json").exists()) def test_global_source_group_leak_across_workers_fails(self): source = ROOT / "group-source" for index, split in enumerate(("train", "test")): record, quality = _minimal(index, split, group="same-group") write_jsonl_gz_atomic(source / "canonical" / f"part-{index:05d}.jsonl.gz", [record]) write_jsonl_gz_atomic(source / "quality/verdicts" / f"part-{index:05d}.quality.jsonl.gz", [quality]) with self.assertRaisesRegex(ValueError, "global source_group crosses splits"): parallel_export_sft(source, ROOT / "group-output", expected_records=2, expected_split_counts={"train": 1, "test": 1}, workers=2, shard_size=1) self.assertFalse((ROOT / "group-output/reports/sft-export-verification.json").exists()) if __name__ == "__main__": unittest.main(verbosity=2)