| from __future__ import annotations |
|
|
| import json |
| import tempfile |
| import unittest |
| from pathlib import Path |
|
|
| from barbet_bgd.generation import GenerationPlan, generate_record |
| from barbet_bgd.io import iter_jsonl_gz, write_json_atomic, write_jsonl_gz_atomic |
| from barbet_bgd.quality_cli import run_quality_validation |
|
|
|
|
| ROOT = Path(__file__).resolve().parents[1] |
| CONFIG_PATH = ROOT / "configs" / "selected_sft_1m.json" |
|
|
|
|
| class QualityRunnerTests(unittest.TestCase): |
| def _canonical_fixture(self, root: Path, records: int = 30) -> Path: |
| config = json.loads(CONFIG_PATH.read_text(encoding="utf-8")) |
| plan = GenerationPlan(config) |
| dataset_root = root / "dataset" |
| canonical_root = dataset_root / "canonical" |
| shards = [] |
| for shard_index, start in enumerate(range(0, records, 15)): |
| end = min(records, start + 15) |
| result = write_jsonl_gz_atomic( |
| canonical_root / f"part-{shard_index:05d}.jsonl.gz", |
| (generate_record(config, plan, index) for index in range(start, end)), |
| ) |
| shards.append(result.to_dict()) |
| write_json_atomic(dataset_root / "config.snapshot.json", config) |
| manifest = { |
| "manifest_version": "bgd.manifest.v1", |
| "metadata": { |
| "config_sha256": self._semantic_hash(config), |
| "dataset_name": config["dataset_name"], |
| }, |
| "shards": shards, |
| "totals": { |
| "records": records, |
| "shards": len(shards), |
| }, |
| } |
| write_json_atomic(dataset_root / "manifest.json", manifest) |
| return dataset_root |
|
|
| @staticmethod |
| def _semantic_hash(value: dict) -> str: |
| import hashlib |
|
|
| payload = json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":")) |
| return hashlib.sha256(payload.encode("utf-8")).hexdigest() |
|
|
| def test_materialises_and_independently_verifies_every_record(self) -> None: |
| with tempfile.TemporaryDirectory() as tmp: |
| root = Path(tmp) |
| dataset_root = self._canonical_fixture(root) |
| output_root = root / "quality" |
|
|
| verified = run_quality_validation( |
| dataset_root=dataset_root, |
| generation_config_path=CONFIG_PATH, |
| output_root=output_root, |
| project_root=ROOT, |
| workers=2, |
| ) |
|
|
| self.assertTrue(verified["quality_artifacts_verified"]) |
| self.assertEqual(verified["records"], 30) |
| self.assertEqual(verified["shards"], 2) |
| self.assertTrue((output_root / "_QUALITY_COMPLETE.json").is_file()) |
| self.assertTrue((output_root / "_QUALITY_VERIFIED.json").is_file()) |
| self.assertTrue((output_root / "reports" / "postwrite-verification.json").is_file()) |
|
|
| quality_manifest = json.loads( |
| (output_root / "manifest.json").read_text(encoding="utf-8") |
| ) |
| self.assertEqual(quality_manifest["totals"]["records"], 30) |
| self.assertEqual([shard["start_index"] for shard in quality_manifest["shards"]], [0, 15]) |
| verdicts = [] |
| for shard in quality_manifest["shards"]: |
| verdicts.extend(iter_jsonl_gz(shard["verdict_path"])) |
| self.assertEqual(len(verdicts), 30) |
| self.assertEqual(verdicts[0]["record_index"], 0) |
| self.assertEqual(verdicts[0]["expected_record_index"], 0) |
| self.assertEqual(verdicts[15]["record_index"], 15) |
| self.assertEqual(verdicts[15]["source_line"], 1) |
|
|
| report = json.loads((output_root / "report.json").read_text(encoding="utf-8")) |
| self.assertTrue(report["all_records_audited"]) |
| self.assertFalse(report["training_promotion_passed"]) |
| self.assertFalse(report["public_release_promotion_passed"]) |
| self.assertTrue(report["quality_gates"]["all_records_exactly_reproduced"]) |
| self.assertTrue(report["config_contract"]["explicit_generation_config_used"]) |
| self.assertFalse(report["config_contract"]["snapshot_used_for_exact_regeneration"]) |
| self.assertTrue(report["config_contract"]["snapshot_generation_plan_equal"]) |
| self.assertIn("target_decision_by_task_family", report["statistics"]) |
| self.assertIn("confidence_target_histogram", report["statistics"]) |
| self.assertEqual( |
| sum(report["statistics"]["confidence_target_histogram"].values()), |
| 30, |
| ) |
| self.assertEqual( |
| sum( |
| count |
| for outcomes in report["statistics"][ |
| "target_decision_by_task_family" |
| ].values() |
| for count in outcomes.values() |
| ), |
| 30, |
| ) |
|
|
| def test_max_records_writes_an_aligned_partial_sidecar(self) -> None: |
| with tempfile.TemporaryDirectory() as tmp: |
| root = Path(tmp) |
| dataset_root = self._canonical_fixture(root) |
| output_root = root / "quality-partial" |
| verified = run_quality_validation( |
| dataset_root=dataset_root, |
| generation_config_path=CONFIG_PATH, |
| output_root=output_root, |
| project_root=ROOT, |
| workers=1, |
| max_records=7, |
| ) |
| self.assertEqual(verified["records"], 7) |
| report = json.loads((output_root / "report.json").read_text(encoding="utf-8")) |
| self.assertTrue(report["all_records_audited"]) |
| self.assertTrue(report["partial_run"]) |
| self.assertFalse(report["quality_gates"]["full_corpus_audited"]) |
|
|
| def test_rejects_a_canonical_shard_checksum_mismatch(self) -> None: |
| with tempfile.TemporaryDirectory() as tmp: |
| root = Path(tmp) |
| dataset_root = self._canonical_fixture(root, records=15) |
| shard_path = next((dataset_root / "canonical").glob("*.jsonl.gz")) |
| shard_path.write_bytes(shard_path.read_bytes() + b"tamper") |
| with self.assertRaisesRegex(ValueError, "canonical checksum mismatch"): |
| run_quality_validation( |
| dataset_root=dataset_root, |
| generation_config_path=CONFIG_PATH, |
| output_root=root / "quality-bad-source", |
| project_root=ROOT, |
| workers=1, |
| ) |
|
|
|
|
| if __name__ == "__main__": |
| unittest.main() |
|
|
