| 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() |
|
|
