Datasets:
File size: 6,606 Bytes
0bf2389 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 | 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()
|