| from __future__ import annotations |
|
|
| import argparse |
| import ast |
| import hashlib |
| import json |
| import random |
| from collections import Counter |
| from datetime import datetime, timezone |
| from pathlib import Path |
|
|
| import pyarrow as pa |
| import pyarrow.parquet as pq |
|
|
| from .families import FAMILIES |
|
|
| VERSION = "0.1.0" |
| LICENSE = "Apache-2.0" |
| DEFAULT_ROWS = 100_000 |
| GENERATOR_VERSION = "oellm-code-generators-0.1.0" |
| VERIFIER_VERSION = "oellm-code-stdio-contract-0.1.0" |
| DATASET_ID = "birgermoell/oellm-code-rlvr" |
|
|
| TEST_CASE = pa.struct([("input", pa.string()), ("output", pa.string()), ("type", pa.string())]) |
| SCHEMA = pa.schema([ |
| ("id", pa.string()), |
| ("messages", pa.list_(pa.struct([("role", pa.string()), ("content", pa.string())]))), |
| ("problem", pa.string()), |
| ("verification_info", pa.struct([("language", pa.string()), ("test_cases", pa.list_(TEST_CASE))])), |
| ("ground_truth", pa.string()), |
| ("public_tests", pa.list_(TEST_CASE)), |
| ("reference_solution", pa.string()), |
| ("dataset", pa.string()), |
| ("split", pa.string()), |
| ("programming_language", pa.string()), |
| ("prompt_language", pa.string()), |
| ("difficulty", pa.int8()), |
| ("difficulty_label", pa.string()), |
| ("generator_family", pa.string()), |
| ("concepts", pa.list_(pa.string())), |
| ("generator_version", pa.string()), |
| ("generation_seed", pa.int64()), |
| ("semantic_group_id", pa.string()), |
| ("parameters_json", pa.string()), |
| ("verifier_kind", pa.string()), |
| ("verifier_version", pa.string()), |
| ("time_limit_seconds", pa.int16()), |
| ("memory_limit_mb", pa.int16()), |
| ("hidden_test_count", pa.int16()), |
| ("mutation_score", pa.float32()), |
| ("source", pa.string()), |
| ("source_license", pa.string()), |
| ("prompt_sha256", pa.string()), |
| ("reference_sha256", pa.string()), |
| ("contamination_group", pa.string()), |
| ]) |
|
|
|
|
| def digest(text: str) -> str: |
| return hashlib.sha256(text.encode("utf-8")).hexdigest() |
|
|
|
|
| def stable_int(text: str) -> int: |
| return int.from_bytes(hashlib.sha256(text.encode()).digest()[:8], "big") & ((1 << 63) - 1) |
|
|
|
|
| def split_for(group_id: str) -> str: |
| bucket = stable_int("split:" + group_id) % 1000 |
| if bucket < 25: |
| return "test" |
| if bucket < 50: |
| return "validation" |
| return "train" |
|
|
|
|
| def difficulty_for(seed: int) -> int: |
| bucket = stable_int(f"difficulty:{seed}") % 100 |
| if bucket < 15: |
| return 1 |
| if bucket < 40: |
| return 2 |
| if bucket < 70: |
| return 3 |
| if bucket < 90: |
| return 4 |
| return 5 |
|
|
|
|
| def _typed(cases: list[dict[str, str]]) -> list[dict[str, str]]: |
| return [{"input": c["input"], "output": c["output"], "type": "stdin_stdout"} for c in cases] |
|
|
|
|
| def build_row(family: str, semantic_index: int) -> dict: |
| group_id = f"oellm-code-{family}-{semantic_index:09d}" |
| seed = stable_int(f"{VERSION}:{family}:{semantic_index}") |
| difficulty = difficulty_for(seed) |
| material = FAMILIES[family](random.Random(seed), difficulty) |
| if material.mutation_score < 2 / 3: |
| raise ValueError("insufficient mutation coverage") |
| ast.parse(material.reference_solution) |
| hidden = _typed(material.hidden_tests) |
| public = _typed(material.public_tests) |
| prompt_hash = digest(material.statement) |
| reference_hash = digest(material.reference_solution) |
| return { |
| "id": digest(group_id)[:24], |
| "messages": [{"role": "user", "content": material.statement}], |
| "problem": material.statement, |
| "verification_info": {"language": "python", "test_cases": hidden}, |
| "ground_truth": json.dumps(hidden, sort_keys=True, separators=(",", ":")), |
| "public_tests": public, |
| "reference_solution": material.reference_solution, |
| "dataset": "oellm-code-rlvr", |
| "split": split_for(group_id), |
| "programming_language": "python", |
| "prompt_language": "en", |
| "difficulty": difficulty, |
| "difficulty_label": ["", "introductory", "basic", "intermediate", "advanced", "challenge"][difficulty], |
| "generator_family": family, |
| "concepts": material.concepts, |
| "generator_version": GENERATOR_VERSION, |
| "generation_seed": seed, |
| "semantic_group_id": group_id, |
| "parameters_json": json.dumps(material.parameters, sort_keys=True, separators=(",", ":")), |
| "verifier_kind": "code_stdio", |
| "verifier_version": VERIFIER_VERSION, |
| "time_limit_seconds": 2, |
| "memory_limit_mb": 256, |
| "hidden_test_count": len(hidden), |
| "mutation_score": material.mutation_score, |
| "source": "deterministic_procedural_generation", |
| "source_license": LICENSE, |
| "prompt_sha256": prompt_hash, |
| "reference_sha256": reference_hash, |
| "contamination_group": f"generator:{family}:v0.1", |
| } |
|
|
|
|
| def file_sha256(path: Path) -> str: |
| result = hashlib.sha256() |
| with path.open("rb") as handle: |
| for chunk in iter(lambda: handle.read(8 * 1024 * 1024), b""): |
| result.update(chunk) |
| return result.hexdigest() |
|
|
|
|
| class SplitWriters: |
| def __init__(self, root: Path): |
| root.mkdir(parents=True, exist_ok=True) |
| self.paths = {s: root / f"{s}-00000-of-00001.parquet" for s in ("train", "validation", "test")} |
| self.writers = {s: pq.ParquetWriter(p, SCHEMA, compression="zstd", compression_level=6) for s, p in self.paths.items()} |
| self.buffers = {s: [] for s in self.paths} |
| self.counts = Counter() |
|
|
| def add(self, row: dict) -> None: |
| split = row["split"] |
| self.buffers[split].append(row) |
| self.counts[split] += 1 |
| if len(self.buffers[split]) >= 2_000: |
| self.flush(split) |
|
|
| def flush(self, split: str) -> None: |
| if self.buffers[split]: |
| self.writers[split].write_table(pa.Table.from_pylist(self.buffers[split], schema=SCHEMA)) |
| self.buffers[split].clear() |
|
|
| def close(self) -> None: |
| for split in self.writers: |
| self.flush(split) |
| self.writers[split].close() |
|
|
|
|
| def build(output: Path, rows: int = DEFAULT_ROWS) -> dict: |
| writers = SplitWriters(output / "data") |
| families = list(FAMILIES) |
| accepted = Counter() |
| candidates = Counter() |
| family_target = {family: rows // len(families) for family in families} |
| for family in families[: rows % len(families)]: |
| family_target[family] += 1 |
| seen_prompts: set[str] = set() |
| difficulties, mutation_buckets, hidden_counts = Counter(), Counter(), Counter() |
|
|
| while sum(accepted.values()) < rows: |
| for family in families: |
| if accepted[family] >= family_target[family]: |
| continue |
| index = candidates[family] |
| candidates[family] += 1 |
| try: |
| row = build_row(family, index) |
| except ValueError: |
| continue |
| if row["prompt_sha256"] in seen_prompts: |
| continue |
| seen_prompts.add(row["prompt_sha256"]) |
| writers.add(row) |
| accepted[family] += 1 |
| difficulties[str(row["difficulty"])] += 1 |
| mutation_buckets[f"{row['mutation_score']:.2f}"] += 1 |
| hidden_counts[str(row["hidden_test_count"])] += 1 |
|
|
| writers.close() |
| files = { |
| split: {"path": f"data/{path.name}", "rows": writers.counts[split], "bytes": path.stat().st_size, "sha256": file_sha256(path)} |
| for split, path in writers.paths.items() |
| } |
| manifest = { |
| "dataset_id": DATASET_ID, |
| "version": VERSION, |
| "created_utc": datetime.now(timezone.utc).isoformat(), |
| "rows": rows, |
| "programming_languages": {"python": rows}, |
| "prompt_languages": {"en": rows}, |
| "generator_families": dict(sorted(accepted.items())), |
| "difficulty": dict(sorted(difficulties.items())), |
| "mutation_scores": dict(sorted(mutation_buckets.items())), |
| "hidden_test_counts": dict(sorted(hidden_counts.items())), |
| "files": files, |
| "license": LICENSE, |
| "generation": {"generator_version": GENERATOR_VERSION, "verifier_contract": VERIFIER_VERSION}, |
| } |
| (output / "manifest.json").write_text(json.dumps(manifest, indent=2, sort_keys=True) + "\n") |
| return manifest |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--output", type=Path, default=Path("release")) |
| parser.add_argument("--rows", type=int, default=DEFAULT_ROWS) |
| args = parser.parse_args() |
| print(json.dumps(build(args.output, args.rows), indent=2)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
