from __future__ import annotations import hashlib import json import tempfile import unittest from pathlib import Path from barbet_bgd.audit import StatsAccumulator, write_manifest, write_report from barbet_bgd.io import ( iter_gzip_jsonl, iter_jsonl_gz, sha256_file, write_gzip_jsonl_atomic, write_jsonl_gz_atomic, ) def _record( record_id: str, *, split: str = "train", source_text: str = "模型將於九月十五日上線。", evidence: str = "src:w03", context_bucket: str = "0.5K-4K", intentional_simplified: bool = False, ) -> dict: return { "record_id": record_id, "schema_version": "bgd.canonical.v1", "primitive": "VERIFY", "mixture_category": "VERIFICATION_QE_ERROR_LOCALIZATION", "task_family": "ASR_QUALITY", "domain": "meeting", "language": ["zh-TW", "en"], "locale": "zh-TW", "split": split, "source_group": "synthetic-test", "task_spec": {"instruction": "判斷候選是否忠實，並引用證據。"}, "inputs": [ { "id": "src", "type": "reference_text", "units": [ {"id": "src:w01", "text": "模型"}, {"id": "src:w03", "text": source_text}, ], }, { "id": "hyp", "type": "asr_hypothesis", "units": [{"id": "hyp:w03", "text": "模型將於九月五日上線。"}], }, ], "target": { "decision": "FAIL", "confidence_target": 0.98, "errors": [ { "type": "VALUE_CORRUPTION", "source_evidence": [evidence], "target_evidence": ["hyp:w03"], } ], "action": {"tool": "EDIT", "arguments": {"target": "hyp:w03"}}, }, "component_targets": {}, "presentation": { "serializer": "JSON", "serializer_version": "1", }, "provenance": {"source_hash": "0" * 64}, "quality": { "context_length_bucket": context_bucket, "intentional_negative_simplified_hits": ( [{"unit_id": "src:w03", "hits": ["这"]}] if intentional_simplified else [] ) }, } class AtomicGzipJsonlTests(unittest.TestCase): def test_round_trip_digest_and_deterministic_bytes(self) -> None: rows = [_record("bgd-001"), _record("bgd-002", split="validation")] with tempfile.TemporaryDirectory() as tmp: root = Path(tmp) first = write_gzip_jsonl_atomic(root / "first.jsonl.gz", rows) second = write_gzip_jsonl_atomic(root / "second.jsonl.gz", rows) self.assertEqual(list(iter_gzip_jsonl(first.path)), rows) self.assertEqual(first.records, 2) self.assertEqual(first.record_count, 2) self.assertEqual(first.sha256, sha256_file(first.path)) self.assertEqual(first.sha256, second.sha256) self.assertEqual( first.sha256, hashlib.sha256(first.path.read_bytes()).hexdigest(), ) self.assertFalse((root / "first.jsonl.gz.incomplete").exists()) alias = write_jsonl_gz_atomic(root / "alias.jsonl.gz", rows) self.assertEqual(list(iter_jsonl_gz(alias.path)), rows) def test_failed_write_preserves_published_file_and_cleans_incomplete(self) -> None: with tempfile.TemporaryDirectory() as tmp: path = Path(tmp) / "shard.jsonl.gz" path.write_bytes(b"published") def bad_rows(): yield _record("bgd-001") yield {"not_json": object()} with self.assertRaises(TypeError): write_gzip_jsonl_atomic(path, bad_rows()) self.assertEqual(path.read_bytes(), b"published") self.assertFalse(Path(f"{path}.incomplete").exists()) class StatsAccumulatorTests(unittest.TestCase): def test_ingest_counts_distributions_and_integrity_findings(self) -> None: stats = StatsAccumulator() stats.ingest(_record("same-id")) stats.ingest( _record( "same-id", split="test", source_text="这个模型将上线。", evidence="src:missing", context_bucket="4K-16K", ) ) result = stats.to_dict() self.assertEqual(result["total_records"], 2) self.assertEqual(result["split"], {"test": 1, "train": 1}) self.assertEqual(result["primitive"], {"VERIFY": 2}) self.assertEqual( result["mixture_category"], {"VERIFICATION_QE_ERROR_LOCALIZATION": 2} ) self.assertEqual(result["task_family"], {"ASR_QUALITY": 2}) self.assertEqual(result["domain"], {"meeting": 2}) self.assertEqual(result["serializer"], {"JSON": 2}) self.assertEqual(result["decision"], {"FAIL": 2}) self.assertEqual(result["error_type"], {"VALUE_CORRUPTION": 2}) self.assertEqual(result["action"], {"EDIT": 2}) self.assertEqual(result["context_bucket"], {"0.5K-4K": 1, "4K-16K": 1}) self.assertEqual(result["primary_zh_tw_records"], 2) self.assertEqual(result["primary_zh_tw_ratio"], 1.0) self.assertEqual(result["simplified_only_hit_records"], 1) self.assertEqual(result["duplicate_record_ids"], 1) self.assertEqual(result["duplicate_record_id_occurrences"], 1) self.assertEqual(result["evidence_reference_missing"], 1) self.assertEqual(result["evidence_reference_missing_records"], 1) def test_merge_detects_cross_shard_duplicates_and_annotations(self) -> None: left = StatsAccumulator().ingest(_record("shared")) right = StatsAccumulator().ingest( _record( "shared", source_text="这个模型将上线。", intentional_simplified=True, ) ) merged = left.merge(right).to_dict() self.assertEqual(merged["total_records"], 2) self.assertEqual(merged["duplicate_record_ids"], 1) self.assertEqual(merged["duplicate_record_id_occurrences"], 1) self.assertEqual(merged["simplified_only_hit_records"], 1) self.assertEqual(merged["intentional_negative_simplified_hit_records"], 1) self.assertEqual(merged["unannotated_simplified_only_hit_records"], 0) def test_manifest_and_report_are_atomic_json(self) -> None: rows = [_record("bgd-001")] with tempfile.TemporaryDirectory() as tmp: root = Path(tmp) shard = write_gzip_jsonl_atomic(root / "shard.jsonl.gz", rows) stats = StatsAccumulator().ingest(rows[0]) manifest_path = write_manifest( root / "manifest.json", [shard], stats=stats, metadata={"dataset_name": "unit-test"}, ) report_path = write_report(root / "report.json", stats) manifest = json.loads(manifest_path.read_text(encoding="utf-8")) report = json.loads(report_path.read_text(encoding="utf-8")) self.assertEqual(manifest["totals"]["records"], 1) self.assertEqual(manifest["shards"][0]["sha256"], shard.sha256) self.assertEqual(manifest["metadata"]["dataset_name"], "unit-test") self.assertTrue(report["checks"]["all_records_primary_zh_tw"]) self.assertTrue(report["checks"]["record_ids_unique"]) self.assertFalse(Path(f"{manifest_path}.incomplete").exists()) self.assertFalse(Path(f"{report_path}.incomplete").exists()) if __name__ == "__main__": unittest.main()