| """Materialise and independently verify one quality verdict per BGD record. |
| |
| The canonical dataset is immutable input. This command streams each canonical |
| shard into a corresponding deterministic gzip JSONL sidecar, then performs a |
| second pass over both datasets to prove record-for-record alignment. |
| |
| Exact regeneration intentionally uses the explicitly supplied, immutable |
| generation configuration. It does not use ``config.snapshot.json`` because |
| snapshot publication can rewrite serialization details; this also keeps the |
| audit contract valid for historical generators that were key-order sensitive. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import hashlib |
| import json |
| import sys |
| from collections import Counter, defaultdict |
| from collections.abc import Mapping, Sequence |
| from concurrent.futures import ProcessPoolExecutor, as_completed |
| from dataclasses import dataclass, field |
| from pathlib import Path |
| from typing import Any, Iterator |
|
|
| from .generation import GenerationPlan |
| from .io import ( |
| ShardResult, |
| iter_jsonl_gz, |
| sha256_file, |
| write_json_atomic, |
| write_jsonl_gz_atomic, |
| ) |
| from .quality import QUALITY_SCHEMA_VERSION, canonical_sha256, validate_record_quality |
|
|
|
|
| QUALITY_MANIFEST_VERSION = "bgd.quality.manifest.v1" |
| QUALITY_REPORT_VERSION = "bgd.quality.report.v1" |
| QUALITY_POSTWRITE_VERSION = "bgd.quality.postwrite.v1" |
| QUALITY_MARKER_VERSION = "bgd.quality.marker.v1" |
| SOURCE_BUNDLE_VERSION = "bgd.quality.source-bundle.v1" |
| DEFAULT_PROJECT_ROOT = Path(__file__).resolve().parents[2] |
| _MAX_FINDING_EXAMPLES = 100 |
| _MAX_POSTWRITE_ISSUES = 100 |
|
|
|
|
| def _sorted_counter(counter: Counter[str]) -> dict[str, int]: |
| return {key: counter[key] for key in sorted(counter)} |
|
|
|
|
| def _cross_table(table: Mapping[str, Counter[str]]) -> dict[str, dict[str, int]]: |
| return {key: _sorted_counter(table[key]) for key in sorted(table)} |
|
|
|
|
| @dataclass(slots=True) |
| class QualityStats: |
| """Small, mergeable aggregate of the materialised verdict stream.""" |
|
|
| total_records: int = 0 |
| disposition: Counter[str] = field(default_factory=Counter) |
| hard_failures: Counter[str] = field(default_factory=Counter) |
| structural_failures: Counter[str] = field(default_factory=Counter) |
| reproducibility_failures: Counter[str] = field(default_factory=Counter) |
| semantic_blockers: Counter[str] = field(default_factory=Counter) |
| review_flags: Counter[str] = field(default_factory=Counter) |
| check_passed: Counter[str] = field(default_factory=Counter) |
| check_failed: Counter[str] = field(default_factory=Counter) |
| primitive: Counter[str] = field(default_factory=Counter) |
| task_family: Counter[str] = field(default_factory=Counter) |
| split: Counter[str] = field(default_factory=Counter) |
| disposition_by_primitive: dict[str, Counter[str]] = field( |
| default_factory=lambda: defaultdict(Counter) |
| ) |
| disposition_by_task_family: dict[str, Counter[str]] = field( |
| default_factory=lambda: defaultdict(Counter) |
| ) |
| disposition_by_split: dict[str, Counter[str]] = field( |
| default_factory=lambda: defaultdict(Counter) |
| ) |
| target_decision_by_task_family: dict[str, Counter[str]] = field( |
| default_factory=lambda: defaultdict(Counter) |
| ) |
| confidence_target_histogram: Counter[str] = field(default_factory=Counter) |
| rank_top_candidate_id: Counter[str] = field(default_factory=Counter) |
| match_winner_candidate_id: Counter[str] = field(default_factory=Counter) |
| winner_candidate_id_by_task_family: dict[str, Counter[str]] = field( |
| default_factory=lambda: defaultdict(Counter) |
| ) |
| integrity_passed: int = 0 |
| structural_integrity_passed: int = 0 |
| reproducibility_passed: int = 0 |
| semantic_passed: int = 0 |
| strict_fitness_passed: int = 0 |
| training_ready: int = 0 |
| exact_hash_match: int = 0 |
| validator_exceptions: int = 0 |
|
|
| def ingest( |
| self, |
| verdict: Mapping[str, Any], |
| canonical_record: Mapping[str, Any] | None = None, |
| ) -> None: |
| self.total_records += 1 |
| disposition = str(verdict.get("disposition", "<MISSING>")) |
| primitive = str(verdict.get("primitive", "<MISSING>")) |
| task_family = str(verdict.get("task_family", "<MISSING>")) |
| split = str(verdict.get("split", "<MISSING>")) |
| self.disposition[disposition] += 1 |
| self.primitive[primitive] += 1 |
| self.task_family[task_family] += 1 |
| self.split[split] += 1 |
| self.disposition_by_primitive[primitive][disposition] += 1 |
| self.disposition_by_task_family[task_family][disposition] += 1 |
| self.disposition_by_split[split][disposition] += 1 |
|
|
| hard_failures = verdict.get("hard_failures", []) |
| if isinstance(hard_failures, Sequence) and not isinstance( |
| hard_failures, (str, bytes, bytearray) |
| ): |
| self.hard_failures.update(str(value) for value in hard_failures) |
| for field_name in ( |
| "structural_failures", |
| "reproducibility_failures", |
| "semantic_blockers", |
| ): |
| values = verdict.get(field_name, []) |
| if isinstance(values, Sequence) and not isinstance( |
| values, (str, bytes, bytearray) |
| ): |
| getattr(self, field_name).update(str(value) for value in values) |
| review_flags = verdict.get("review_flags", []) |
| if isinstance(review_flags, Sequence) and not isinstance( |
| review_flags, (str, bytes, bytearray) |
| ): |
| self.review_flags.update(str(value) for value in review_flags) |
|
|
| checks = verdict.get("checks", {}) |
| if isinstance(checks, Mapping): |
| for name, passed in checks.items(): |
| (self.check_passed if bool(passed) else self.check_failed)[str(name)] += 1 |
|
|
| self.integrity_passed += bool(verdict.get("integrity_passed")) |
| self.structural_integrity_passed += bool( |
| verdict.get("structural_integrity_passed") |
| ) |
| self.reproducibility_passed += bool(verdict.get("reproducibility_passed")) |
| self.semantic_passed += bool(verdict.get("semantic_passed")) |
| self.strict_fitness_passed += bool(verdict.get("strict_fitness_passed")) |
| self.training_ready += bool(verdict.get("training_ready")) |
| self.exact_hash_match += ( |
| verdict.get("canonical_sha256") is not None |
| and verdict.get("canonical_sha256") == verdict.get("reproduced_sha256") |
| ) |
| self.validator_exceptions += "QUALITY_VALIDATOR_EXCEPTION" in hard_failures |
|
|
| if canonical_record is not None: |
| target = canonical_record.get("target", {}) |
| if isinstance(target, Mapping): |
| decision = target.get("decision", "<MISSING>") |
| decision_key = str(decision) |
| self.target_decision_by_task_family[task_family][decision_key] += 1 |
| confidence = target.get("confidence_target", "<MISSING>") |
| confidence_key = ( |
| confidence |
| if isinstance(confidence, str) |
| else json.dumps( |
| confidence, |
| ensure_ascii=False, |
| sort_keys=True, |
| separators=(",", ":"), |
| ) |
| ) |
| self.confidence_target_histogram[str(confidence_key)] += 1 |
| ranking = target.get("ranking") |
| if isinstance(ranking, list) and ranking: |
| winner = str(ranking[0]) |
| self.rank_top_candidate_id[winner] += 1 |
| self.winner_candidate_id_by_task_family[task_family][winner] += 1 |
| canonical_id = target.get("canonical_id") |
| if isinstance(canonical_id, str) and canonical_id: |
| self.match_winner_candidate_id[canonical_id] += 1 |
| self.winner_candidate_id_by_task_family[task_family][canonical_id] += 1 |
|
|
| def merge(self, other: "QualityStats") -> None: |
| self.total_records += other.total_records |
| for name in ( |
| "disposition", |
| "hard_failures", |
| "structural_failures", |
| "reproducibility_failures", |
| "semantic_blockers", |
| "review_flags", |
| "check_passed", |
| "check_failed", |
| "primitive", |
| "task_family", |
| "split", |
| "confidence_target_histogram", |
| "rank_top_candidate_id", |
| "match_winner_candidate_id", |
| ): |
| getattr(self, name).update(getattr(other, name)) |
| for name in ( |
| "disposition_by_primitive", |
| "disposition_by_task_family", |
| "disposition_by_split", |
| "target_decision_by_task_family", |
| "winner_candidate_id_by_task_family", |
| ): |
| target = getattr(self, name) |
| for key, counter in getattr(other, name).items(): |
| target[key].update(counter) |
| self.integrity_passed += other.integrity_passed |
| self.structural_integrity_passed += other.structural_integrity_passed |
| self.reproducibility_passed += other.reproducibility_passed |
| self.semantic_passed += other.semantic_passed |
| self.strict_fitness_passed += other.strict_fitness_passed |
| self.training_ready += other.training_ready |
| self.exact_hash_match += other.exact_hash_match |
| self.validator_exceptions += other.validator_exceptions |
|
|
| def to_dict(self) -> dict[str, Any]: |
| check_names = sorted(set(self.check_passed) | set(self.check_failed)) |
| checks = { |
| name: { |
| "passed": self.check_passed[name], |
| "failed": self.check_failed[name], |
| } |
| for name in check_names |
| } |
| total = self.total_records |
| return { |
| "total_records": total, |
| "disposition": _sorted_counter(self.disposition), |
| "hard_failures": _sorted_counter(self.hard_failures), |
| "structural_failures": _sorted_counter(self.structural_failures), |
| "reproducibility_failures": _sorted_counter(self.reproducibility_failures), |
| "semantic_blockers": _sorted_counter(self.semantic_blockers), |
| "review_flags": _sorted_counter(self.review_flags), |
| "checks": checks, |
| "primitive": _sorted_counter(self.primitive), |
| "task_family": _sorted_counter(self.task_family), |
| "split": _sorted_counter(self.split), |
| "disposition_by_primitive": _cross_table(self.disposition_by_primitive), |
| "disposition_by_task_family": _cross_table(self.disposition_by_task_family), |
| "disposition_by_split": _cross_table(self.disposition_by_split), |
| "target_decision_by_task_family": _cross_table( |
| self.target_decision_by_task_family |
| ), |
| "confidence_target_histogram": _sorted_counter( |
| self.confidence_target_histogram |
| ), |
| "rank_top_candidate_id": _sorted_counter(self.rank_top_candidate_id), |
| "match_winner_candidate_id": _sorted_counter( |
| self.match_winner_candidate_id |
| ), |
| "winner_candidate_id_by_task_family": _cross_table( |
| self.winner_candidate_id_by_task_family |
| ), |
| "integrity_passed_records": self.integrity_passed, |
| "integrity_passed_ratio": round(self.integrity_passed / total, 8) if total else 0.0, |
| "strict_fitness_passed_records": self.strict_fitness_passed, |
| "strict_fitness_passed_ratio": ( |
| round(self.strict_fitness_passed / total, 8) if total else 0.0 |
| ), |
| "structural_integrity_passed_records": self.structural_integrity_passed, |
| "reproducibility_passed_records": self.reproducibility_passed, |
| "semantic_passed_records": self.semantic_passed, |
| "training_ready_records": self.training_ready, |
| "training_ready_false_records": total - self.training_ready, |
| "canonical_reproduction_hash_match_records": self.exact_hash_match, |
| "quality_validator_exception_records": self.validator_exceptions, |
| } |
|
|
|
|
| @dataclass(frozen=True, slots=True) |
| class ShardTask: |
| canonical_path: str |
| canonical_sha256: str |
| canonical_manifest_records: int |
| records_to_process: int |
| start_index: int |
| verdict_path: str |
| config: dict[str, Any] |
| compresslevel: int |
|
|
|
|
| @dataclass(slots=True) |
| class QualityShardResult: |
| canonical_path: str |
| canonical_sha256: str |
| canonical_manifest_records: int |
| records_processed: int |
| start_index: int |
| verdict: ShardResult |
| stats: QualityStats |
| finding_examples: list[dict[str, Any]] |
|
|
|
|
| def _load_json_object(path: str | Path) -> dict[str, Any]: |
| source = Path(path) |
| value = json.loads(source.read_text(encoding="utf-8")) |
| if not isinstance(value, dict): |
| raise ValueError(f"expected a JSON object: {source}") |
| return value |
|
|
|
|
| def _semantic_sha256(value: Mapping[str, Any]) -> str: |
| encoded = json.dumps( |
| dict(value), ensure_ascii=False, sort_keys=True, separators=(",", ":") |
| ).encode("utf-8") |
| return hashlib.sha256(encoded).hexdigest() |
|
|
|
|
| def _order_sensitive_sha256(value: Mapping[str, Any]) -> str: |
| encoded = json.dumps( |
| dict(value), ensure_ascii=False, sort_keys=False, separators=(",", ":") |
| ).encode("utf-8") |
| return hashlib.sha256(encoded).hexdigest() |
|
|
|
|
| def _mapping_key_order_equal(left: Any, right: Any) -> bool: |
| if isinstance(left, Mapping) and isinstance(right, Mapping): |
| if list(left) != list(right): |
| return False |
| return all(_mapping_key_order_equal(left[key], right[key]) for key in left) |
| if isinstance(left, list) and isinstance(right, list): |
| return len(left) == len(right) and all( |
| _mapping_key_order_equal(a, b) for a, b in zip(left, right, strict=True) |
| ) |
| return left == right |
|
|
|
|
| def _generation_plan_sha256(config: Mapping[str, Any]) -> str: |
| """Hash every order-sensitive decision that defines the global plan.""" |
|
|
| plan = GenerationPlan(dict(config)) |
| payload = { |
| "primitive_cycle": plan.primitive_cycle, |
| "mixture_cycle": plan.mixture_cycle, |
| "serializer_cycle": plan.serializer_cycle, |
| "long_slots": plan.long_slots, |
| "train_end": plan.train_end, |
| "validation_end": plan.validation_end, |
| "total": plan.total, |
| } |
| return _semantic_sha256(payload) |
|
|
|
|
| def _source_bundle( |
| project_root: Path, |
| generation_config_path: Path, |
| config_snapshot_path: Path, |
| ) -> dict[str, Any]: |
| """Hash the executable Python, schema, and configuration inputs.""" |
|
|
| paths: list[tuple[str, Path]] = [] |
| for root_name in ("src", "schema", "configs"): |
| root = project_root / root_name |
| if not root.exists(): |
| continue |
| for path in sorted(candidate for candidate in root.rglob("*") if candidate.is_file()): |
| if "__pycache__" in path.parts or path.suffix in {".pyc", ".pyo"}: |
| continue |
| paths.append((path.relative_to(project_root).as_posix(), path.resolve())) |
| pyproject = project_root / "pyproject.toml" |
| if pyproject.is_file(): |
| paths.append(("pyproject.toml", pyproject.resolve())) |
|
|
| explicit = ( |
| ("runtime/generation-config.json", generation_config_path.resolve()), |
| ("dataset/config.snapshot.json", config_snapshot_path.resolve()), |
| ) |
| paths.extend(explicit) |
|
|
| |
| |
| entries: list[dict[str, Any]] = [] |
| seen: set[tuple[str, Path]] = set() |
| for logical_path, path in sorted(paths, key=lambda item: item[0]): |
| key = (logical_path, path) |
| if key in seen: |
| continue |
| seen.add(key) |
| entries.append( |
| { |
| "logical_path": logical_path, |
| "path": str(path), |
| "sha256": sha256_file(path), |
| "bytes": path.stat().st_size, |
| } |
| ) |
| digest_payload = [ |
| { |
| "logical_path": entry["logical_path"], |
| "sha256": entry["sha256"], |
| "bytes": entry["bytes"], |
| } |
| for entry in entries |
| ] |
| digest = hashlib.sha256( |
| json.dumps(digest_payload, sort_keys=True, separators=(",", ":")).encode("utf-8") |
| ).hexdigest() |
| return { |
| "version": SOURCE_BUNDLE_VERSION, |
| "sha256": digest, |
| "files": entries, |
| } |
|
|
|
|
| def _validator_exception_verdict(record: Mapping[str, Any], exc: Exception) -> dict[str, Any]: |
| """Preserve one sidecar row even if an individual validator raises.""" |
|
|
| record_id = record.get("record_id") |
| try: |
| record_index = int(str(record_id).rsplit("_", 1)[-1]) |
| except ValueError: |
| record_index = None |
| return { |
| "record_id": record_id, |
| "record_index": record_index, |
| "quality_schema_version": QUALITY_SCHEMA_VERSION, |
| "primitive": record.get("primitive"), |
| "task_family": record.get("task_family"), |
| "split": record.get("split"), |
| "canonical_sha256": canonical_sha256(record), |
| "reproduced_sha256": None, |
| "reproducibility_passed": False, |
| "structural_integrity_passed": False, |
| "integrity_passed": False, |
| "semantic_passed": False, |
| "strict_fitness_passed": False, |
| "training_ready": False, |
| "disposition": "REJECT", |
| "check_pass_ratio": 0.0, |
| "checks": {"quality_validator_execution": False}, |
| "hard_failures": ["QUALITY_VALIDATOR_EXCEPTION"], |
| "structural_failures": ["QUALITY_VALIDATOR_EXCEPTION"], |
| "reproducibility_failures": [], |
| "semantic_blockers": [], |
| "review_flags": [], |
| "scope_limitations": [ |
| "SYNTHETIC_TEMPLATE_ONLY", |
| "NO_HUMAN_REVIEW", |
| "NO_REAL_MODALITY_SIGNAL", |
| ], |
| "canonical_validation_errors": [], |
| "metrics": {}, |
| "runner_error": { |
| "type": type(exc).__name__, |
| "message": str(exc)[:500], |
| }, |
| } |
|
|
|
|
| def _validate_shard(task: ShardTask) -> QualityShardResult: |
| canonical_path = Path(task.canonical_path) |
| actual_source_sha = sha256_file(canonical_path) |
| if actual_source_sha != task.canonical_sha256: |
| raise ValueError( |
| f"canonical checksum mismatch for {canonical_path}: " |
| f"{actual_source_sha} != {task.canonical_sha256}" |
| ) |
| if not 1 <= task.records_to_process <= task.canonical_manifest_records: |
| raise ValueError(f"invalid record limit for {canonical_path}") |
|
|
| plan = GenerationPlan(task.config) |
| stats = QualityStats() |
| examples: list[dict[str, Any]] = [] |
| canonical_iter = iter_jsonl_gz(canonical_path) |
|
|
| def verdict_stream() -> Iterator[dict[str, Any]]: |
| for ordinal in range(task.records_to_process): |
| try: |
| record = next(canonical_iter) |
| except StopIteration as exc: |
| raise ValueError( |
| f"short canonical shard {canonical_path}: stopped at {ordinal}, " |
| f"expected {task.records_to_process}" |
| ) from exc |
| try: |
| verdict = validate_record_quality(record, task.config, plan) |
| except Exception as exc: |
| verdict = _validator_exception_verdict(record, exc) |
| verdict = dict(verdict) |
| verdict["source_shard"] = canonical_path.name |
| verdict["source_line"] = ordinal + 1 |
| verdict["expected_record_index"] = task.start_index + ordinal |
| stats.ingest(verdict, record) |
| if verdict.get("disposition") != "KEEP" and len(examples) < 10: |
| examples.append( |
| { |
| "record_id": verdict.get("record_id"), |
| "disposition": verdict.get("disposition"), |
| "hard_failures": verdict.get("hard_failures", []), |
| "structural_failures": verdict.get("structural_failures", []), |
| "semantic_blockers": verdict.get("semantic_blockers", []), |
| "review_flags": verdict.get("review_flags", []), |
| } |
| ) |
| yield verdict |
|
|
| if task.records_to_process == task.canonical_manifest_records: |
| try: |
| extra = next(canonical_iter) |
| except StopIteration: |
| return |
| raise ValueError( |
| f"canonical shard {canonical_path} contains more than manifest count; " |
| f"first extra record={extra.get('record_id')}" |
| ) |
|
|
| verdict_result = write_jsonl_gz_atomic( |
| task.verdict_path, |
| verdict_stream(), |
| compresslevel=task.compresslevel, |
| ) |
| if verdict_result.records != task.records_to_process: |
| raise RuntimeError( |
| f"short quality sidecar {verdict_result.path}: " |
| f"{verdict_result.records} != {task.records_to_process}" |
| ) |
| return QualityShardResult( |
| canonical_path=str(canonical_path), |
| canonical_sha256=actual_source_sha, |
| canonical_manifest_records=task.canonical_manifest_records, |
| records_processed=task.records_to_process, |
| start_index=task.start_index, |
| verdict=verdict_result, |
| stats=stats, |
| finding_examples=examples, |
| ) |
|
|
|
|
| def _resolve_manifest_path(raw_path: str, manifest_path: Path) -> Path: |
| path = Path(raw_path) |
| if not path.is_absolute(): |
| path = manifest_path.parent / path |
| return path.resolve() |
|
|
|
|
| def _sidecar_name(canonical_path: Path) -> str: |
| name = canonical_path.name |
| suffix = ".jsonl.gz" |
| stem = name[: -len(suffix)] if name.endswith(suffix) else name |
| return f"{stem}.quality.jsonl.gz" |
|
|
|
|
| def _build_tasks( |
| manifest: Mapping[str, Any], |
| manifest_path: Path, |
| output_root: Path, |
| config: dict[str, Any], |
| requested_records: int, |
| compresslevel: int, |
| ) -> list[ShardTask]: |
| raw_shards = manifest.get("shards") |
| if not isinstance(raw_shards, list) or not raw_shards: |
| raise ValueError("canonical manifest has no shards") |
| remaining = requested_records |
| source_start_index = 0 |
| tasks: list[ShardTask] = [] |
| source_paths: set[Path] = set() |
| sidecar_names: set[str] = set() |
| for entry in raw_shards: |
| if remaining == 0: |
| break |
| if not isinstance(entry, Mapping): |
| raise ValueError("canonical manifest shard entry is not an object") |
| canonical_path = _resolve_manifest_path(str(entry.get("path", "")), manifest_path) |
| if not canonical_path.is_file(): |
| raise FileNotFoundError(canonical_path) |
| if canonical_path in source_paths: |
| raise ValueError(f"duplicate canonical shard path: {canonical_path}") |
| source_paths.add(canonical_path) |
| manifest_records = int(entry.get("records", 0)) |
| if manifest_records <= 0: |
| raise ValueError(f"invalid canonical record count: {canonical_path}") |
| expected_sha = str(entry.get("sha256", "")) |
| if len(expected_sha) != 64: |
| raise ValueError(f"invalid canonical checksum: {canonical_path}") |
| take = min(remaining, manifest_records) |
| sidecar_name = _sidecar_name(canonical_path) |
| if sidecar_name in sidecar_names: |
| raise ValueError(f"duplicate sidecar name: {sidecar_name}") |
| sidecar_names.add(sidecar_name) |
| tasks.append( |
| ShardTask( |
| canonical_path=str(canonical_path), |
| canonical_sha256=expected_sha, |
| canonical_manifest_records=manifest_records, |
| records_to_process=take, |
| start_index=source_start_index, |
| verdict_path=str((output_root / "verdicts" / sidecar_name).resolve()), |
| config=config, |
| compresslevel=compresslevel, |
| ) |
| ) |
| remaining -= take |
| source_start_index += manifest_records |
| if remaining: |
| raise ValueError( |
| f"canonical manifest contains fewer records than requested: missing {remaining}" |
| ) |
| return tasks |
|
|
|
|
| def _run_tasks(tasks: list[ShardTask], workers: int) -> list[QualityShardResult]: |
| worker_count = max(1, min(int(workers), len(tasks))) |
| results: list[QualityShardResult] = [] |
| if worker_count == 1: |
| for index, task in enumerate(tasks, 1): |
| result = _validate_shard(task) |
| results.append(result) |
| print( |
| f"quality {index}/{len(tasks)} {result.verdict.path.name} " |
| f"records={result.records_processed}", |
| flush=True, |
| ) |
| return results |
|
|
| with ProcessPoolExecutor(max_workers=worker_count) as executor: |
| futures = {executor.submit(_validate_shard, task): task for task in tasks} |
| completed = 0 |
| for future in as_completed(futures): |
| task = futures[future] |
| result = future.result() |
| results.append(result) |
| completed += 1 |
| print( |
| f"quality {completed}/{len(tasks)} {Path(task.verdict_path).name} " |
| f"records={result.records_processed}", |
| flush=True, |
| ) |
| return results |
|
|
|
|
| def _aggregate_results( |
| results: Sequence[QualityShardResult], |
| ) -> tuple[QualityStats, list[dict[str, Any]]]: |
| stats = QualityStats() |
| examples: list[dict[str, Any]] = [] |
| for result in sorted(results, key=lambda item: item.start_index): |
| stats.merge(result.stats) |
| for example in result.finding_examples: |
| if len(examples) < _MAX_FINDING_EXAMPLES: |
| examples.append(example) |
| return stats, examples |
|
|
|
|
| def _pin_metadata( |
| *, |
| project_root: Path, |
| generation_config_path: Path, |
| config_snapshot_path: Path, |
| canonical_manifest_path: Path, |
| config: Mapping[str, Any], |
| snapshot: Mapping[str, Any], |
| ) -> tuple[dict[str, Any], list[str]]: |
| order_equal = _mapping_key_order_equal(config, snapshot) |
| warnings: list[str] = [] |
| if not order_equal: |
| warnings.append( |
| "config.snapshot.json is semantically equal but mapping key order differs; " |
| "the immutable explicit generation config was used for exact regeneration" |
| ) |
| pins = { |
| "generation_config": { |
| "path": str(generation_config_path.resolve()), |
| "raw_sha256": sha256_file(generation_config_path), |
| "semantic_sha256": _semantic_sha256(config), |
| "order_sensitive_sha256": _order_sensitive_sha256(config), |
| "generation_plan_sha256": _generation_plan_sha256(config), |
| "used_for_exact_regeneration": True, |
| }, |
| "config_snapshot": { |
| "path": str(config_snapshot_path.resolve()), |
| "raw_sha256": sha256_file(config_snapshot_path), |
| "semantic_sha256": _semantic_sha256(snapshot), |
| "order_sensitive_sha256": _order_sensitive_sha256(snapshot), |
| "generation_plan_sha256": _generation_plan_sha256(snapshot), |
| "semantically_equal_to_generation_config": snapshot == config, |
| "mapping_key_order_equal_to_generation_config": order_equal, |
| "used_for_exact_regeneration": False, |
| }, |
| "canonical_manifest": { |
| "path": str(canonical_manifest_path.resolve()), |
| "raw_sha256": sha256_file(canonical_manifest_path), |
| "bytes": canonical_manifest_path.stat().st_size, |
| }, |
| "source_bundle": _source_bundle( |
| project_root, generation_config_path, config_snapshot_path |
| ), |
| } |
| return pins, warnings |
|
|
|
|
| def _pins_unchanged( |
| initial: Mapping[str, Any], |
| *, |
| project_root: Path, |
| generation_config_path: Path, |
| config_snapshot_path: Path, |
| canonical_manifest_path: Path, |
| ) -> bool: |
| current_bundle = _source_bundle(project_root, generation_config_path, config_snapshot_path) |
| return ( |
| sha256_file(generation_config_path) |
| == initial["generation_config"]["raw_sha256"] |
| and sha256_file(config_snapshot_path) |
| == initial["config_snapshot"]["raw_sha256"] |
| and sha256_file(canonical_manifest_path) |
| == initial["canonical_manifest"]["raw_sha256"] |
| and current_bundle["sha256"] == initial["source_bundle"]["sha256"] |
| and current_bundle["files"] == initial["source_bundle"]["files"] |
| ) |
|
|
|
|
| def _quality_gates( |
| stats: QualityStats, |
| requested_records: int, |
| source_total_records: int, |
| config: Mapping[str, Any], |
| ) -> dict[str, bool]: |
| all_audited = stats.total_records == requested_records |
| full_corpus_audited = all_audited and requested_records == source_total_records |
| all_reproduced = ( |
| stats.reproducibility_passed == requested_records |
| and stats.exact_hash_match == requested_records |
| ) |
| all_structural = stats.structural_integrity_passed == requested_records |
| zero_semantic_blockers = not stats.semantic_blockers |
| zero_not_training_ready = stats.training_ready == requested_records |
| redistribution_cleared = config.get("redistribution") != "pending-owner-policy" |
| internal_promotion = all( |
| ( |
| full_corpus_audited, |
| all_reproduced, |
| all_structural, |
| zero_semantic_blockers, |
| zero_not_training_ready, |
| stats.validator_exceptions == 0, |
| ) |
| ) |
| return { |
| "all_records_audited": all_audited, |
| "full_corpus_audited": full_corpus_audited, |
| "exact_requested_record_count": all_audited, |
| "all_records_received_verdict": all_audited, |
| "all_records_exactly_reproduced": all_reproduced, |
| "all_records_structural_integrity_passed": all_structural, |
| "zero_semantic_blockers": zero_semantic_blockers, |
| "zero_training_ready_false": zero_not_training_ready, |
| "no_quality_validator_exceptions": stats.validator_exceptions == 0, |
| "all_records_integrity_passed": stats.integrity_passed == requested_records, |
| "all_records_strict_fitness_passed": stats.strict_fitness_passed == requested_records, |
| "redistribution_cleared_for_public_release": redistribution_cleared, |
| "internal_training_promotion_passed": internal_promotion, |
| "public_release_promotion_passed": internal_promotion and redistribution_cleared, |
| } |
|
|
|
|
| def _manifest_payload( |
| *, |
| results: Sequence[QualityShardResult], |
| stats: QualityStats, |
| pins: Mapping[str, Any], |
| warnings: Sequence[str], |
| requested_records: int, |
| source_total_records: int, |
| ) -> dict[str, Any]: |
| ordered_results = sorted(results, key=lambda result: result.start_index) |
| shards = [ |
| { |
| "canonical_path": result.canonical_path, |
| "canonical_sha256": result.canonical_sha256, |
| "canonical_manifest_records": result.canonical_manifest_records, |
| "records": result.records_processed, |
| "start_index": result.start_index, |
| "verdict_path": str(result.verdict.path), |
| "verdict_sha256": result.verdict.sha256, |
| "verdict_compressed_bytes": result.verdict.compressed_bytes, |
| "verdict_uncompressed_bytes": result.verdict.uncompressed_bytes, |
| } |
| for result in ordered_results |
| ] |
| return { |
| "manifest_version": QUALITY_MANIFEST_VERSION, |
| "quality_schema_version": QUALITY_SCHEMA_VERSION, |
| "metadata": { |
| "requested_records": requested_records, |
| "source_total_records": source_total_records, |
| "partial_run": requested_records != source_total_records, |
| "pins": dict(pins), |
| "warnings": list(warnings), |
| }, |
| "shards": shards, |
| "statistics": stats.to_dict(), |
| "totals": { |
| "records": sum(result.records_processed for result in results), |
| "shards": len(results), |
| "verdict_compressed_bytes": sum( |
| result.verdict.compressed_bytes for result in results |
| ), |
| "verdict_uncompressed_bytes": sum( |
| result.verdict.uncompressed_bytes for result in results |
| ), |
| }, |
| } |
|
|
|
|
| def _append_issue(issues: list[dict[str, Any]], **issue: Any) -> None: |
| if len(issues) < _MAX_POSTWRITE_ISSUES: |
| issues.append(issue) |
|
|
|
|
| def _verdict_shape_valid(verdict: Mapping[str, Any]) -> bool: |
| return ( |
| isinstance(verdict.get("record_id"), str) |
| and isinstance(verdict.get("record_index"), int) |
| and verdict.get("quality_schema_version") == QUALITY_SCHEMA_VERSION |
| and verdict.get("disposition") in {"KEEP", "REVIEW", "REJECT", "QUARANTINE"} |
| and isinstance(verdict.get("checks"), Mapping) |
| and isinstance(verdict.get("hard_failures"), list) |
| and isinstance(verdict.get("structural_failures"), list) |
| and isinstance(verdict.get("reproducibility_failures"), list) |
| and isinstance(verdict.get("semantic_blockers"), list) |
| and isinstance(verdict.get("review_flags"), list) |
| and isinstance(verdict.get("canonical_sha256"), str) |
| and isinstance(verdict.get("source_shard"), str) |
| and isinstance(verdict.get("source_line"), int) |
| and isinstance(verdict.get("expected_record_index"), int) |
| and isinstance(verdict.get("training_ready"), bool) |
| ) |
|
|
|
|
| def _verify_postwrite( |
| *, |
| quality_manifest_path: Path, |
| complete_path: Path, |
| report_path: Path, |
| output_root: Path, |
| project_root: Path, |
| generation_config_path: Path, |
| config_snapshot_path: Path, |
| canonical_manifest_path: Path, |
| ) -> dict[str, Any]: |
| """Independently re-read every sidecar and its paired canonical records.""" |
|
|
| quality_manifest = _load_json_object(quality_manifest_path) |
| issues: list[dict[str, Any]] = [] |
| gates = { |
| "quality_manifest_shape_valid": True, |
| "generation_config_pin_matches": True, |
| "config_snapshot_pin_matches": True, |
| "canonical_manifest_pin_matches": True, |
| "source_bundle_pin_matches": True, |
| "canonical_shard_checksums_match": True, |
| "verdict_shard_checksums_match": True, |
| "record_counts_match": True, |
| "record_ids_align": True, |
| "record_indices_contiguous": True, |
| "canonical_record_hashes_align": True, |
| "verdict_shapes_valid": True, |
| "statistics_recomputed_exactly": True, |
| } |
| if quality_manifest.get("manifest_version") != QUALITY_MANIFEST_VERSION: |
| gates["quality_manifest_shape_valid"] = False |
| _append_issue(issues, code="QUALITY_MANIFEST_VERSION_INVALID") |
| metadata = quality_manifest.get("metadata", {}) |
| pins = metadata.get("pins", {}) if isinstance(metadata, Mapping) else {} |
| try: |
| current_bundle = _source_bundle( |
| project_root, generation_config_path, config_snapshot_path |
| ) |
| if sha256_file(generation_config_path) != pins["generation_config"]["raw_sha256"]: |
| gates["generation_config_pin_matches"] = False |
| _append_issue(issues, code="GENERATION_CONFIG_PIN_MISMATCH") |
| if sha256_file(config_snapshot_path) != pins["config_snapshot"]["raw_sha256"]: |
| gates["config_snapshot_pin_matches"] = False |
| _append_issue(issues, code="CONFIG_SNAPSHOT_PIN_MISMATCH") |
| if sha256_file(canonical_manifest_path) != pins["canonical_manifest"]["raw_sha256"]: |
| gates["canonical_manifest_pin_matches"] = False |
| _append_issue(issues, code="CANONICAL_MANIFEST_PIN_MISMATCH") |
| if ( |
| current_bundle["sha256"] != pins["source_bundle"]["sha256"] |
| or current_bundle["files"] != pins["source_bundle"]["files"] |
| ): |
| gates["source_bundle_pin_matches"] = False |
| _append_issue(issues, code="SOURCE_BUNDLE_PIN_MISMATCH") |
| except (KeyError, TypeError, OSError, ValueError) as exc: |
| gates["quality_manifest_shape_valid"] = False |
| _append_issue( |
| issues, |
| code="PIN_METADATA_INVALID", |
| detail=f"{type(exc).__name__}: {exc}"[:500], |
| ) |
|
|
| recomputed = QualityStats() |
| shard_entries = quality_manifest.get("shards") |
| if not isinstance(shard_entries, list) or not shard_entries: |
| gates["quality_manifest_shape_valid"] = False |
| shard_entries = [] |
| _append_issue(issues, code="QUALITY_MANIFEST_SHARDS_INVALID") |
|
|
| for shard_index, entry in enumerate(shard_entries): |
| if not isinstance(entry, Mapping): |
| gates["quality_manifest_shape_valid"] = False |
| _append_issue(issues, code="QUALITY_SHARD_ENTRY_INVALID", shard=shard_index) |
| continue |
| canonical_path = Path(str(entry.get("canonical_path", ""))) |
| verdict_path = Path(str(entry.get("verdict_path", ""))) |
| expected_records = int(entry.get("records", -1)) |
| canonical_manifest_records = int(entry.get("canonical_manifest_records", -1)) |
| start_index = int(entry.get("start_index", -1)) |
|
|
| try: |
| actual = sha256_file(canonical_path) |
| if actual != entry.get("canonical_sha256"): |
| gates["canonical_shard_checksums_match"] = False |
| _append_issue( |
| issues, |
| code="CANONICAL_SHARD_CHECKSUM_MISMATCH", |
| shard=shard_index, |
| path=str(canonical_path), |
| ) |
| except OSError as exc: |
| gates["canonical_shard_checksums_match"] = False |
| _append_issue( |
| issues, |
| code="CANONICAL_SHARD_READ_FAILED", |
| shard=shard_index, |
| detail=str(exc)[:500], |
| ) |
| continue |
| try: |
| actual = sha256_file(verdict_path) |
| if actual != entry.get("verdict_sha256"): |
| gates["verdict_shard_checksums_match"] = False |
| _append_issue( |
| issues, |
| code="VERDICT_SHARD_CHECKSUM_MISMATCH", |
| shard=shard_index, |
| path=str(verdict_path), |
| ) |
| except OSError as exc: |
| gates["verdict_shard_checksums_match"] = False |
| _append_issue( |
| issues, |
| code="VERDICT_SHARD_READ_FAILED", |
| shard=shard_index, |
| detail=str(exc)[:500], |
| ) |
| continue |
|
|
| canonical_iter = iter_jsonl_gz(canonical_path) |
| verdict_iter = iter_jsonl_gz(verdict_path) |
| paired = 0 |
| for ordinal in range(max(expected_records, 0)): |
| try: |
| canonical_record = next(canonical_iter) |
| except StopIteration: |
| gates["record_counts_match"] = False |
| _append_issue( |
| issues, |
| code="CANONICAL_SHORT_DURING_POSTWRITE", |
| shard=shard_index, |
| ordinal=ordinal, |
| ) |
| break |
| try: |
| verdict = next(verdict_iter) |
| except StopIteration: |
| gates["record_counts_match"] = False |
| _append_issue( |
| issues, |
| code="VERDICT_SHORT_DURING_POSTWRITE", |
| shard=shard_index, |
| ordinal=ordinal, |
| ) |
| break |
| paired += 1 |
| if canonical_record.get("record_id") != verdict.get("record_id"): |
| gates["record_ids_align"] = False |
| _append_issue( |
| issues, |
| code="RECORD_ID_ALIGNMENT_MISMATCH", |
| shard=shard_index, |
| ordinal=ordinal, |
| canonical_record_id=canonical_record.get("record_id"), |
| verdict_record_id=verdict.get("record_id"), |
| ) |
| expected_index = start_index + ordinal |
| if ( |
| verdict.get("record_index") != expected_index |
| or verdict.get("expected_record_index") != expected_index |
| or verdict.get("source_line") != ordinal + 1 |
| or verdict.get("source_shard") != canonical_path.name |
| ): |
| gates["record_indices_contiguous"] = False |
| _append_issue( |
| issues, |
| code="RECORD_INDEX_OR_SOURCE_POSITION_MISMATCH", |
| shard=shard_index, |
| ordinal=ordinal, |
| expected_record_index=expected_index, |
| verdict_record_index=verdict.get("record_index"), |
| verdict_expected_record_index=verdict.get("expected_record_index"), |
| source_line=verdict.get("source_line"), |
| source_shard=verdict.get("source_shard"), |
| ) |
| if canonical_sha256(canonical_record) != verdict.get("canonical_sha256"): |
| gates["canonical_record_hashes_align"] = False |
| _append_issue( |
| issues, |
| code="CANONICAL_RECORD_HASH_MISMATCH", |
| shard=shard_index, |
| ordinal=ordinal, |
| record_id=canonical_record.get("record_id"), |
| ) |
| if not _verdict_shape_valid(verdict): |
| gates["verdict_shapes_valid"] = False |
| _append_issue( |
| issues, |
| code="VERDICT_SHAPE_INVALID", |
| shard=shard_index, |
| ordinal=ordinal, |
| record_id=verdict.get("record_id"), |
| ) |
| recomputed.ingest(verdict, canonical_record) |
|
|
| try: |
| extra_verdict = next(verdict_iter) |
| except StopIteration: |
| extra_verdict = None |
| if extra_verdict is not None: |
| gates["record_counts_match"] = False |
| _append_issue( |
| issues, |
| code="VERDICT_HAS_EXTRA_RECORDS", |
| shard=shard_index, |
| first_extra_record_id=extra_verdict.get("record_id"), |
| ) |
| if expected_records == canonical_manifest_records: |
| try: |
| extra_canonical = next(canonical_iter) |
| except StopIteration: |
| extra_canonical = None |
| if extra_canonical is not None: |
| gates["record_counts_match"] = False |
| _append_issue( |
| issues, |
| code="CANONICAL_HAS_EXTRA_RECORDS", |
| shard=shard_index, |
| first_extra_record_id=extra_canonical.get("record_id"), |
| ) |
| if paired != expected_records: |
| gates["record_counts_match"] = False |
|
|
| expected_stats = quality_manifest.get("statistics") |
| actual_stats = recomputed.to_dict() |
| if actual_stats != expected_stats: |
| gates["statistics_recomputed_exactly"] = False |
| _append_issue(issues, code="QUALITY_STATISTICS_MISMATCH") |
|
|
| all_gates_passed = all(gates.values()) |
| postwrite = { |
| "verification_version": QUALITY_POSTWRITE_VERSION, |
| "quality_manifest": str(quality_manifest_path.resolve()), |
| "quality_manifest_sha256": sha256_file(quality_manifest_path), |
| "complete_marker": str(complete_path.resolve()), |
| "complete_marker_sha256": sha256_file(complete_path), |
| "source_report": str(report_path.resolve()), |
| "source_report_sha256": sha256_file(report_path), |
| "records_reread": recomputed.total_records, |
| "shards_reread": len(shard_entries), |
| "gates": gates, |
| "all_artifact_verification_gates_passed": all_gates_passed, |
| "issues": issues, |
| "recomputed_statistics": actual_stats, |
| } |
| postwrite_path = output_root / "reports" / "postwrite-verification.json" |
| write_json_atomic(postwrite_path, postwrite) |
| if not all_gates_passed: |
| failed = { |
| "marker_version": QUALITY_MARKER_VERSION, |
| "quality_artifacts_verified": False, |
| "postwrite_verification": str(postwrite_path.resolve()), |
| "postwrite_verification_sha256": sha256_file(postwrite_path), |
| "failed_gates": [name for name, passed in gates.items() if not passed], |
| } |
| write_json_atomic(output_root / "_QUALITY_FAILED.json", failed) |
| raise RuntimeError(f"quality postwrite verification failed; inspect {postwrite_path}") |
|
|
| quality_gates = quality_manifest.get("metadata", {}).get("quality_gates", {}) |
| verified = { |
| "marker_version": QUALITY_MARKER_VERSION, |
| "quality_artifacts_verified": True, |
| "records": recomputed.total_records, |
| "shards": len(shard_entries), |
| "quality_manifest": str(quality_manifest_path.resolve()), |
| "quality_manifest_sha256": sha256_file(quality_manifest_path), |
| "quality_report": str(report_path.resolve()), |
| "quality_report_sha256": sha256_file(report_path), |
| "complete_marker": str(complete_path.resolve()), |
| "complete_marker_sha256": sha256_file(complete_path), |
| "postwrite_verification": str(postwrite_path.resolve()), |
| "postwrite_verification_sha256": sha256_file(postwrite_path), |
| "artifact_verification_gates": gates, |
| "quality_gates": quality_gates, |
| "disposition": actual_stats["disposition"], |
| } |
| verified_path = output_root / "_QUALITY_VERIFIED.json" |
| write_json_atomic(verified_path, verified) |
| return verified |
|
|
|
|
| def run_quality_validation( |
| *, |
| dataset_root: str | Path, |
| generation_config_path: str | Path, |
| output_root: str | Path, |
| manifest_path: str | Path | None = None, |
| project_root: str | Path = DEFAULT_PROJECT_ROOT, |
| workers: int = 1, |
| max_records: int | None = None, |
| compresslevel: int | None = None, |
| ) -> dict[str, Any]: |
| dataset_root = Path(dataset_root).resolve() |
| project_root = Path(project_root).resolve() |
| output_root = Path(output_root).resolve() |
| generation_config_path = Path(generation_config_path).resolve() |
| canonical_manifest_path = Path(manifest_path or dataset_root / "manifest.json").resolve() |
| config_snapshot_path = (dataset_root / "config.snapshot.json").resolve() |
|
|
| if output_root == dataset_root: |
| raise ValueError("quality output must be a child path, not the dataset root itself") |
| if generation_config_path == config_snapshot_path: |
| raise ValueError( |
| "--config must name the immutable original generation config, not " |
| "DATASET_ROOT/config.snapshot.json" |
| ) |
| if output_root.exists() and any(output_root.iterdir()): |
| raise FileExistsError(f"quality output directory is not empty: {output_root}") |
| for required in ( |
| generation_config_path, |
| canonical_manifest_path, |
| config_snapshot_path, |
| ): |
| if not required.is_file(): |
| raise FileNotFoundError(required) |
|
|
| config = _load_json_object(generation_config_path) |
| snapshot = _load_json_object(config_snapshot_path) |
| canonical_manifest = _load_json_object(canonical_manifest_path) |
| GenerationPlan(config) |
| if snapshot != config: |
| raise ValueError( |
| "config.snapshot.json is not semantically equal to the explicit generation config" |
| ) |
| manifest_semantic_config_hash = canonical_manifest.get("metadata", {}).get("config_sha256") |
| if manifest_semantic_config_hash != _semantic_sha256(config): |
| raise ValueError( |
| "canonical manifest config_sha256 does not match the explicit generation config" |
| ) |
|
|
| raw_shards = canonical_manifest.get("shards", []) |
| source_total_records = sum( |
| int(entry.get("records", 0)) for entry in raw_shards if isinstance(entry, Mapping) |
| ) |
| declared_total = canonical_manifest.get("totals", {}).get("records") |
| if int(declared_total or -1) != source_total_records or source_total_records <= 0: |
| raise ValueError("canonical manifest total does not equal its shard record counts") |
| requested_records = source_total_records if max_records is None else int(max_records) |
| if not 1 <= requested_records <= source_total_records: |
| raise ValueError(f"--max-records must be between 1 and {source_total_records}") |
| if int(workers) < 1: |
| raise ValueError("--workers must be at least 1") |
| if compresslevel is None: |
| compresslevel = int(config.get("gzip_compresslevel", 6)) |
| if not 0 <= int(compresslevel) <= 9: |
| raise ValueError("--compresslevel must be between 0 and 9") |
|
|
| pins, warnings = _pin_metadata( |
| project_root=project_root, |
| generation_config_path=generation_config_path, |
| config_snapshot_path=config_snapshot_path, |
| canonical_manifest_path=canonical_manifest_path, |
| config=config, |
| snapshot=snapshot, |
| ) |
| output_root.mkdir(parents=True, exist_ok=True) |
| tasks = _build_tasks( |
| canonical_manifest, |
| canonical_manifest_path, |
| output_root, |
| config, |
| requested_records, |
| int(compresslevel), |
| ) |
| results = _run_tasks(tasks, int(workers)) |
| if not _pins_unchanged( |
| pins, |
| project_root=project_root, |
| generation_config_path=generation_config_path, |
| config_snapshot_path=config_snapshot_path, |
| canonical_manifest_path=canonical_manifest_path, |
| ): |
| raise RuntimeError("configuration, manifest, or source bundle changed during validation") |
|
|
| stats, finding_examples = _aggregate_results(results) |
| quality_gates = _quality_gates( |
| stats, |
| requested_records, |
| source_total_records, |
| config, |
| ) |
| config_contract = { |
| "explicit_generation_config_used": True, |
| "snapshot_used_for_exact_regeneration": False, |
| "snapshot_semantically_equal": snapshot == config, |
| "snapshot_mapping_key_order_equal": _mapping_key_order_equal(config, snapshot), |
| "snapshot_generation_plan_equal": ( |
| _generation_plan_sha256(config) == _generation_plan_sha256(snapshot) |
| ), |
| "canonical_manifest_semantic_config_hash_matches": ( |
| manifest_semantic_config_hash == _semantic_sha256(config) |
| ), |
| } |
| manifest = _manifest_payload( |
| results=results, |
| stats=stats, |
| pins=pins, |
| warnings=warnings, |
| requested_records=requested_records, |
| source_total_records=source_total_records, |
| ) |
| manifest["metadata"]["quality_gates"] = quality_gates |
| manifest["metadata"]["config_contract"] = config_contract |
| quality_manifest_path = output_root / "manifest.json" |
| write_json_atomic(quality_manifest_path, manifest) |
|
|
| report = { |
| "report_version": QUALITY_REPORT_VERSION, |
| "quality_schema_version": QUALITY_SCHEMA_VERSION, |
| "dataset_root": str(dataset_root), |
| "output_root": str(output_root), |
| "requested_records": requested_records, |
| "source_total_records": source_total_records, |
| "partial_run": requested_records != source_total_records, |
| "all_records_audited": quality_gates["all_records_audited"], |
| "training_promotion_passed": quality_gates[ |
| "internal_training_promotion_passed" |
| ], |
| "public_release_promotion_passed": quality_gates[ |
| "public_release_promotion_passed" |
| ], |
| "statistics": stats.to_dict(), |
| "quality_gates": quality_gates, |
| "config_contract": config_contract, |
| "pins": pins, |
| "warnings": warnings, |
| "finding_examples": finding_examples, |
| "interpretation": { |
| "KEEP": "all integrity and strict task-family fitness checks passed", |
| "REVIEW": "integrity passed, but at least one strict fitness flag requires review", |
| "REJECT": "structural failures or semantic blockers make the record unusable", |
| "QUARANTINE": "exact regeneration failed without a structural or semantic rejection", |
| "artifact_verification_is_separate_from_quality_outcome": True, |
| }, |
| } |
| report_path = output_root / "report.json" |
| write_json_atomic(report_path, report) |
| complete = { |
| "marker_version": QUALITY_MARKER_VERSION, |
| "quality_sidecars_complete": True, |
| "records": stats.total_records, |
| "shards": len(results), |
| "quality_manifest": str(quality_manifest_path), |
| "quality_manifest_sha256": sha256_file(quality_manifest_path), |
| "quality_report": str(report_path), |
| "quality_report_sha256": sha256_file(report_path), |
| "quality_gates": quality_gates, |
| "disposition": stats.to_dict()["disposition"], |
| } |
| complete_path = output_root / "_QUALITY_COMPLETE.json" |
| write_json_atomic(complete_path, complete) |
| verified = _verify_postwrite( |
| quality_manifest_path=quality_manifest_path, |
| complete_path=complete_path, |
| report_path=report_path, |
| output_root=output_root, |
| project_root=project_root, |
| generation_config_path=generation_config_path, |
| config_snapshot_path=config_snapshot_path, |
| canonical_manifest_path=canonical_manifest_path, |
| ) |
| return verified |
|
|
|
|
| def build_parser() -> argparse.ArgumentParser: |
| parser = argparse.ArgumentParser( |
| description="Materialise and independently verify one quality verdict per BGD record" |
| ) |
| parser.add_argument("--dataset-root", required=True) |
| parser.add_argument( |
| "--config", |
| required=True, |
| help="original order-preserving generation config; never use config.snapshot.json", |
| ) |
| parser.add_argument("--output", required=True) |
| parser.add_argument("--manifest", help="canonical manifest; defaults to DATASET_ROOT/manifest.json") |
| parser.add_argument("--project-root", default=str(DEFAULT_PROJECT_ROOT)) |
| parser.add_argument("--workers", type=int, default=1) |
| parser.add_argument("--max-records", type=int) |
| parser.add_argument("--compresslevel", type=int) |
| return parser |
|
|
|
|
| def main(argv: list[str] | None = None) -> int: |
| args = build_parser().parse_args(argv) |
| try: |
| verified = run_quality_validation( |
| dataset_root=args.dataset_root, |
| generation_config_path=args.config, |
| output_root=args.output, |
| manifest_path=args.manifest, |
| project_root=args.project_root, |
| workers=args.workers, |
| max_records=args.max_records, |
| compresslevel=args.compresslevel, |
| ) |
| except Exception as exc: |
| print(f"ERROR: {exc}", file=sys.stderr) |
| return 1 |
| print(json.dumps(verified, ensure_ascii=False, indent=2, sort_keys=True), flush=True) |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
