"""Command-line entry points for generating and auditing BGD-SFT artifacts.""" from __future__ import annotations import argparse import hashlib import json import sys from collections import Counter from concurrent.futures import ProcessPoolExecutor, as_completed from dataclasses import dataclass from pathlib import Path from typing import Any, Iterable from .audit import StatsAccumulator, build_manifest, build_report from .generation import GenerationPlan, generate_record from .io import ( ShardResult, iter_jsonl_gz, sha256_file, write_json_atomic, write_jsonl_gz_atomic, ) from .serializers import build_messages from .validation import validate_record DEFAULT_CONFIG = Path(__file__).resolve().parents[2] / "configs" / "selected_sft_1m.json" @dataclass class WorkerResult: shard: ShardResult stats: StatsAccumulator group_splits: dict[str, str] invalid_examples: list[dict[str, Any]] def _load_config(path: str | Path) -> dict[str, Any]: config_path = Path(path) config = json.loads(config_path.read_text(encoding="utf-8")) if not isinstance(config, dict): raise ValueError("config must be a JSON object") GenerationPlan(config) return config def _config_digest(config: dict[str, Any]) -> str: payload = json.dumps(config, ensure_ascii=False, sort_keys=True, separators=(",", ":")) return hashlib.sha256(payload.encode("utf-8")).hexdigest() def _record_stream( config: dict[str, Any], start: int, end: int, stats: StatsAccumulator, group_splits: dict[str, str], ) -> Iterable[dict[str, Any]]: plan = GenerationPlan(config) for index in range(start, end): record = generate_record(config, plan, index) errors = validate_record(record) if errors: raise ValueError( f"generated invalid record {record.get('record_id')}: " + "; ".join(errors) ) source_group = record["source_group"] split = record["split"] previous = group_splits.setdefault(source_group, split) if previous != split: raise ValueError(f"source group split leakage: {source_group}: {previous} vs {split}") stats.ingest(record) yield record def _generate_shard( config: dict[str, Any], output_path: str, start: int, end: int, compresslevel: int, ) -> WorkerResult: stats = StatsAccumulator() group_splits: dict[str, str] = {} shard = write_jsonl_gz_atomic( output_path, _record_stream(config, start, end, stats, group_splits), compresslevel=compresslevel, ) if shard.records != end - start: raise RuntimeError(f"short shard {output_path}: {shard.records} != {end - start}") return WorkerResult(shard=shard, stats=stats, group_splits=group_splits, invalid_examples=[]) def _audit_shard(expected: dict[str, Any]) -> WorkerResult: path = Path(expected["path"]) actual_hash = sha256_file(path) invalid_examples: list[dict[str, Any]] = [] stats = StatsAccumulator() group_splits: dict[str, str] = {} records = 0 for record in iter_jsonl_gz(path): records += 1 errors = validate_record(record) if errors and len(invalid_examples) < 20: invalid_examples.append({"record_id": record.get("record_id"), "errors": errors}) stats.ingest(record) source_group = record.get("source_group") split = record.get("split") if isinstance(source_group, str) and isinstance(split, str): previous = group_splits.setdefault(source_group, split) if previous != split and len(invalid_examples) < 20: invalid_examples.append( { "record_id": record.get("record_id"), "errors": [f"source group split leakage: {source_group}: {previous} vs {split}"], } ) if actual_hash != expected["sha256"]: invalid_examples.append( {"record_id": None, "errors": [f"checksum mismatch for {path}"]} ) if records != int(expected["records"]): invalid_examples.append( { "record_id": None, "errors": [f"record count mismatch for {path}: {records} != {expected['records']}"], } ) shard = ShardResult( path=path, records=records, sha256=actual_hash, compressed_bytes=path.stat().st_size, uncompressed_bytes=int(expected.get("uncompressed_bytes", 0)), ) return WorkerResult( shard=shard, stats=stats, group_splits=group_splits, invalid_examples=invalid_examples, ) def _merge_worker_results(results: list[WorkerResult]) -> tuple[StatsAccumulator, int, list[dict[str, Any]]]: stats = StatsAccumulator() all_group_splits: dict[str, str] = {} split_conflicts = 0 invalid_examples: list[dict[str, Any]] = [] for result in results: stats.merge(result.stats) for source_group, split in result.group_splits.items(): previous = all_group_splits.setdefault(source_group, split) if previous != split: split_conflicts += 1 if len(invalid_examples) < 20: invalid_examples.append( { "record_id": None, "errors": [ f"cross-shard source group leakage: {source_group}: {previous} vs {split}" ], } ) for example in result.invalid_examples: if len(invalid_examples) < 20: invalid_examples.append(example) return stats, split_conflicts, invalid_examples def _expected_counts(percent: dict[str, int], total: int) -> dict[str, int]: return {key: total * value // 100 for key, value in percent.items()} def _promotion_gates( config: dict[str, Any], stats: StatsAccumulator, *, requested_records: int, split_conflicts: int, invalid_examples: list[dict[str, Any]], ) -> dict[str, Any]: observed = stats.to_dict() full_run = requested_records == int(config["total_records"]) gates: dict[str, bool | None] = { "exact_requested_record_count": observed["total_records"] == requested_records, "all_records_primary_zh_tw": observed["primary_zh_tw_records"] == requested_records, "no_unannotated_simplified_only_hits": observed[ "unannotated_simplified_only_hit_records" ] == 0, "record_ids_unique": observed["duplicate_record_id_occurrences"] == 0, "evidence_references_resolve": observed["evidence_reference_missing"] == 0, "source_groups_split_locked": split_conflicts == 0, "all_records_semantically_valid": not invalid_examples, "exact_split_distribution": None, "exact_primitive_distribution": None, "exact_mixture_distribution": None, "exact_serializer_distribution": None, "exact_long_context_distribution": None, } if full_run: gates["exact_split_distribution"] = observed["split"] == _expected_counts( config["split_percent"], requested_records ) gates["exact_primitive_distribution"] = observed["primitive"] == _expected_counts( config["primitive_percent"], requested_records ) gates["exact_mixture_distribution"] = observed["mixture_category"] == _expected_counts( config["mixture_percent"], requested_records ) gates["exact_serializer_distribution"] = observed["serializer"] == _expected_counts( config["serializer_percent"], requested_records ) long_total = int(config["long_context_records"]) long_expected = _expected_counts(config["long_context_bucket_percent"], long_total) overall_expected = dict(long_expected) overall_expected["0.5K-4K"] += requested_records - long_total gates["exact_long_context_distribution"] = observed["context_bucket"] == overall_expected evaluated = [value for value in gates.values() if value is not None] return { "full_run": full_run, "gates": gates, "all_evaluated_gates_passed": all(evaluated), "invalid_examples": invalid_examples, "source_group_split_conflicts": split_conflicts, } def _publish_reports( output_root: Path, config: dict[str, Any], results: list[WorkerResult], stats: StatsAccumulator, gates: dict[str, Any], *, requested_records: int, report_prefix: str, ) -> tuple[Path, Path]: shards = sorted((result.shard for result in results), key=lambda shard: str(shard.path)) metadata = { "dataset_name": config["dataset_name"], "schema_version": config["schema_version"], "generator_version": config["generator_version"], "validator_version": config["validator_version"], "config_sha256": _config_digest(config), "requested_records": requested_records, "synthetic_only": True, "human_reviewed_records": 0, "teacher_generated_records": 0, } manifest = build_manifest(shards, stats=stats, metadata=metadata) manifest_path = output_root / f"{report_prefix}manifest.json" write_json_atomic(manifest_path, manifest) report = build_report(stats, metadata=metadata) report["promotion_gates"] = gates report_path = output_root / "reports" / f"{report_prefix}audit.json" write_json_atomic(report_path, report) return manifest_path, report_path def _run_parallel_generate( config: dict[str, Any], output_root: Path, requested_records: int, workers: int, ) -> list[WorkerResult]: shard_size = int(config["shard_size"]) tasks = [] for shard_index, start in enumerate(range(0, requested_records, shard_size)): end = min(requested_records, start + shard_size) path = output_root / "canonical" / f"part-{shard_index:05d}.jsonl.gz" tasks.append((config, str(path), start, end, int(config["gzip_compresslevel"]))) results: list[WorkerResult] = [] if workers == 1: for shard_index, task in enumerate(tasks, 1): result = _generate_shard(*task) results.append(result) print(f"generated {shard_index}/{len(tasks)} {result.shard.path.name}", flush=True) return results with ProcessPoolExecutor(max_workers=workers) as executor: futures = {executor.submit(_generate_shard, *task): task[1] for task in tasks} completed = 0 for future in as_completed(futures): path = futures.pop(future) result = future.result() results.append(result) completed += 1 print(f"generated {completed}/{len(tasks)} {Path(path).name}", flush=True) return results def command_generate(args: argparse.Namespace) -> int: config = _load_config(args.config) requested_records = int(args.limit or config["total_records"]) if not 1 <= requested_records <= int(config["total_records"]): raise ValueError("--limit must be between 1 and config.total_records") output_root = Path(args.output).resolve() if (output_root / "_SUCCESS.json").exists(): raise FileExistsError(f"completed dataset already exists: {output_root}") canonical = output_root / "canonical" if canonical.exists() and any(canonical.iterdir()): raise FileExistsError( f"output canonical directory is not empty: {canonical}; choose a new output path" ) output_root.mkdir(parents=True, exist_ok=True) write_json_atomic(output_root / "config.snapshot.json", config) workers = max(1, min(int(args.workers), (requested_records + config["shard_size"] - 1) // config["shard_size"])) results = _run_parallel_generate(config, output_root, requested_records, workers) stats, split_conflicts, invalid_examples = _merge_worker_results(results) gates = _promotion_gates( config, stats, requested_records=requested_records, split_conflicts=split_conflicts, invalid_examples=invalid_examples, ) manifest_path, report_path = _publish_reports( output_root, config, results, stats, gates, requested_records=requested_records, report_prefix="", ) success = { "dataset_name": config["dataset_name"], "records": requested_records, "shards": len(results), "manifest": str(manifest_path), "manifest_sha256": sha256_file(manifest_path), "audit": str(report_path), "audit_sha256": sha256_file(report_path), "all_evaluated_gates_passed": gates["all_evaluated_gates_passed"], } if not gates["all_evaluated_gates_passed"]: write_json_atomic(output_root / "_FAILED_GATES.json", success | {"gates": gates}) raise RuntimeError(f"generation gates failed; inspect {report_path}") write_json_atomic(output_root / "_SUCCESS.json", success) print(json.dumps(success, ensure_ascii=False, indent=2, sort_keys=True)) return 0 def _run_parallel_audit(manifest: dict[str, Any], workers: int) -> list[WorkerResult]: shards = manifest.get("shards") if not isinstance(shards, list) or not shards: raise ValueError("manifest has no shards") results: list[WorkerResult] = [] if workers == 1: for index, shard in enumerate(shards, 1): result = _audit_shard(shard) results.append(result) print(f"audited {index}/{len(shards)} {Path(shard['path']).name}", flush=True) return results with ProcessPoolExecutor(max_workers=workers) as executor: futures = {executor.submit(_audit_shard, shard): shard for shard in shards} completed = 0 for future in as_completed(futures): shard = futures.pop(future) results.append(future.result()) completed += 1 print(f"audited {completed}/{len(shards)} {Path(shard['path']).name}", flush=True) return results def command_audit(args: argparse.Namespace) -> int: output_root = Path(args.output).resolve() config = _load_config(args.config or output_root / "config.snapshot.json") manifest_path = Path(args.manifest or output_root / "manifest.json") manifest = json.loads(manifest_path.read_text(encoding="utf-8")) requested_records = int(manifest["metadata"]["requested_records"]) workers = max(1, min(int(args.workers), len(manifest["shards"]))) results = _run_parallel_audit(manifest, workers) stats, split_conflicts, invalid_examples = _merge_worker_results(results) gates = _promotion_gates( config, stats, requested_records=requested_records, split_conflicts=split_conflicts, invalid_examples=invalid_examples, ) _, report_path = _publish_reports( output_root, config, results, stats, gates, requested_records=requested_records, report_prefix="postwrite-", ) verified = { "dataset_name": config["dataset_name"], "records": stats.total_records, "shards": len(results), "source_manifest": str(manifest_path), "source_manifest_sha256": sha256_file(manifest_path), "audit": str(report_path), "audit_sha256": sha256_file(report_path), "all_evaluated_gates_passed": gates["all_evaluated_gates_passed"], } if not gates["all_evaluated_gates_passed"]: write_json_atomic(output_root / "_POSTWRITE_FAILED.json", verified | {"gates": gates}) raise RuntimeError(f"post-write audit failed; inspect {report_path}") write_json_atomic(output_root / "_VERIFIED.json", verified) print(json.dumps(verified, ensure_ascii=False, indent=2, sort_keys=True)) return 0 def command_build(args: argparse.Namespace) -> int: """Generate and then independently re-read every published shard.""" generate_args = argparse.Namespace( config=args.config, output=args.output, limit=args.limit, workers=args.workers, ) generated = command_generate(generate_args) if generated: return generated audit_args = argparse.Namespace( output=args.output, config=None, manifest=None, workers=args.workers, ) return command_audit(audit_args) def command_show_plan(args: argparse.Namespace) -> int: config = _load_config(args.config) plan = GenerationPlan(config) summary = { "dataset_name": config["dataset_name"], "total_records": config["total_records"], "primitive_per_100": dict(sorted(Counter(plan.primitive_cycle).items())), "mixture_per_100": dict(sorted(Counter(plan.mixture_cycle).items())), "serializer_per_100": dict(sorted(Counter(plan.serializer_cycle).items())), "long_slots": [ { "offset": offset, "primitive": plan.primitive_cycle[offset], "mixture": plan.mixture_cycle[offset], } for offset in plan.long_slots ], } print(json.dumps(summary, ensure_ascii=False, indent=2, sort_keys=True)) return 0 def command_render_sample(args: argparse.Namespace) -> int: config = _load_config(args.config) plan = GenerationPlan(config) record = generate_record(config, plan, int(args.index)) print( json.dumps( {"record": record, "messages": build_messages(record)}, ensure_ascii=False, indent=2, sort_keys=True, ) ) return 0 def build_parser() -> argparse.ArgumentParser: parser = argparse.ArgumentParser(description="Barbet BGD-SFT deterministic dataset builder") subparsers = parser.add_subparsers(dest="command", required=True) generate = subparsers.add_parser("generate", help="generate validated canonical shards") generate.add_argument("--config", default=str(DEFAULT_CONFIG)) generate.add_argument("--output", required=True) generate.add_argument("--limit", type=int) generate.add_argument("--workers", type=int, default=1) generate.set_defaults(func=command_generate) audit = subparsers.add_parser("audit", help="re-read, hash and semantically validate shards") audit.add_argument("--output", required=True) audit.add_argument("--config") audit.add_argument("--manifest") audit.add_argument("--workers", type=int, default=1) audit.set_defaults(func=command_audit) build = subparsers.add_parser( "build", help="generate the dataset and independently post-write audit every shard" ) build.add_argument("--config", default=str(DEFAULT_CONFIG)) build.add_argument("--output", required=True) build.add_argument("--limit", type=int) build.add_argument("--workers", type=int, default=1) build.set_defaults(func=command_build) show_plan = subparsers.add_parser("show-plan", help="print exact per-100 mixture") show_plan.add_argument("--config", default=str(DEFAULT_CONFIG)) show_plan.set_defaults(func=command_show_plan) render = subparsers.add_parser("render-sample", help="render one canonical record as SFT messages") render.add_argument("--config", default=str(DEFAULT_CONFIG)) render.add_argument("--index", type=int, default=0) render.set_defaults(func=command_render_sample) return parser def main(argv: list[str] | None = None) -> int: parser = build_parser() args = parser.parse_args(argv) try: return int(args.func(args)) except Exception as exc: print(f"ERROR: {exc}", file=sys.stderr) return 1 if __name__ == "__main__": raise SystemExit(main())