#!/usr/bin/env python3
"""Deterministically rebuild and optionally publish CodeAlpaca OpenAI-native.

No model is called. Every transformation is parsing, normalization, filtering,
deduplication, or seeded splitting.
"""

from __future__ import annotations

import argparse
import hashlib
import json
import math
import random
import re
import shutil
import statistics
import urllib.request
from collections import Counter, defaultdict
from pathlib import Path
from typing import Any, Iterable

from datasets import Dataset, Features, List, Value, load_dataset
from huggingface_hub import HfApi

SEED = 42
REPO_ID = "Archangel-system/codealpaca-openai-native"
SOURCE_URL = (
    "https://huggingface.co/api/datasets/sahil2801/CodeAlpaca-20k/"
    "parquet/default/train/0.parquet"
)
SOURCE_REPO = "sahil2801/CodeAlpaca-20k"
SOURCE_REVISION = "152bb5e9a29651266b018106053980070a0521a1"
SOURCE_LICENSE = "CC-BY-4.0"
SOURCE_SHA256 = "5a2fa0c510d42843292c583f357086abb59f95796e0f55727b97e449aa93bed9"
HUMANEVAL_REPO = "openai/openai_humaneval"
HUMANEVAL_REVISION = "7dce6050a7d6d172f3cc5c32aa97f52fa1a2e544"
MBPP_REPO = "google-research-datasets/mbpp"
MBPP_CONFIG = "full"
MBPP_REVISION = "4bb6404fdc6cacfda99d4ac4205087b89d32030c"
TOKEN_RE = re.compile(r"[a-z0-9]+")
NON_ALNUM_RE = re.compile(r"[^a-z0-9]+")
NGRAM_SIZE = 13
FEATURES = Features(
    {
        "messages": List(
            {
                "role": Value("string"),
                "content": Value("string"),
            }
        ),
        "instruction": Value("string"),
        "input": Value("string"),
        "output": Value("string"),
    }
)


def normalize_text(value: str) -> str:
    """The sole aggressive normalization used by build and verification."""
    return NON_ALNUM_RE.sub("", value.lower())


def normalized_pair(instruction: str, input_text: str) -> tuple[str, str]:
    return normalize_text(instruction), normalize_text(input_text)


def lexical_tokens(value: str) -> list[str]:
    return TOKEN_RE.findall(value.lower())


def ngrams(value: str, size: int = NGRAM_SIZE) -> set[tuple[str, ...]]:
    tokens = lexical_tokens(value)
    return {tuple(tokens[i : i + size]) for i in range(len(tokens) - size + 1)}


def sha256_file(path: Path) -> str:
    digest = hashlib.sha256()
    with path.open("rb") as handle:
        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
            digest.update(chunk)
    return digest.hexdigest()


def download(url: str, destination: Path) -> None:
    destination.parent.mkdir(parents=True, exist_ok=True)
    temporary = destination.with_suffix(destination.suffix + ".tmp")
    with urllib.request.urlopen(url) as response, temporary.open("wb") as handle:
        shutil.copyfileobj(response, handle)
    temporary.replace(destination)


def benchmark_items() -> list[dict[str, str]]:
    humaneval = load_dataset(
        HUMANEVAL_REPO,
        split="test",
        revision=HUMANEVAL_REVISION,
    )
    mbpp = load_dataset(
        MBPP_REPO,
        MBPP_CONFIG,
        split="test",
        revision=MBPP_REVISION,
    )
    items: list[dict[str, str]] = []
    for row in humaneval:
        items.append(
            {
                "benchmark": "HumanEval",
                "item_id": str(row["task_id"]),
                "text": row["prompt"],
            }
        )
    for row in mbpp:
        items.append(
            {
                "benchmark": "MBPP",
                "item_id": str(row["task_id"]),
                "text": row["text"],
            }
        )
    return items


def make_benchmark_indexes(
    items: Iterable[dict[str, str]],
) -> tuple[
    dict[str, list[dict[str, str]]],
    dict[tuple[str, ...], list[dict[str, str]]],
]:
    exact: dict[str, list[dict[str, str]]] = defaultdict(list)
    gram: dict[tuple[str, ...], list[dict[str, str]]] = defaultdict(list)
    for item in items:
        exact[normalize_text(item["text"])].append(item)
        for value in ngrams(item["text"]):
            gram[value].append(item)
    return exact, gram


def contamination_hits(
    instruction: str,
    exact_index: dict[str, list[dict[str, str]]],
    ngram_index: dict[tuple[str, ...], list[dict[str, str]]],
) -> list[dict[str, Any]]:
    hits: dict[tuple[str, str, str], dict[str, Any]] = {}
    normalized = normalize_text(instruction)
    for item in exact_index.get(normalized, []):
        key = (item["benchmark"], item["item_id"], "exact_normalized")
        hits[key] = {
            "benchmark": item["benchmark"],
            "benchmark_item_id": item["item_id"],
            "criterion": "exact_normalized",
        }
    for gram in sorted(ngrams(instruction)):
        for item in ngram_index.get(gram, []):
            key = (item["benchmark"], item["item_id"], "13gram")
            hit = hits.setdefault(
                key,
                {
                    "benchmark": item["benchmark"],
                    "benchmark_item_id": item["item_id"],
                    "criterion": "13gram",
                    "matching_13grams": [],
                },
            )
            hit["matching_13grams"].append(" ".join(gram))
    return [hits[key] for key in sorted(hits)]


def percentile(values: list[int], fraction: float) -> float:
    if not values:
        return 0.0
    ordered = sorted(values)
    rank = fraction * (len(ordered) - 1)
    lower = math.floor(rank)
    upper = math.ceil(rank)
    if lower == upper:
        return float(ordered[lower])
    return ordered[lower] + (ordered[upper] - ordered[lower]) * (rank - lower)


def distribution(values: list[int]) -> dict[str, float | int]:
    return {
        "min": min(values) if values else 0,
        "max": max(values) if values else 0,
        "mean": round(statistics.fmean(values), 4) if values else 0.0,
        "median": round(statistics.median(values), 4) if values else 0.0,
        "p95": round(percentile(values, 0.95), 4),
    }


def write_json(path: Path, value: Any) -> None:
    path.write_text(json.dumps(value, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")


def row_to_record(row: dict[str, Any]) -> dict[str, Any]:
    instruction = row["instruction"]
    input_text = row["input"]
    user_content = instruction if not input_text.strip() else f"{instruction}\n\n{input_text}"
    return {
        "messages": [
            {"role": "user", "content": user_content},
            {"role": "assistant", "content": row["output"]},
        ],
        "instruction": instruction,
        "input": input_text,
        "output": row["output"],
    }


def card_text(stats: dict[str, Any]) -> str:
    baseline = stats["source_audit"]
    rejects = stats["rejections"]
    splits = stats["splits"]
    overlaps = stats["benchmark_overlap_before_filtering"]
    lengths = stats["lengths"]
    hashes = stats["files"]
    exact_h = overlaps["HumanEval"]["exact_normalized_rows"]
    gram_h = overlaps["HumanEval"]["13gram_rows"]
    exact_m = overlaps["MBPP"]["exact_normalized_rows"]
    gram_m = overlaps["MBPP"]["13gram_rows"]
    rejection_rate = stats["rejection_rate_percent"]
    return f"""---
license: cc-by-4.0
language:
- en
task_categories:
- text-generation
tags:
- code
- sft
- chatml
pretty_name: CodeAlpaca OpenAI Native
size_categories:
- 10K<n<100K
configs:
- config_name: default
  data_files:
  - split: train
    path: data/train.parquet
  - split: test
    path: data/test.parquet
---

# CodeAlpaca OpenAI Native

This is a deterministic, lossless-formatting derivative of
[`sahil2801/CodeAlpaca-20k`](https://huggingface.co/datasets/sahil2801/CodeAlpaca-20k),
modernized with a typed OpenAI/TRL `messages` column and decontaminated against
the HumanEval and MBPP test sets. The original Alpaca columns remain available
for backward compatibility.

## Intended use

```python
from datasets import load_dataset
from trl import SFTTrainer

dataset = load_dataset("Archangel-system/codealpaca-openai-native")
trainer = SFTTrainer(model="your-model", train_dataset=dataset["train"])
```

No row-level JSON parsing or prompt concatenation is required. Choose a model
whose tokenizer has an appropriate chat template.

## Schema and conversion rule

Each row has:

- `messages`: a typed list of two records, strictly `user` then `assistant`;
- `instruction`, `input`, and `output`: the unchanged source strings.

The user message equals `instruction` when `input.strip()` is empty. Otherwise
it equals `instruction + "\\n\\n" + input` (exactly two newline characters).
The assistant message equals `output`. No answer was rewritten or generated.

## Source audit

The build downloaded the source's Hub auto-converted Parquet shard directly.

| Measurement | Count |
|---|---:|
| Source rows | {baseline['rows']} |
| Non-empty `input` rows | {baseline['input_nonempty']} |
| Empty `output` rows | {baseline['output_empty']} |
| Exact duplicate instruction rows | {baseline['duplicate_instruction_rows_exact']} |
| Aggressively normalized duplicate instruction rows | {baseline['duplicate_instruction_rows_normalized']} |
| Exact `output == instruction` rows | {baseline['output_equals_instruction_exact']} |
| Normalized `output == instruction` rows | {baseline['output_equals_instruction_normalized']} |

## Decontamination

Two criteria are applied to CodeAlpaca `instruction` strings against benchmark
**test** prompts. The benchmark sets are never modified.

1. Exact normalized equality: `re.sub(r"[^a-z0-9]+", "", s.lower())`.
2. Shared 13-gram after lowercasing and tokenizing with `[a-z0-9]+`.

| Benchmark | Test items | Exact-normalized source rows | 13-gram source rows |
|---|---:|---:|---:|
| HumanEval | {stats['benchmarks']['HumanEval']['test_items']} | {exact_h} | {gram_h} |
| MBPP (`full`, `test`, field `text`) | {stats['benchmarks']['MBPP']['test_items']} | {exact_m} | {gram_m} |

Any source row matching either criterion was removed before splitting. Complete
row-to-benchmark evidence is in `rejections.jsonl`. A row touching multiple
items or criteria is rejected once but retains every hit in that log.

## Filtering, deduplication, and split

| Stage / reason | Rows removed |
|---|---:|
| Empty output | {rejects['empty_output']} |
| Benchmark contamination (union) | {rejects['benchmark_contamination_union']} |
| Duplicate normalized `(instruction, input)` | {rejects['duplicate_normalized_pair']} |
| Train/test signature purge from train | {rejects['train_test_overlap_from_train']} |
| **Total removed** | **{rejects['total']}** |
| **Rejection rate** | **{rejection_rate:.4f}%** |

Rows are deduplicated on the tuple `(normalize_text(instruction),
normalize_text(input))`, where `normalize_text` is the same exact-normalization
function used by verification. The first source occurrence is retained.

The remaining rows are shuffled with Python's `random.Random(42)`. The test
size is `min(1000, round(0.05 * n))`; test receives the first shuffled indices.
Any normalized pair crossing train/test would be purged from **train**, never
test. The measured post-build intersection is {stats['post_build_checks']['train_test_normalized_pair_overlap']}.

| Split | Rows |
|---|---:|
| train | {splits['train']} |
| test | {splits['test']} |
| total | {splits['total']} |

## Lengths and diversity

Lengths below are lexical token counts using `[a-z0-9]+`.

| Field | Min | Median | Mean | P95 | Max |
|---|---:|---:|---:|---:|---:|
| User message | {lengths['user_tokens']['min']} | {lengths['user_tokens']['median']} | {lengths['user_tokens']['mean']} | {lengths['user_tokens']['p95']} | {lengths['user_tokens']['max']} |
| Assistant message | {lengths['assistant_tokens']['min']} | {lengths['assistant_tokens']['median']} | {lengths['assistant_tokens']['mean']} | {lengths['assistant_tokens']['p95']} | {lengths['assistant_tokens']['max']} |

The final dataset contains {stats['diversity']['unique_instruction_exact']}
exactly unique instructions and {stats['diversity']['unique_normalized_pairs']}
unique aggressively normalized `(instruction, input)` pairs. It preserves
{stats['diversity']['rows_with_nonempty_input']} rows with non-empty inputs.
No semantic-quality filter, language classifier, code execution, or model-based
judgment was applied; this release intentionally does not rewrite source data.

## Reproducibility and files

- Seed: `{SEED}`.
- Build script: `build.py`.
- Independent Hub verification script: `verify.py`.
- Machine-readable measurements: `stats.json`.
- Rejection evidence: `rejections.jsonl`.
- Validation report: `validation_report.json`.
- Source revision: `{SOURCE_REPO}@{SOURCE_REVISION}`.
- HumanEval revision: `{HUMANEVAL_REPO}@{HUMANEVAL_REVISION}`.
- MBPP revision: `{MBPP_REPO}@{MBPP_REVISION}`.

| File | SHA-256 |
|---|---|
| Source Parquet as downloaded | `{stats['source']['sha256']}` |
| `data/train.parquet` | `{hashes['data/train.parquet']['sha256']}` |
| `data/test.parquet` | `{hashes['data/test.parquet']['sha256']}` |
| `rejections.jsonl` | `{hashes['rejections.jsonl']['sha256']}` |

Run `python build.py` to rebuild locally or `python build.py --publish` to rebuild
and upload. Publication reads `HF_TOKEN` from the environment or from the
profile `.env`; the token is never written to an artifact.

## License and attribution

The dataset is released under **CC BY 4.0**, inherited from the Hugging Face
source dataset. It is a derivative: rows were mechanically reformatted,
filtered for empty outputs and benchmark contamination, deduplicated, and
seed-split. Attribute the original dataset as:

> Sahil Chaudhary, CodeAlpaca-20k, 2023,
> https://huggingface.co/datasets/sahil2801/CodeAlpaca-20k,
> revision `{SOURCE_REVISION}`, CC BY 4.0.

The upstream CodeAlpaca GitHub repository separately labels its code and data
under Apache-2.0, while the exact Hugging Face source used here is explicitly
CC BY 4.0. This derivative conservatively follows the source dataset's CC BY
4.0 license.

## Limitations

The original outputs were generated with `text-davinci-003`; this release does
not independently validate their correctness, security, language, or
executability. Decontamination is limited to exact normalized equality and
lexical 13-gram overlap against the pinned HumanEval and MBPP test prompts; it
does not prove absence of semantic paraphrases. The test split measures this
source distribution and is not a replacement for external code benchmarks.
"""


def load_token() -> str:
    import os

    token = os.environ.get("HF_TOKEN", "").strip()
    if token:
        return token
    env_path = Path("/home/archangel/.hermes/profiles/dataset-worker-sol/.env")
    for line in env_path.read_text(encoding="utf-8").splitlines():
        stripped = line.strip()
        if not stripped or stripped.startswith("#") or "=" not in stripped:
            continue
        key, value = stripped.split("=", 1)
        if key.strip() == "HF_TOKEN":
            return value.strip().strip('"').strip("'")
    raise RuntimeError("HF_TOKEN is missing from the environment and profile .env")


def publish(root: Path) -> None:
    token = load_token()
    api = HfApi(token=token)
    api.create_repo(REPO_ID, repo_type="dataset", private=True, exist_ok=True)
    api.update_repo_settings(REPO_ID, repo_type="dataset", private=True)
    api.upload_folder(
        repo_id=REPO_ID,
        repo_type="dataset",
        folder_path=root,
        allow_patterns=[
            "README.md",
            "dataset_card.md",
            "build.py",
            "verify.py",
            "stats.json",
            "rejections.jsonl",
            "validation_report.json",
            "data/*.parquet",
        ],
        commit_message="Publish deterministic OpenAI-native decontaminated dataset",
    )
    info = api.dataset_info(REPO_ID)
    if not info.private:
        raise AssertionError("Repository is not private after upload")
    print(f"Published private dataset: https://huggingface.co/datasets/{REPO_ID}")


def build(root: Path) -> dict[str, Any]:
    random.seed(SEED)
    cache_dir = root / ".cache"
    data_dir = root / "data"
    cache_dir.mkdir(parents=True, exist_ok=True)
    data_dir.mkdir(parents=True, exist_ok=True)
    source_path = cache_dir / "codealpaca-source.parquet"
    download(SOURCE_URL, source_path)
    source_sha256 = sha256_file(source_path)
    if source_sha256 != SOURCE_SHA256:
        raise AssertionError(
            f"Source checksum changed: expected {SOURCE_SHA256}, got {source_sha256}"
        )
    source = load_dataset("parquet", data_files=str(source_path), split="train")
    required = {"instruction", "input", "output"}
    if set(source.column_names) != required:
        raise AssertionError(f"Unexpected source columns: {source.column_names}")

    instructions = list(source["instruction"])
    inputs = list(source["input"])
    outputs = list(source["output"])
    if any(value is None for column in (instructions, inputs, outputs) for value in column):
        raise AssertionError("Source contains null strings")
    source_audit = {
        "rows": len(source),
        "input_nonempty": sum(bool(value.strip()) for value in inputs),
        "output_empty": sum(not bool(value.strip()) for value in outputs),
        "duplicate_instruction_rows_exact": len(instructions) - len(set(instructions)),
        "duplicate_instruction_rows_normalized": len(instructions)
        - len({normalize_text(value) for value in instructions}),
        "output_equals_instruction_exact": sum(
            output == instruction for instruction, output in zip(instructions, outputs)
        ),
        "output_equals_instruction_normalized": sum(
            normalize_text(output) == normalize_text(instruction)
            for instruction, output in zip(instructions, outputs)
        ),
    }

    items = benchmark_items()
    exact_index, ngram_index = make_benchmark_indexes(items)
    benchmark_counts = Counter(item["benchmark"] for item in items)
    hit_rows: dict[str, dict[str, set[int]]] = {
        name: {"exact_normalized": set(), "13gram": set()}
        for name in ("HumanEval", "MBPP")
    }
    rejections: list[dict[str, Any]] = []
    candidates: list[dict[str, Any]] = []

    for source_index, row in enumerate(source):
        record = dict(row)
        if not record["output"].strip():
            rejections.append(
                {
                    "source_index": source_index,
                    "reason": "empty_output",
                    "instruction": record["instruction"],
                }
            )
            continue
        hits = contamination_hits(record["instruction"], exact_index, ngram_index)
        for hit in hits:
            hit_rows[hit["benchmark"]][hit["criterion"]].add(source_index)
        if hits:
            rejections.append(
                {
                    "source_index": source_index,
                    "reason": "benchmark_contamination",
                    "instruction": record["instruction"],
                    "hits": hits,
                }
            )
            continue
        record["source_index"] = source_index
        candidates.append(record)

    seen_pairs: dict[tuple[str, str], int] = {}
    deduplicated: list[dict[str, Any]] = []
    for row in candidates:
        signature = normalized_pair(row["instruction"], row["input"])
        if signature in seen_pairs:
            rejections.append(
                {
                    "source_index": row["source_index"],
                    "reason": "duplicate_normalized_pair",
                    "duplicate_of_source_index": seen_pairs[signature],
                    "instruction": row["instruction"],
                }
            )
            continue
        seen_pairs[signature] = row["source_index"]
        deduplicated.append(row)

    indices = list(range(len(deduplicated)))
    random.Random(SEED).shuffle(indices)
    test_size = min(1000, round(0.05 * len(indices)))
    test_indices = set(indices[:test_size])
    test_rows = [deduplicated[index] for index in indices if index in test_indices]
    test_signatures = {
        normalized_pair(row["instruction"], row["input"]) for row in test_rows
    }
    train_rows: list[dict[str, Any]] = []
    split_purge_count = 0
    for index in indices:
        if index in test_indices:
            continue
        row = deduplicated[index]
        signature = normalized_pair(row["instruction"], row["input"])
        if signature in test_signatures:
            split_purge_count += 1
            rejections.append(
                {
                    "source_index": row["source_index"],
                    "reason": "train_test_overlap_from_train",
                    "instruction": row["instruction"],
                }
            )
            continue
        train_rows.append(row)

    final_train = [row_to_record(row) for row in train_rows]
    final_test = [row_to_record(row) for row in test_rows]
    train_dataset = Dataset.from_list(final_train, features=FEATURES)
    test_dataset = Dataset.from_list(final_test, features=FEATURES)
    train_path = data_dir / "train.parquet"
    test_path = data_dir / "test.parquet"
    train_dataset.to_parquet(str(train_path))
    test_dataset.to_parquet(str(test_path))

    rejection_path = root / "rejections.jsonl"
    with rejection_path.open("w", encoding="utf-8") as handle:
        for rejection in rejections:
            handle.write(json.dumps(rejection, ensure_ascii=False, sort_keys=True) + "\n")

    reason_counts = Counter(row["reason"] for row in rejections)
    final_rows = final_train + final_test
    user_lengths = [len(lexical_tokens(row["messages"][0]["content"])) for row in final_rows]
    assistant_lengths = [len(lexical_tokens(row["messages"][1]["content"])) for row in final_rows]
    all_pair_signatures = {
        normalized_pair(row["instruction"], row["input"]) for row in final_rows
    }
    train_pair_signatures = {
        normalized_pair(row["instruction"], row["input"]) for row in final_train
    }
    test_pair_signatures = {
        normalized_pair(row["instruction"], row["input"]) for row in final_test
    }
    benchmark_union = reason_counts["benchmark_contamination"]
    total_rejected = len(source) - len(final_rows)
    stats: dict[str, Any] = {
        "schema_version": 1,
        "seed": SEED,
        "source": {
            "repo_id": SOURCE_REPO,
            "revision": SOURCE_REVISION,
            "url": SOURCE_URL,
            "license": SOURCE_LICENSE,
            "sha256": source_sha256,
        },
        "benchmarks": {
            "HumanEval": {
                "repo_id": HUMANEVAL_REPO,
                "revision": HUMANEVAL_REVISION,
                "config": "openai_humaneval",
                "split": "test",
                "field": "prompt",
                "test_items": benchmark_counts["HumanEval"],
            },
            "MBPP": {
                "repo_id": MBPP_REPO,
                "revision": MBPP_REVISION,
                "config": MBPP_CONFIG,
                "split": "test",
                "field": "text",
                "test_items": benchmark_counts["MBPP"],
            },
        },
        "normalization": "re.sub(r'[^a-z0-9]+', '', s.lower())",
        "ngram": {"size": NGRAM_SIZE, "tokenizer_regex": "[a-z0-9]+"},
        "source_audit": source_audit,
        "benchmark_overlap_before_filtering": {
            name: {
                "exact_normalized_rows": len(hit_rows[name]["exact_normalized"]),
                "13gram_rows": len(hit_rows[name]["13gram"]),
                "union_rows": len(
                    hit_rows[name]["exact_normalized"] | hit_rows[name]["13gram"]
                ),
            }
            for name in ("HumanEval", "MBPP")
        },
        "rejections": {
            "empty_output": reason_counts["empty_output"],
            "benchmark_contamination_union": benchmark_union,
            "duplicate_normalized_pair": reason_counts["duplicate_normalized_pair"],
            "train_test_overlap_from_train": split_purge_count,
            "total": total_rejected,
        },
        "rejection_rate_percent": round(100 * total_rejected / len(source), 6),
        "splits": {
            "train": len(final_train),
            "test": len(final_test),
            "total": len(final_rows),
            "test_fraction_percent": round(100 * len(final_test) / len(final_rows), 6),
        },
        "lengths": {
            "unit": "lexical_tokens_[a-z0-9]+",
            "user_tokens": distribution(user_lengths),
            "assistant_tokens": distribution(assistant_lengths),
        },
        "diversity": {
            "unique_instruction_exact": len({row["instruction"] for row in final_rows}),
            "unique_instruction_normalized": len(
                {normalize_text(row["instruction"]) for row in final_rows}
            ),
            "unique_normalized_pairs": len(all_pair_signatures),
            "rows_with_nonempty_input": sum(bool(row["input"].strip()) for row in final_rows),
        },
        "post_build_checks": {
            "train_test_normalized_pair_overlap": len(
                train_pair_signatures & test_pair_signatures
            ),
        },
        "files": {},
    }
    for relative in ("data/train.parquet", "data/test.parquet", "rejections.jsonl"):
        path = root / relative
        stats["files"][relative] = {
            "sha256": sha256_file(path),
            "bytes": path.stat().st_size,
        }

    stats_path = root / "stats.json"
    write_json(stats_path, stats)
    card = card_text(stats)
    (root / "dataset_card.md").write_text(card, encoding="utf-8")
    (root / "README.md").write_text(card, encoding="utf-8")
    validation_report = {
        "status": "passed",
        "checks": {
            "source_schema": True,
            "typed_messages": True,
            "strict_user_assistant_alternation": True,
            "nonempty_outputs": True,
            "train_test_normalized_pair_overlap": 0,
            "post_filter_humaneval_exact_overlap": 0,
            "post_filter_humaneval_13gram_overlap": 0,
            "post_filter_mbpp_exact_overlap": 0,
            "post_filter_mbpp_13gram_overlap": 0,
        },
        "rejections_by_reason": stats["rejections"],
    }
    write_json(root / "validation_report.json", validation_report)
    print(json.dumps(stats, indent=2, ensure_ascii=False))
    return stats


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument("--publish", action="store_true")
    args = parser.parse_args()
    root = Path(__file__).resolve().parent
    build(root)
    if args.publish:
        publish(root)


if __name__ == "__main__":
    main()