from __future__ import annotations from copy import deepcopy from importlib.util import find_spec from pathlib import Path import hashlib import tempfile import unittest from barbet_bgd.io import write_jsonl_gz_atomic from barbet_bgd.serializers_v2 import SERIALIZERS_V2, SerializationV2Error, parse_target_v2 from barbet_bgd.serializers_v3 import ( build_messages_v3, canonical_json_v3, parse_request_message_v3, validate_messages_v3, ) from barbet_bgd.export_sft_v3 import export_sft def _record(index: int = 0, split: str = "train") -> dict: return { "record_id": f"row:{index}", "source_group": 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": SERIALIZERS_V2[index % 4]}, "provenance": {"internal_audit_marker": "not-model-visible-747f"}, } def _quality(record: dict) -> dict: return {"record_id": record["record_id"], "disposition": "KEEP", "training_ready": True, "record_sha256": hashlib.sha256(canonical_json_v3(record).encode("utf-8")).hexdigest(), "hard_failures": [], "pipeline_checks": {"test": True}} def _write_shard(root: Path, index: int, records: list[dict], verdicts: list[dict] | None = None): write_jsonl_gz_atomic(root / "canonical" / f"part-{index:05d}.jsonl.gz", records) write_jsonl_gz_atomic(root / "quality" / "verdicts" / f"part-{index:05d}.quality.jsonl.gz", verdicts if verdicts is not None else [_quality(row) for row in records]) class ReleaseSerializerTests(unittest.TestCase): def test_all_output_syntaxes_are_explicit_and_lossless(self): for index, serializer in enumerate(SERIALIZERS_V2): with self.subTest(serializer=serializer): record = _record(index) record["target"]["edge_text"] = '<臺灣>\\n"' record["target"]["typed_numbers"] = [1, 1.0, None, False] messages = build_messages_v3(record) validate_messages_v3(record, messages) request = parse_request_message_v3(messages[1]["content"]) self.assertEqual(request["response_format"]["serializer"], serializer) self.assertEqual(parse_target_v2(request["response_format"]["empty_target_example"], serializer), {}) self.assertEqual(canonical_json_v3(parse_target_v2(messages[2]["content"], serializer)), canonical_json_v3(record["target"])) self.assertNotIn("not-model-visible-747f", messages[1]["content"]) self.assertNotIn("record_id", request) self.assertNotIn(record["record_id"], messages[1]["content"]) def test_changing_serializer_changes_model_visible_request(self): record = _record() first = build_messages_v3(record) record["presentation"]["serializer"] = "KEY_VALUE" second = build_messages_v3(record) self.assertNotEqual(first[1]["content"], second[1]["content"]) def test_changed_format_and_target_are_rejected(self): record = _record() messages = build_messages_v3(record) broken = deepcopy(messages) broken[1]["content"] = broken[1]["content"].replace('"serializer":"JSON"', '"serializer":"KEY_VALUE"') with self.assertRaises(SerializationV2Error): validate_messages_v3(record, broken) broken = deepcopy(messages) broken[2]["content"] = broken[2]["content"].replace("COPIED", "FAIL") with self.assertRaises(SerializationV2Error): validate_messages_v3(record, broken) @unittest.skipUnless(find_spec("pyarrow"), "pyarrow is required for Parquet export") class ReleaseExportTests(unittest.TestCase): @unittest.skipUnless(find_spec("datasets"), "datasets is required for native streaming check") def test_native_datasets_streams_messages_as_list_of_turns(self): from datasets import load_dataset with tempfile.TemporaryDirectory() as tmp: root = Path(tmp) records = [_record(index) for index in range(4)] _write_shard(root, 0, records) export_sft(root, root, expected_records=4, expected_split_counts={"train": 4}) streamed = load_dataset("parquet", data_files={"train": str(root / "data" / "train-00000.parquet")}, split="train", streaming=True, cache_dir=str(root / "hf-cache")) actual = list(streamed) self.assertEqual(len(actual), 4) for row, record in zip(actual, records, strict=True): self.assertEqual(row["messages"], build_messages_v3(record)) def test_fixed_schema_export_and_full_readback_across_splits(self): import pyarrow.parquet as pq with tempfile.TemporaryDirectory() as tmp: root = Path(tmp) train = [_record(index) for index in range(4)] validation = [_record(4, "validation")] _write_shard(root, 0, train) _write_shard(root, 1, validation) observed = [] def validator(row): observed.append(row["record_id"]) return _quality(row) report = export_sft(root, root, expected_records=5, expected_split_counts={"train": 4, "validation": 1}, batch_rows=1, batch_bytes=1024, record_validator=validator) self.assertTrue(report["verified"]) self.assertTrue(all(report["checks"].values())) self.assertEqual(report["readback_records"], 5) self.assertEqual(len(observed), 10) data = pq.read_table(root / "data" / "train-00000.parquet").to_pylist() self.assertEqual(len(data), 4) self.assertIsInstance(data[0]["messages"], list) self.assertEqual(data[0]["messages"], build_messages_v3(train[0])) self.assertTrue((root / "reports" / "sft-export-verification.json").is_file()) self.assertTrue((root / "reports" / "taiwan-usage.json").is_file()) self.assertTrue(report["checks"]["taiwan_usage_readback_identical"]) with self.assertRaises(FileExistsError): export_sft(root, root, expected_records=5, expected_split_counts={"train": 4, "validation": 1}) def test_duplicate_ids_and_source_group_split_leak_are_rejected(self): for duplicate_id in (True, False): with self.subTest(duplicate_id=duplicate_id), tempfile.TemporaryDirectory() as tmp: root = Path(tmp) first, second = _record(0), _record(1, "test") if duplicate_id: second["record_id"] = first["record_id"] else: second["source_group"] = first["source_group"] _write_shard(root, 0, [first]) _write_shard(root, 1, [second]) with self.assertRaisesRegex(ValueError, "duplicate record_id|source_group crosses splits"): export_sft(root, root, expected_records=2, expected_split_counts={"train": 1, "test": 1}) self.assertFalse((root / "reports" / "sft-export-verification.json").exists()) def test_verdict_rejection_and_unaligned_counts_fail_closed(self): for mode in ("reject", "missing", "wrong_id", "extra"): with self.subTest(mode=mode), tempfile.TemporaryDirectory() as tmp: root = Path(tmp) row = _record() quality = _quality(row) if mode == "reject": quality["disposition"] = "REJECT" if mode == "wrong_id": quality["record_id"] = "wrong" verdicts = [] if mode == "missing" else [quality] if mode == "extra": verdicts.append(quality) _write_shard(root, 0, [row], verdicts) with self.assertRaises(ValueError): export_sft(root, root, expected_records=1, expected_split_counts={"train": 1}) self.assertFalse((root / "reports" / "sft-export-verification.json").exists()) def test_lost_records_and_independent_validator_rejection_fail_closed(self): with tempfile.TemporaryDirectory() as tmp: root = Path(tmp) _write_shard(root, 0, [_record()]) with self.assertRaisesRegex(ValueError, "total/split count mismatch"): export_sft(root, root, expected_records=2, expected_split_counts={"train": 2}) with tempfile.TemporaryDirectory() as tmp: root = Path(tmp) _write_shard(root, 0, [_record()]) with self.assertRaisesRegex(ValueError, "independent record validator rejected"): export_sft(root, root, expected_records=1, expected_split_counts={"train": 1}, record_validator=lambda row: {"disposition": "REJECT"}) def test_stale_quality_hash_and_locale_review_do_not_pass(self): for mode in ("stale_hash", "locale_block", "locale_review"): with self.subTest(mode=mode), tempfile.TemporaryDirectory() as tmp: root = Path(tmp) row = _record() if mode == "locale_block": row["task_spec"]["query"] = "請檢查這個軟件。" if mode == "locale_review": row["task_spec"]["query"] = "請使用 opaque ID 識別候選項目。" quality = _quality(row) if mode == "stale_hash": row["target"]["output_text"] = "內容已經改動。" _write_shard(root, 0, [row], [quality]) with self.assertRaisesRegex(ValueError, "canonical record hash|Taiwan usage review/rejection"): export_sft(root, root, expected_records=1, expected_split_counts={"train": 1}) self.assertFalse((root / "reports" / "sft-export-verification.json").exists()) if __name__ == "__main__": unittest.main()