| |
| """Rebuild data/ from the closebench package. |
| |
| Deterministic: the same closebench version yields byte-identical files. |
| |
| python build.py # closebench installed (pip install closebench==0.1.1) |
| python build.py --src /path/to/repo # or import it from a source checkout |
| |
| Writes, one JSON object per line, UTF-8, compact separators, fixed key order: |
| |
| data/worlds-{lang}.jsonl what the agent sees: seed, mode, lang, company, period, |
| accounts, entries, documents |
| data/truth-{lang}.jsonl the answer key: seed, mode, lang, errors |
| |
| Seeds 1..50 are `hard` worlds, seeds 1001..1050 are `absence` worlds -- the mode is |
| encoded in the seed, exactly as closebench.cli.mode_for does it. |
| """ |
| from __future__ import annotations |
| import argparse, hashlib, json, os, sys |
|
|
| HARD_SEEDS = range(1, 51) |
| ABSENCE_SEEDS = range(1001, 1051) |
| SEEDS = [*HARD_SEEDS, *ABSENCE_SEEDS] |
| LANGS = ("en", "ru") |
| HERE = os.path.dirname(os.path.abspath(__file__)) |
| DATA = os.path.join(HERE, "data") |
|
|
|
|
| def mode_for(seed: int) -> str: |
| """Same rule as closebench.cli.mode_for: seed >= 1000 selects `absence`.""" |
| return "absence" if seed >= 1000 else "hard" |
|
|
|
|
| def import_closebench(src: str | None = None): |
| """Return (World, version). `src` is a source checkout to put on sys.path.""" |
| src = src or os.environ.get("CLOSEBENCH_SRC") |
| if src: |
| sys.path.insert(0, src) |
| try: |
| import closebench |
| from closebench.world import World |
| except ImportError: |
| sys.exit("closebench is not importable: `pip install closebench==0.1.1` " |
| "or pass --src /path/to/closebench checkout") |
| return World, closebench.__version__ |
|
|
|
|
| def world_record(world) -> dict: |
| """Agent-visible part of a built World, in the column order used by the dataset.""" |
| snap = world.snapshot() |
| return { |
| "seed": world.seed, "mode": world.difficulty, "lang": world.lang, |
| "company": snap["company"], "period": snap["period"], |
| "accounts": snap["accounts"], "entries": snap["entries"], |
| "documents": snap["documents"], |
| } |
|
|
|
|
| def truth_record(world) -> dict: |
| """Planted errors of a built World -- the grader's answer key.""" |
| return {"seed": world.seed, "mode": world.difficulty, "lang": world.lang, |
| "errors": world.truth()["errors"]} |
|
|
|
|
| def dumps(obj) -> str: |
| return json.dumps(obj, ensure_ascii=False, separators=(",", ":")) |
|
|
|
|
| def sha256(path: str) -> str: |
| h = hashlib.sha256() |
| with open(path, "rb") as f: |
| for chunk in iter(lambda: f.read(1 << 20), b""): |
| h.update(chunk) |
| return h.hexdigest() |
|
|
|
|
| def build(World, outdir: str = DATA) -> list[dict]: |
| os.makedirs(outdir, exist_ok=True) |
| rows = [] |
| for lang in LANGS: |
| wp = os.path.join(outdir, f"worlds-{lang}.jsonl") |
| tp = os.path.join(outdir, f"truth-{lang}.jsonl") |
| with open(wp, "w", encoding="utf-8", newline="\n") as fw, \ |
| open(tp, "w", encoding="utf-8", newline="\n") as ft: |
| for sd in SEEDS: |
| w = World(seed=sd, lang=lang, difficulty=mode_for(sd)).build() |
| fw.write(dumps(world_record(w)) + "\n") |
| ft.write(dumps(truth_record(w)) + "\n") |
| rows.append({"lang": lang, "seed": sd, "mode": w.difficulty, |
| "entries": len(w.ledger.entries), "documents": len(w.documents), |
| "errors": len(w.errors), "kinds": [e.kind for e in w.errors]}) |
| return rows |
|
|
|
|
| def summarise(rows: list[dict]) -> str: |
| out = [] |
| for lang in LANGS: |
| for mode in ("hard", "absence"): |
| rs = [r for r in rows if r["lang"] == lang and r["mode"] == mode] |
| rng = lambda k: f"{min(r[k] for r in rs)}-{max(r[k] for r in rs)}" |
| out.append(f" {lang} {mode:<8} worlds={len(rs):3d} entries/world={rng('entries'):>8} " |
| f"documents/world={rng('documents'):>6} errors/world={rng('errors'):>4} " |
| f"errors total={sum(r['errors'] for r in rs)}") |
| return "\n".join(out) |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) |
| ap.add_argument("--src", help="closebench source checkout to import from (if not pip-installed)") |
| ap.add_argument("--outdir", default=DATA) |
| a = ap.parse_args() |
| World, version = import_closebench(a.src) |
| print(f"closebench {version}; seeds hard={HARD_SEEDS.start}..{HARD_SEEDS.stop - 1} " |
| f"absence={ABSENCE_SEEDS.start}..{ABSENCE_SEEDS.stop - 1}; langs={','.join(LANGS)}") |
| rows = build(World, a.outdir) |
| print(summarise(rows)) |
| total = 0 |
| for name in sorted(os.listdir(a.outdir)): |
| p = os.path.join(a.outdir, name) |
| size = os.path.getsize(p); total += size |
| print(f" {name:<18} {size:>10,d} bytes sha256={sha256(p)}") |
| print(f" total {total / 1e6:.1f} MB (uncompressed; below the 200 MB threshold, no gzip)") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
