Datasets:

jaytonde05
/

kv-cache-quantization-commands

"""Build benchmark-ready JSONL files for the KV-cache quantization study.
Reads raw downloads from ~/datasets and writes ~/bench/data/:
  ruler_{4k,16k,32k,64k,128k}.jsonl  13 tasks x 40 samples per length
  gpqa_x4.jsonl                      198 questions x 4 shuffled samples
  docvqa_1000.jsonl (+ docvqa_img/)   seeded 1,000-question subset
  lcb_v6_x2.jsonl                    175 problems x 2 samples
  swe_kl_50.jsonl                    50 trajectories, 50K-150K tokens
Usage: python prep_data.py [--stage all|ruler|gpqa|docvqa|lcb|swe] [--workers N]
Other models: KVQ_TOK=<model dir> KVQ_DATA=<folder under ~/bench> (default Qwen3.8-27B, data);
  KVQ_RULER_TASKS / KVQ_RULER_LENGTHS (comma lists) limit the RULER grid.
"""
import argparse
import concurrent.futures as cf
import hashlib
import json
import os
import random
import subprocess
import sys
from pathlib import Path

HOME = Path.home()
RAW = HOME / "datasets"
OUT = HOME / "bench" / os.environ.get("KVQ_DATA", "data")
TOK = Path(os.environ.get("KVQ_TOK", HOME / "models" / "Qwen3.8-27B"))
RULER_RAW = OUT.parent / ("ruler_raw" + OUT.name.removeprefix("data"))  # per-tokenizer raw RULER output
SEED = 0

RULER_DIR = RAW / "ruler" / "RULER" / "scripts" / "data"
RULER_TASKS = [
    "niah_single_1", "niah_single_2", "niah_single_3",
    "niah_multikey_1", "niah_multikey_2", "niah_multikey_3",
    "niah_multivalue", "niah_multiquery", "vt", "cwe", "fwe", "qa_1", "qa_2",
]
RULER_LENGTHS = {"4k": 4096, "16k": 16384, "32k": 32768, "64k": 65536, "128k": 131072}
if os.environ.get("KVQ_RULER_TASKS"):
    RULER_TASKS = os.environ["KVQ_RULER_TASKS"].split(",")
if os.environ.get("KVQ_RULER_LENGTHS"):
    RULER_LENGTHS = {n: RULER_LENGTHS[n] for n in os.environ["KVQ_RULER_LENGTHS"].split(",")}
RULER_SAMPLES = 40
SHORT_OUT = 16384  # RULER / DocVQA: reasoning_effort=low; cap leaves room for thinking
LONG_OUT = 65536   # GPQA / LCB: reasoning_effort=xhigh (model default)


def write_jsonl(path, rows):
    path.parent.mkdir(parents=True, exist_ok=True)
    with open(path, "w") as f:
        for r in rows:
            f.write(json.dumps(r, ensure_ascii=False) + "\n")
    print(f"wrote {path} ({len(rows)} rows)", flush=True)


# ---------------------------------------------------------------- RULER
def _ruler_job(task, length_name, length):
    save_dir = RULER_RAW / length_name
    out_file = save_dir / task / "validation.jsonl"
    if out_file.exists() and sum(1 for _ in open(out_file)) == RULER_SAMPLES:
        return task, length_name, "cached"
    cmd = [sys.executable, "prepare.py", "--save_dir", str(save_dir), "--benchmark", "synthetic",
           "--task", task, "--tokenizer_path", str(TOK), "--tokenizer_type", "hf",
           "--max_seq_length", str(length), "--model_template_type", "base",
           "--num_samples", str(RULER_SAMPLES), "--random_seed", "42"]
    p = subprocess.run(cmd, cwd=RULER_DIR, capture_output=True, text=True)
    if p.returncode != 0:
        return task, length_name, "FAILED: " + (p.stderr or p.stdout)[-800:]
    return task, length_name, "ok"


def ruler(workers):
    jobs = [(t, n, L) for n, L in RULER_LENGTHS.items() for t in RULER_TASKS]
    # Longest contexts first so the slow jobs start early.
    jobs.sort(key=lambda j: -j[2])
    failed = []
    with cf.ProcessPoolExecutor(max_workers=workers) as ex:
        for task, n, status in ex.map(_ruler_job, *zip(*jobs)):
            print(f"ruler {n:>4} {task:<16} {status[:300]}", flush=True)
            if status.startswith("FAILED"):
                failed.append((task, n))
    for n in RULER_LENGTHS:
        rows = []
        for task in RULER_TASKS:
            f = RULER_RAW / n / task / "validation.jsonl"
            if not f.exists():
                continue
            for line in open(f):
                o = json.loads(line)
                prompt = o["input"].rstrip() + "\n\n" + o["answer_prefix"].strip()
                rows.append({"id": f"{task}-{o['index']}", "task": task, "length": n,
                             "answers": o["outputs"], "input_tokens": o["length"],
                             "prompt": prompt, "output_tokens": SHORT_OUT})
        write_jsonl(OUT / f"ruler_{n}.jsonl", rows)
    if failed:
        print("RULER FAILED JOBS:", failed, flush=True)


# ---------------------------------------------------------------- GPQA
GPQA_TEMPLATE = (
    "Answer the following multiple choice question. The last line of your response should be "
    "of the following format: 'ANSWER: $LETTER' (without quotes) where LETTER is one of ABCD. "
    "Think step by step before answering.\n\n{question}\n\nA) {A}\nB) {B}\nC) {C}\nD) {D}"
)


def gpqa():
    import pandas as pd
    df = pd.read_csv(RAW / "gpqa" / "gpqa_diamond.csv")
    rows = []
    for _, r in df.iterrows():
        opts = [r["Correct Answer"], r["Incorrect Answer 1"], r["Incorrect Answer 2"], r["Incorrect Answer 3"]]
        opts = [str(o).strip() for o in opts]
        for s in range(4):
            order = list(range(4))
            random.Random(f"{r['Record ID']}-{s}").shuffle(order)
            shuffled = [opts[i] for i in order]
            letter = "ABCD"[order.index(0)]
            prompt = GPQA_TEMPLATE.format(question=str(r["Question"]).strip(),
                                          A=shuffled[0], B=shuffled[1], C=shuffled[2], D=shuffled[3])
            rows.append({"id": r["Record ID"], "sample": s, "domain": r["High-level domain"],
                         "correct_letter": letter, "prompt": prompt, "output_tokens": LONG_OUT})
    write_jsonl(OUT / "gpqa_x4.jsonl", rows)


# ---------------------------------------------------------------- DocVQA
def docvqa():
    import pyarrow.parquet as pq
    files = sorted((RAW / "docvqa" / "DocVQA").glob("validation-*.parquet"))
    cols = ["questionId", "question", "answers", "question_types", "docId", "image"]
    meta = []  # (file, row) index first, images loaded only for chosen rows
    for fi, f in enumerate(files):
        n = pq.ParquetFile(f).metadata.num_rows
        meta += [(fi, i) for i in range(n)]
    chosen = sorted(random.Random(SEED).sample(range(len(meta)), 1000))
    by_file = {}
    for k in chosen:
        fi, i = meta[k]
        by_file.setdefault(fi, []).append(i)
    img_dir = OUT / "docvqa_img"
    img_dir.mkdir(parents=True, exist_ok=True)
    rows = []
    for fi, idxs in sorted(by_file.items()):
        t = pq.read_table(files[fi], columns=cols).take(idxs).to_pylist()
        for r in t:
            b = r["image"]["bytes"]
            ext = "png" if b[:8] == b"\x89PNG\r\n\x1a\n" else "jpg"
            p = img_dir / f"{r['questionId']}.{ext}"
            p.write_bytes(b)
            rows.append({"id": str(r["questionId"]), "doc_id": r["docId"], "answers": r["answers"],
                         "question_types": r["question_types"],
                         "prompt": f"{r['question']}\nAnswer the question using a single word or phrase.",
                         "image_files": [str(p)], "output_tokens": SHORT_OUT})
    print(f"docvqa: {len(meta)} validation questions, sampled {len(rows)}", flush=True)
    write_jsonl(OUT / "docvqa_1000.jsonl", rows)


# ---------------------------------------------------------------- LiveCodeBench
LCB_SYSTEM = ("You are an expert Python programmer. You will be given a question (problem specification) "
              "and will generate a correct Python program that matches the specification and passes all tests.")
LCB_WITH_STARTER = ("You will use the following starter code to write the solution to the problem and "
                    "enclose your code within delimiters.")
LCB_NO_STARTER = ("Read the inputs from stdin solve the problem and write the answer to stdout (do not directly "
                  "test on the sample inputs). Enclose your code within delimiters as follows. Ensure that when "
                  "the python program runs, it reads the inputs, runs the algorithm and writes output to STDOUT.")


def lcb_prompt(q):
    # Mirrors lcb_runner/prompts/code_generation.py:get_generic_question_template_answer,
    # with the generic system message prepended (the chat endpoint gets one user turn).
    p = f"{LCB_SYSTEM}\n\n### Question:\n{q['question_content']}\n\n"
    if q.get("starter_code"):
        p += f"### Format: {LCB_WITH_STARTER}\n```python\n{q['starter_code']}\n```\n\n"
    else:
        p += f"### Format: {LCB_NO_STARTER}\n```python\n# YOUR CODE HERE\n```\n\n"
    p += "### Answer: (use the provided format with backticks)\n\n"
    return p


def lcb():
    rows = []
    with open(RAW / "livecodebench" / "test6.jsonl") as f:
        problems = [json.loads(line) for line in f]
    for q in problems:
        for s in range(2):
            rows.append({"id": q["question_id"], "sample": s, "platform": q["platform"],
                         "difficulty": q["difficulty"], "contest_date": q["contest_date"],
                         "prompt": lcb_prompt(q), "output_tokens": LONG_OUT})
    print(f"lcb: {len(problems)} v6 problems", flush=True)
    write_jsonl(OUT / "lcb_v6_x2.jsonl", rows)


# ---------------------------------------------------------------- SWE trajectories
def _clean_msg(m):
    out = {"role": m["role"], "content": m.get("content") or ""}
    if m.get("tool_calls"):
        out["tool_calls"] = [{"id": c.get("id"), "type": c.get("type") or "function",
                              "function": {"name": c["function"]["name"],
                                           "arguments": c["function"]["arguments"]}}
                             for c in m["tool_calls"]]
    if m["role"] == "tool":
        out["name"] = m.get("name")
        out["tool_call_id"] = m.get("tool_call_id")
    return out


def _strip_none(x):
    if isinstance(x, dict):
        return {k: _strip_none(v) for k, v in x.items() if v is not None}
    if isinstance(x, list):
        return [_strip_none(v) for v in x]
    return x


def swe():
    import pyarrow.parquet as pq
    from transformers import AutoTokenizer
    tok = AutoTokenizer.from_pretrained(TOK)
    pf = pq.ParquetFile(RAW / "swe" / "swe-rebench-openhands" / "trajectories.parquet")
    lo_chars, hi_chars = 50_000 * 2.5, 150_000 * 4.5   # loose char window before exact tokenization
    cands = []
    for g in range(pf.metadata.num_row_groups):
        t = pf.read_row_group(g, columns=["trajectory_id", "repo", "trajectory"]).to_pylist()
        for i, r in enumerate(t):
            n = sum(len(m.get("content") or "") + sum(len(c["function"]["arguments"] or "")
                    for c in (m.get("tool_calls") or [])) for m in r["trajectory"])
            if lo_chars <= n <= hi_chars:
                cands.append((g, i, r["repo"]))
    print(f"swe: {pf.metadata.num_rows} trajectories, {len(cands)} in the char window", flush=True)
    random.Random(SEED).shuffle(cands)
    picked, repos, seen = [], set(), 0
    for g, i, repo in cands:
        if len(picked) >= 50:
            break
        if repo in repos:          # one trajectory per repo for diversity
            continue
        seen += 1
        r = pf.read_row_group(g).slice(i, 1).to_pylist()[0]
        msgs = [_clean_msg(m) for m in r["trajectory"]]
        tools = _strip_none(r["tools"])
        ids = None
        for attempt in range(2):
            try:
                ids = tok.apply_chat_template(msgs, tools=tools, tokenize=True)
                if not isinstance(ids, list):
                    ids = ids["input_ids"]
                break
            except Exception as e:
                if attempt == 0:  # some templates need tool-call arguments as dicts
                    for m in msgs:
                        for c in m.get("tool_calls", []):
                            try:
                                c["function"]["arguments"] = json.loads(c["function"]["arguments"])
                            except Exception:
                                pass
                else:
                    print("swe skip render:", r["trajectory_id"], repr(e)[:150], flush=True)
        if ids is None:
            continue
        if not (50_000 <= len(ids) <= 150_000):
            continue
        repos.add(repo)
        picked.append({"id": r["trajectory_id"], "instance_id": r["instance_id"], "repo": repo,
                       "resolved": r["resolved"], "n_tokens": len(ids), "n_messages": len(msgs),
                       "assistant_turns": [k for k, m in enumerate(msgs) if m["role"] == "assistant"],
                       "messages": msgs, "tools": tools})
    print(f"swe: tokenized {seen} candidates, kept {len(picked)}", flush=True)
    write_jsonl(OUT / "swe_kl_50.jsonl", picked)


def manifest():
    m = {}
    for p in sorted(OUT.glob("*.jsonl")):
        h = hashlib.sha256(p.read_bytes()).hexdigest()
        m[p.name] = {"rows": sum(1 for _ in open(p)), "sha256": h}
    (OUT / "MANIFEST.json").write_text(json.dumps(m, indent=1))
    print(json.dumps(m, indent=1), flush=True)


if __name__ == "__main__":
    ap = argparse.ArgumentParser()
    ap.add_argument("--stage", default="all", choices=["all", "ruler", "gpqa", "docvqa", "lcb", "swe"])
    ap.add_argument("--workers", type=int, default=20)
    a = ap.parse_args()
    stages = ["gpqa", "lcb", "docvqa", "swe", "ruler"] if a.stage == "all" else [a.stage]
    for s in stages:
        print(f"===== {s}", flush=True)
        if s == "ruler":
            ruler(a.workers)
        else:
            globals()[s]()
    manifest()
    print("PREP_DONE", flush=True)

	"""Build benchmark-ready JSONL files for the KV-cache quantization study.

	Reads raw downloads from ~/datasets and writes ~/bench/data/:
	ruler_{4k,16k,32k,64k,128k}.jsonl 13 tasks x 40 samples per length
	gpqa_x4.jsonl 198 questions x 4 shuffled samples
	docvqa_1000.jsonl (+ docvqa_img/) seeded 1,000-question subset
	lcb_v6_x2.jsonl 175 problems x 2 samples
	swe_kl_50.jsonl 50 trajectories, 50K-150K tokens

	Usage: python prep_data.py [--stage all\|ruler\|gpqa\|docvqa\|lcb\|swe] [--workers N]
	Other models: KVQ_TOK=<model dir> KVQ_DATA=<folder under ~/bench> (default Qwen3.8-27B, data);
	KVQ_RULER_TASKS / KVQ_RULER_LENGTHS (comma lists) limit the RULER grid.
	"""
	import argparse
	import concurrent.futures as cf
	import hashlib
	import json
	import os
	import random
	import subprocess
	import sys
	from pathlib import Path

	HOME = Path.home()
	RAW = HOME / "datasets"
	OUT = HOME / "bench" / os.environ.get("KVQ_DATA", "data")
	TOK = Path(os.environ.get("KVQ_TOK", HOME / "models" / "Qwen3.8-27B"))
	RULER_RAW = OUT.parent / ("ruler_raw" + OUT.name.removeprefix("data")) # per-tokenizer raw RULER output
	SEED = 0

	RULER_DIR = RAW / "ruler" / "RULER" / "scripts" / "data"
	RULER_TASKS = [
	"niah_single_1", "niah_single_2", "niah_single_3",
	"niah_multikey_1", "niah_multikey_2", "niah_multikey_3",
	"niah_multivalue", "niah_multiquery", "vt", "cwe", "fwe", "qa_1", "qa_2",
	]
	RULER_LENGTHS = {"4k": 4096, "16k": 16384, "32k": 32768, "64k": 65536, "128k": 131072}
	if os.environ.get("KVQ_RULER_TASKS"):
	RULER_TASKS = os.environ["KVQ_RULER_TASKS"].split(",")
	if os.environ.get("KVQ_RULER_LENGTHS"):
	RULER_LENGTHS = {n: RULER_LENGTHS[n] for n in os.environ["KVQ_RULER_LENGTHS"].split(",")}
	RULER_SAMPLES = 40
	SHORT_OUT = 16384 # RULER / DocVQA: reasoning_effort=low; cap leaves room for thinking
	LONG_OUT = 65536 # GPQA / LCB: reasoning_effort=xhigh (model default)


	def write_jsonl(path, rows):
	path.parent.mkdir(parents=True, exist_ok=True)
	with open(path, "w") as f:
	for r in rows:
	f.write(json.dumps(r, ensure_ascii=False) + "\n")
	print(f"wrote {path} ({len(rows)} rows)", flush=True)


	# ---------------------------------------------------------------- RULER
	def _ruler_job(task, length_name, length):
	save_dir = RULER_RAW / length_name
	out_file = save_dir / task / "validation.jsonl"
	if out_file.exists() and sum(1 for _ in open(out_file)) == RULER_SAMPLES:
	return task, length_name, "cached"
	cmd = [sys.executable, "prepare.py", "--save_dir", str(save_dir), "--benchmark", "synthetic",
	"--task", task, "--tokenizer_path", str(TOK), "--tokenizer_type", "hf",
	"--max_seq_length", str(length), "--model_template_type", "base",
	"--num_samples", str(RULER_SAMPLES), "--random_seed", "42"]
	p = subprocess.run(cmd, cwd=RULER_DIR, capture_output=True, text=True)
	if p.returncode != 0:
	return task, length_name, "FAILED: " + (p.stderr or p.stdout)[-800:]
	return task, length_name, "ok"


	def ruler(workers):
	jobs = [(t, n, L) for n, L in RULER_LENGTHS.items() for t in RULER_TASKS]
	# Longest contexts first so the slow jobs start early.
	jobs.sort(key=lambda j: -j[2])
	failed = []
	with cf.ProcessPoolExecutor(max_workers=workers) as ex:
	for task, n, status in ex.map(_ruler_job, zip(jobs)):
	print(f"ruler {n:>4} {task:<16} {status[:300]}", flush=True)
	if status.startswith("FAILED"):
	failed.append((task, n))
	for n in RULER_LENGTHS:
	rows = []
	for task in RULER_TASKS:
	f = RULER_RAW / n / task / "validation.jsonl"
	if not f.exists():
	continue
	for line in open(f):
	o = json.loads(line)
	prompt = o["input"].rstrip() + "\n\n" + o["answer_prefix"].strip()
	rows.append({"id": f"{task}-{o['index']}", "task": task, "length": n,
	"answers": o["outputs"], "input_tokens": o["length"],
	"prompt": prompt, "output_tokens": SHORT_OUT})
	write_jsonl(OUT / f"ruler_{n}.jsonl", rows)
	if failed:
	print("RULER FAILED JOBS:", failed, flush=True)


	# ---------------------------------------------------------------- GPQA
	GPQA_TEMPLATE = (
	"Answer the following multiple choice question. The last line of your response should be "
	"of the following format: 'ANSWER: $LETTER' (without quotes) where LETTER is one of ABCD. "
	"Think step by step before answering.\n\n{question}\n\nA) {A}\nB) {B}\nC) {C}\nD) {D}"
	)


	def gpqa():
	import pandas as pd
	df = pd.read_csv(RAW / "gpqa" / "gpqa_diamond.csv")
	rows = []
	for _, r in df.iterrows():
	opts = [r["Correct Answer"], r["Incorrect Answer 1"], r["Incorrect Answer 2"], r["Incorrect Answer 3"]]
	opts = [str(o).strip() for o in opts]
	for s in range(4):
	order = list(range(4))
	random.Random(f"{r['Record ID']}-{s}").shuffle(order)
	shuffled = [opts[i] for i in order]
	letter = "ABCD"[order.index(0)]
	prompt = GPQA_TEMPLATE.format(question=str(r["Question"]).strip(),
	A=shuffled[0], B=shuffled[1], C=shuffled[2], D=shuffled[3])
	rows.append({"id": r["Record ID"], "sample": s, "domain": r["High-level domain"],
	"correct_letter": letter, "prompt": prompt, "output_tokens": LONG_OUT})
	write_jsonl(OUT / "gpqa_x4.jsonl", rows)


	# ---------------------------------------------------------------- DocVQA
	def docvqa():
	import pyarrow.parquet as pq
	files = sorted((RAW / "docvqa" / "DocVQA").glob("validation-*.parquet"))
	cols = ["questionId", "question", "answers", "question_types", "docId", "image"]
	meta = [] # (file, row) index first, images loaded only for chosen rows
	for fi, f in enumerate(files):
	n = pq.ParquetFile(f).metadata.num_rows
	meta += [(fi, i) for i in range(n)]
	chosen = sorted(random.Random(SEED).sample(range(len(meta)), 1000))
	by_file = {}
	for k in chosen:
	fi, i = meta[k]
	by_file.setdefault(fi, []).append(i)
	img_dir = OUT / "docvqa_img"
	img_dir.mkdir(parents=True, exist_ok=True)
	rows = []
	for fi, idxs in sorted(by_file.items()):
	t = pq.read_table(files[fi], columns=cols).take(idxs).to_pylist()
	for r in t:
	b = r["image"]["bytes"]
	ext = "png" if b[:8] == b"\x89PNG\r\n\x1a\n" else "jpg"
	p = img_dir / f"{r['questionId']}.{ext}"
	p.write_bytes(b)
	rows.append({"id": str(r["questionId"]), "doc_id": r["docId"], "answers": r["answers"],
	"question_types": r["question_types"],
	"prompt": f"{r['question']}\nAnswer the question using a single word or phrase.",
	"image_files": [str(p)], "output_tokens": SHORT_OUT})
	print(f"docvqa: {len(meta)} validation questions, sampled {len(rows)}", flush=True)
	write_jsonl(OUT / "docvqa_1000.jsonl", rows)


	# ---------------------------------------------------------------- LiveCodeBench
	LCB_SYSTEM = ("You are an expert Python programmer. You will be given a question (problem specification) "
	"and will generate a correct Python program that matches the specification and passes all tests.")
	LCB_WITH_STARTER = ("You will use the following starter code to write the solution to the problem and "
	"enclose your code within delimiters.")
	LCB_NO_STARTER = ("Read the inputs from stdin solve the problem and write the answer to stdout (do not directly "
	"test on the sample inputs). Enclose your code within delimiters as follows. Ensure that when "
	"the python program runs, it reads the inputs, runs the algorithm and writes output to STDOUT.")


	def lcb_prompt(q):
	# Mirrors lcb_runner/prompts/code_generation.py:get_generic_question_template_answer,
	# with the generic system message prepended (the chat endpoint gets one user turn).
	p = f"{LCB_SYSTEM}\n\n### Question:\n{q['question_content']}\n\n"
	if q.get("starter_code"):
	p += f"### Format: {LCB_WITH_STARTER}\n```python\n{q['starter_code']}\n```\n\n"
	else:
	p += f"### Format: {LCB_NO_STARTER}\n```python\n# YOUR CODE HERE\n```\n\n"
	p += "### Answer: (use the provided format with backticks)\n\n"
	return p


	def lcb():
	rows = []
	with open(RAW / "livecodebench" / "test6.jsonl") as f:
	problems = [json.loads(line) for line in f]
	for q in problems:
	for s in range(2):
	rows.append({"id": q["question_id"], "sample": s, "platform": q["platform"],
	"difficulty": q["difficulty"], "contest_date": q["contest_date"],
	"prompt": lcb_prompt(q), "output_tokens": LONG_OUT})
	print(f"lcb: {len(problems)} v6 problems", flush=True)
	write_jsonl(OUT / "lcb_v6_x2.jsonl", rows)


	# ---------------------------------------------------------------- SWE trajectories
	def _clean_msg(m):
	out = {"role": m["role"], "content": m.get("content") or ""}
	if m.get("tool_calls"):
	out["tool_calls"] = [{"id": c.get("id"), "type": c.get("type") or "function",
	"function": {"name": c["function"]["name"],
	"arguments": c["function"]["arguments"]}}
	for c in m["tool_calls"]]
	if m["role"] == "tool":
	out["name"] = m.get("name")
	out["tool_call_id"] = m.get("tool_call_id")
	return out


	def _strip_none(x):
	if isinstance(x, dict):
	return {k: _strip_none(v) for k, v in x.items() if v is not None}
	if isinstance(x, list):
	return [_strip_none(v) for v in x]
	return x


	def swe():
	import pyarrow.parquet as pq
	from transformers import AutoTokenizer
	tok = AutoTokenizer.from_pretrained(TOK)
	pf = pq.ParquetFile(RAW / "swe" / "swe-rebench-openhands" / "trajectories.parquet")
	lo_chars, hi_chars = 50_000 * 2.5, 150_000 * 4.5 # loose char window before exact tokenization
	cands = []
	for g in range(pf.metadata.num_row_groups):
	t = pf.read_row_group(g, columns=["trajectory_id", "repo", "trajectory"]).to_pylist()
	for i, r in enumerate(t):
	n = sum(len(m.get("content") or "") + sum(len(c["function"]["arguments"] or "")
	for c in (m.get("tool_calls") or [])) for m in r["trajectory"])
	if lo_chars <= n <= hi_chars:
	cands.append((g, i, r["repo"]))
	print(f"swe: {pf.metadata.num_rows} trajectories, {len(cands)} in the char window", flush=True)
	random.Random(SEED).shuffle(cands)
	picked, repos, seen = [], set(), 0
	for g, i, repo in cands:
	if len(picked) >= 50:
	break
	if repo in repos: # one trajectory per repo for diversity
	continue
	seen += 1
	r = pf.read_row_group(g).slice(i, 1).to_pylist()[0]
	msgs = [_clean_msg(m) for m in r["trajectory"]]
	tools = _strip_none(r["tools"])
	ids = None
	for attempt in range(2):
	try:
	ids = tok.apply_chat_template(msgs, tools=tools, tokenize=True)
	if not isinstance(ids, list):
	ids = ids["input_ids"]
	break
	except Exception as e:
	if attempt == 0: # some templates need tool-call arguments as dicts
	for m in msgs:
	for c in m.get("tool_calls", []):
	try:
	c["function"]["arguments"] = json.loads(c["function"]["arguments"])
	except Exception:
	pass
	else:
	print("swe skip render:", r["trajectory_id"], repr(e)[:150], flush=True)
	if ids is None:
	continue
	if not (50_000 <= len(ids) <= 150_000):
	continue
	repos.add(repo)
	picked.append({"id": r["trajectory_id"], "instance_id": r["instance_id"], "repo": repo,
	"resolved": r["resolved"], "n_tokens": len(ids), "n_messages": len(msgs),
	"assistant_turns": [k for k, m in enumerate(msgs) if m["role"] == "assistant"],
	"messages": msgs, "tools": tools})
	print(f"swe: tokenized {seen} candidates, kept {len(picked)}", flush=True)
	write_jsonl(OUT / "swe_kl_50.jsonl", picked)


	def manifest():
	m = {}
	for p in sorted(OUT.glob("*.jsonl")):
	h = hashlib.sha256(p.read_bytes()).hexdigest()
	m[p.name] = {"rows": sum(1 for _ in open(p)), "sha256": h}
	(OUT / "MANIFEST.json").write_text(json.dumps(m, indent=1))
	print(json.dumps(m, indent=1), flush=True)


	if __name__ == "__main__":
	ap = argparse.ArgumentParser()
	ap.add_argument("--stage", default="all", choices=["all", "ruler", "gpqa", "docvqa", "lcb", "swe"])
	ap.add_argument("--workers", type=int, default=20)
	a = ap.parse_args()
	stages = ["gpqa", "lcb", "docvqa", "swe", "ruler"] if a.stage == "all" else [a.stage]
	for s in stages:
	print(f"===== {s}", flush=True)
	if s == "ruler":
	ruler(a.workers)
	else:
	globals()[s]()
	manifest()
	print("PREP_DONE", flush=True)