"""Build the mid-training candidate pool (Hub dataset MINZIK77/midtraining-pool), one config per source. usage: python build_pool.py probe NAME [--rows 40] # parse a few rows of one file, print a normalized row and counts python build_pool.py build NAME [NAME ...] [--upload] [--workers N] # all files -> OUT/data/NAME/train-*.parquet + OUT/stats/NAME.json python build_pool.py upload [NAME ...] # data + stats + this script -> the Hub repo (README: make_card.py) Each row is one agent trajectory in one schema for all sources: id, source, task_id, repo, scaffold, outcome, group, messages[{role, content, reasoning, tool_calls, tool_call_id, name}], tools, n_messages, n_chars, n_tokens_sigdig, n_tokens_smollm3, content_hash - id: source/file/row for parquet sources, source/file@byte_offset for jsonl sources. - messages keep the source text. Roles are mapped to system / user / assistant / tool. tool_calls is a JSON list of {id, name, arguments}; tools is the source's tool definitions as JSON text. - outcome: "resolved" / "failed" when the source labels the run (verified, resolved, reward), "incomplete" when the source records that the run stopped with an error (for example a timeout), else "unlabeled". - n_chars, n_tokens_*: characters and tokens of a ChatML rendering (tools as one system turn; reasoning, content and tool calls of each turn), with allenai/dolma2-tokenizer-sigdig @86d32e8 and HuggingFaceTB/SmolLM3-3B, no special tokens added. - content_hash: blake2b-64 of that rendering, for deduplication inside and across sources. Filters (light; the training mix selects further): - rows with no assistant turn or that do not parse; - rows of the 12 SWE-bench repositories, also forks with the same name (matched on the repository basename); - exact duplicates of the rendering inside a source (the first one stays, in file order). Sources are read at a pinned commit. Files are downloaded and cut into work units (parquet row groups of at most SLICE_ROWS rows, after re-chunking larger ones in one streaming pass; jsonl byte ranges), converted in parallel processes, then deduplicated and written as shards of about 1.5 GB of text. Shared hosts: every process sets oom_score_adj 1000 (the kernel kills these first), new units wait while the cgroup's anonymous memory is above MEMORY_SHARE of its limit, and each downloaded file is deleted when its units end. """ import argparse import hashlib import json import os import shutil import sys import time from collections import deque from concurrent.futures import FIRST_COMPLETED, ProcessPoolExecutor, ThreadPoolExecutor, wait from pathlib import Path HERE = Path(__file__).resolve().parent TOKDIR = Path(os.environ.get("POOL_TOK", HERE.parent / "datasize" / "tok")) OUT = Path(os.environ["POOL_OUT"]) if "POOL_OUT" in os.environ else HERE.parents[3] / "build" / "pool_repo" TMP = Path(os.environ["POOL_TMP"]) if "POOL_TMP" in os.environ else HERE.parents[3] / "build" / "pool_tmp" REPO = "MINZIK77/midtraining-pool" CATEGORY = "trajectory" # data/CATEGORY/NAME/ and config CATEGORY-NAME (this script builds the trajectory category) SWEB = {"astropy", "django", "matplotlib", "seaborn", "flask", "requests", "xarray", "pylint", "pytest", "scikit-learn", "sphinx", "sympy"} ROLE = {"gpt": "assistant", "human": "user", "model": "assistant", "function": "tool", "observation": "tool", "ipython": "tool", "tool_response": "tool"} SLICE_ROWS = 512 # parquet work unit: one row group of at most this many rows (larger row groups are re-chunked) CHUNK_BYTES = 32 << 20 # jsonl work unit: lines that start in this many bytes TOKEN_BATCH = 32 # rows per tokenizer call (only the lengths are kept) SHARD_CHARS = 1_500_000_000 # output shard: about this much rendered text MEMORY_SHARE = 0.4 # do not start new work units while the cgroup's anonymous memory is above this share of its limit def repo_base(s): if not s: return None s = str(s).lower() if "__" in s: # owner__repo-123 / owner__repo.hash.task s = s.split("__", 1)[1] for sep in (".", "-"): head = s.split(sep)[0] if head in SWEB: return head return s.split(".")[0] return s.rstrip("/").split("/")[-1] def is_sweb(*names): for n in names: b = repo_base(n) if b and (b in SWEB or any(b.startswith(x + "-") for x in SWEB if x not in ("requests", "flask"))): return True return False def flag(v, true_values=(1, True)): return "resolved" if v in true_values else "failed" def trove_outcome(r, p): v = r.get("result") if v in (None, "None", ""): return "unlabeled" try: return "resolved" if float(v) >= 1.0 else "failed" except ValueError: return "incomplete" # AgentTimeoutError, DaytonaError, ... # name -> spec. kind pq | jsonl. msgs: field with the turns. outcome/task/repo/group: functions of (row, path). SOURCES = { "nanoswe": dict(ds="nanoswe/nanoswe-trajs-261002", kind="pq", glob="train-*.parquet", license="mit", cols=["messages", "verified", "instance_id"], msgs="messages", scaffold="not named (tools: bash, file_editor)", outcome=lambda r, p: flag(bool(r["verified"])), task=lambda r, p: r["instance_id"]), "minicoder": dict(ds="ricdomolm/mini-coder-trajs-400k", kind="pq", glob="data/*.parquet", license="mit", cols=["messages", "verified", "instance_id"], msgs="messages", scaffold="mini-swe-agent", outcome=lambda r, p: flag(bool(r["verified"])), task=lambda r, p: r["instance_id"]), "klear": dict(ds="Kwai-Klear/SWE-smith-mini_swe_agent_plus-trajectories-66k", kind="pq", glob="data/*.parquet", license="mit", cols=["messages", "instance_id"], msgs="messages", scaffold="mini-swe-agent-plus", task=lambda r, p: r["instance_id"]), "openswe": dict(ds="nvidia/Open-SWE-Traces", kind="pq", glob="data/**/*.parquet", license="cc-by-4.0", cols=["messages", "tools", "resolved", "repo", "instance_id"], msgs="messages", tools="tools", # resolved: 1 solved, 0 not solved, -1 information unavailable (card) scaffold="see group", outcome=lambda r, p: {1: "resolved", 0: "failed"}.get(r["resolved"], "unlabeled"), task=lambda r, p: r["instance_id"], repo=lambda r, p: r["repo"], group=lambda r, p: "/".join(p.split("/")[1:-1])), # filtered_reward1-* is a second copy of the reward-1 runs (its own split on the card), so it is not read. "coderforge": dict(ds="togethercomputer/CoderForge-Preview", kind="pq", glob=["trajectories/R2E_Gym-*.parquet", "trajectories/SWE_Rebench-*.parquet", "trajectories/SWE_Smith-*.parquet"], license="none stated", cols=["messages", "tools", "reward", "image"], msgs="messages", tools="tools", scaffold="single scaffold (not named on the card)", group=lambda r, p: p.split("/")[-1].split("-")[0], outcome=lambda r, p: "resolved" if (r["reward"] or 0) >= 1.0 else "failed", task=lambda r, p: (r["image"] or "").split("/")[-1] or None, repo=lambda r, p: (r["image"] or "").split("/")[-1].split(":")[0].replace("_1776_", "__") or None), "nemoswe_v1": dict(ds="nvidia/Nemotron-SWE-v1", kind="jsonl", glob="data/r2e_gym.jsonl", license="cc-by-4.0", msgs="messages", tools="tools", scaffold="openhands", repo=lambda r, p: r.get("repo")), "nemoswe_v2_oh": dict(ds="nvidia/Nemotron-SFT-SWE-v2", kind="jsonl", glob="data/swe.jsonl", license="cc-by-4.0 (+ code licenses)", msgs="messages", tools="tools", scaffold="openhands"), # exit_status is 'submit' when the agent ended with its terminating action, else an OpenHands error message. "nebius_oh": dict(ds="nebius/SWE-rebench-openhands-trajectories", kind="pq", glob="*.parquet", license="cc-by-4.0", cols=["trajectory", "tools", "resolved", "repo", "instance_id", "exit_status"], msgs="trajectory", tools="tools", scaffold="openhands", outcome=lambda r, p: "resolved" if r["resolved"] == 1 else ("failed" if r.get("exit_status") == "submit" else "incomplete"), task=lambda r, p: r["instance_id"], repo=lambda r, p: r["repo"]), "swezero": dict(ds="nvidia/SWE-Zero-openhands-trajectories", kind="pq", glob="data/*.parquet", license="cc-by-4.0", cols=["trajectory", "repo"], msgs="trajectory", scaffold="openhands", repo=lambda r, p: r["repo"]), "scaleswe": dict(ds="AweAI-Team/Scale-SWE-Distilled", kind="pq", glob="data/*.parquet", license="none stated", cols=["messages", "system"], msgs="messages", system="system", scaffold="unspecified"), "sera": dict(ds="allenai/SERA-4.6-Lite-Best-Subset", kind="jsonl", glob="*.jsonl", license="apache-2.0", msgs="messages", scaffold="unspecified", task=lambda r, p: r.get("instance_id")), "terminal": dict(ds="nvidia/Nemotron-Terminal-Corpus", kind="pq", glob="**/*.parquet", license="cc-by-4.0", cols=["conversations"], msgs="conversations", scaffold="not named", group=lambda r, p: "/".join(p.split("/")[:-1]) or None), "otagent": dict(ds="open-thoughts/OpenThoughts-Agent-SFT-100K", kind="pq", glob="data/*.parquet", license="apache-2.0", cols=["conversations"], msgs="conversations", scaffold="terminus-2"), "agenttrove": dict(ds="open-thoughts/AgentTrove", kind="pq", glob="data/*.parquet", license="apache-2.0", cols=["conversations", "result", "original_source", "trace_source"], msgs="conversations", scaffold="terminus-2 (Harbor)", outcome=trove_outcome, group=lambda r, p: "/".join(str(x) for x in (r.get("original_source"), r.get("trace_source")) if x)), "opencode": dict(ds="nvidia/Nemotron-SFT-OpenCode-v1", kind="jsonl", glob="*/data.jsonl", license="cc-by-4.0", msgs="messages", tools="tools", scaffold="opencode", group=lambda r, p: p.split("/")[-2]), } def text_of(c): if c is None: return "" if isinstance(c, str): return c if isinstance(c, list): return "".join(x.get("text", "") if isinstance(x, dict) else str(x) for x in c) if isinstance(c, dict): return c.get("text") if isinstance(c.get("text"), str) else json.dumps(c, ensure_ascii=False, default=str) return str(c) def opt(v): return None if v is None or v == "" else str(v) def norm_messages(msgs, system=None): if isinstance(msgs, str): msgs = json.loads(msgs) out = [] if system and not any(isinstance(m, dict) and (m.get("role") or m.get("from")) == "system" for m in msgs or []): out.append(dict(role="system", content=str(system), reasoning=None, tool_calls=None, tool_call_id=None, name=None)) for m in msgs or []: if not isinstance(m, dict): continue role = m.get("role") or m.get("from") or "" role = ROLE.get(role, role) content = text_of(m.get("content", m.get("value"))) for part in m.get("parts") or []: content += part.get("text", "") if isinstance(part, dict) else str(part) calls = m.get("tool_calls") if isinstance(calls, str): calls = json.loads(calls) if calls.strip() else None norm = [] for tc in calls or []: fn = tc.get("function", tc) if isinstance(tc, dict) else {} args = fn.get("arguments") norm.append({"id": tc.get("id") if isinstance(tc, dict) else None, "name": fn.get("name"), "arguments": args if isinstance(args, str) or args is None else json.dumps(args, ensure_ascii=False, default=str)}) out.append(dict(role=str(role), content=content, reasoning=opt(m.get("reasoning_content") or m.get("reasoning")), tool_calls=json.dumps(norm, ensure_ascii=False) if norm else None, tool_call_id=opt(m.get("tool_call_id")), name=opt(m.get("name")))) return out def norm_tools(t): if t is None: return None if isinstance(t, str): return t or None if isinstance(t, (list, tuple)): if not t: return None if all(isinstance(x, str) for x in t): try: return json.dumps([json.loads(x) for x in t], ensure_ascii=False) except ValueError: return "\n".join(t) return json.dumps(t, ensure_ascii=False, default=str) def render(messages, tools): s = [f"<|im_start|>system\n# Tools\n{tools}<|im_end|>\n"] if tools else [] for m in messages: parts = [p for p in (m["reasoning"], m["content"]) if p] for c in json.loads(m["tool_calls"]) if m["tool_calls"] else []: parts.append(json.dumps({"name": c["name"], "arguments": c["arguments"]}, ensure_ascii=False)) s.append(f"<|im_start|>{m['role']}\n" + "\n".join(parts) + "<|im_end|>\n") return "".join(s) def schema(): import pyarrow as pa msg = pa.struct([("role", pa.string()), ("content", pa.string()), ("reasoning", pa.string()), ("tool_calls", pa.string()), ("tool_call_id", pa.string()), ("name", pa.string())]) return pa.schema([("id", pa.string()), ("source", pa.string()), ("task_id", pa.string()), ("repo", pa.string()), ("scaffold", pa.string()), ("outcome", pa.string()), ("group", pa.string()), ("messages", pa.list_(msg)), ("tools", pa.string()), ("n_messages", pa.int32()), ("n_chars", pa.int64()), ("n_tokens_sigdig", pa.int32()), ("n_tokens_smollm3", pa.int32()), ("content_hash", pa.string())]) _TOK = None def tokenizers(): global _TOK if _TOK is None: from tokenizers import Tokenizer _TOK = Tokenizer.from_file(str(TOKDIR / "sigdig.json")), Tokenizer.from_file(str(TOKDIR / "smollm3.json")) return _TOK def revision(ds): from huggingface_hub import HfApi return HfApi().dataset_info(ds).sha def list_files(spec, rev): from huggingface_hub import HfFileSystem base = f"datasets/{spec['ds']}@{rev}" globs = spec["glob"] if isinstance(spec["glob"], list) else [spec["glob"]] return sorted({p[len(base) + 1:] for g in globs for p in HfFileSystem().glob(f"{base}/{g}")}) def convert(name, spec, rel, key, r): """One source row -> one pool row (without the rendering columns), or the drop reason.""" try: messages = norm_messages(r[spec["msgs"]], r.get(spec["system"]) if spec.get("system") else None) tools = norm_tools(r.get(spec["tools"])) if spec.get("tools") else None except (ValueError, TypeError, AttributeError, KeyError): return "parse_error" if not any(m["role"] == "assistant" for m in messages): return "no_assistant" task = opt(spec["task"](r, rel)) if spec.get("task") else None repo = opt(spec["repo"](r, rel)) if spec.get("repo") else None if is_sweb(repo, task): return "swebench" group = opt(spec["group"](r, rel)) if spec.get("group") else None sep = "@" if spec["kind"] == "jsonl" else "/" return dict(id=f"{name}/{rel}{sep}{key}", source=name, task_id=task, repo=repo, scaffold=group.split("/")[0] if spec["scaffold"] == "see group" and group else spec["scaffold"], outcome=spec["outcome"](r, rel) if spec.get("outcome") else "unlabeled", group=group, messages=messages, tools=tools, n_messages=len(messages)) # ---------------------------------------------------------------- shared-host guards def low_priority(): """Ask the kernel to kill these processes first if memory runs out (other jobs share the host).""" try: with open("/proc/self/oom_score_adj", "w") as f: f.write("1000") except OSError: pass def memory_ok(): """False while the cgroup's anonymous memory is above MEMORY_SHARE of its limit (cgroup v2; else True).""" try: limit = open("/sys/fs/cgroup/memory.max").read().strip() if limit == "max": limit = os.sysconf("SC_PAGE_SIZE") * os.sysconf("SC_PHYS_PAGES") anon = next(int(line.split()[1]) for line in open("/sys/fs/cgroup/memory.stat") if line.startswith("anon ")) return anon < MEMORY_SHARE * int(limit) except (OSError, StopIteration, ValueError): return True # ---------------------------------------------------------------- work units def fetch(spec, rev, rel): from huggingface_hub import hf_hub_download for attempt in range(5): try: return hf_hub_download(spec["ds"], rel, repo_type="dataset", revision=rev, local_dir=str(TMP / spec["ds"].replace("/", "__"))) except Exception as error: # network or Hub errors if attempt == 4: raise print(f"download {rel} failed ({type(error).__name__}), retry", flush=True) time.sleep(30 * (attempt + 1)) def units_of(spec, path): """Work units of a file: ("pq", row group, first row) or ("jsonl", start, end); None if it needs re-chunking.""" if spec["kind"] == "pq": import pyarrow.parquet as pq meta = pq.ParquetFile(path).metadata sizes = [meta.row_group(rg).num_rows for rg in range(meta.num_row_groups)] if any(n > SLICE_ROWS for n in sizes): return None bases = [sum(sizes[:rg]) for rg in range(len(sizes))] return [("pq", rg, base) for rg, base in enumerate(bases) if sizes[rg]] size = os.path.getsize(path) return [("jsonl", s, min(size, s + CHUNK_BYTES)) for s in range(0, size, CHUNK_BYTES)] def rechunk(name, path): """Stream a parquet file (only the needed columns) into files of SLICE_ROWS rows, one row group each. Returns [(chunk path, first row in the source file)]. Memory stays at a few batches.""" import pyarrow as pa import pyarrow.parquet as pq low_priority() spec = SOURCES[name] out = Path(f"{path}.chunks") shutil.rmtree(out, ignore_errors=True) out.mkdir() pf = pq.ParquetFile(path, pre_buffer=False, buffer_size=8 << 20) chunks, buf, rows, first = [], [], 0, 0 for batch in pf.iter_batches(batch_size=64, columns=spec["cols"]): buf.append(batch) rows += batch.num_rows if rows >= SLICE_ROWS: table = pa.Table.from_batches(buf) head, rest = table.slice(0, SLICE_ROWS), table.slice(SLICE_ROWS) p = out / f"{len(chunks):06d}.parquet" pq.write_table(head, p, compression="lz4", row_group_size=SLICE_ROWS) chunks.append((str(p), first)) first += SLICE_ROWS buf, rows = (rest.to_batches() if rest.num_rows else []), rest.num_rows if rows: p = out / f"{len(chunks):06d}.parquet" pq.write_table(pa.Table.from_batches(buf), p, compression="lz4", row_group_size=SLICE_ROWS) chunks.append((str(p), first)) os.remove(path) return chunks def read_unit(spec, path, unit): """(key, row) pairs of one unit. A jsonl line belongs to the unit in which its first byte lies.""" if unit[0] == "pq": import pyarrow.parquet as pq _, rg, base = unit cols = spec["cols"] if not path.endswith(".chunks") and ".chunks/" not in path else None table = pq.ParquetFile(path).read_row_group(rg, columns=cols) for i, r in enumerate(table.to_pylist()): yield base + i, r return _, start, end = unit with open(path, "rb") as f: if start: f.seek(start - 1) f.readline() # skip the line that started before this unit while True: pos = f.tell() if pos >= end: return line = f.readline() if not line: return if line.strip(): yield pos, json.loads(line) def run_unit(name, rel, path, unit, order): """Convert one unit into OUT/parts/NAME/ORDER.parquet. ORDER sorts the parts in file order.""" import pyarrow as pa import pyarrow.parquet as pq low_priority() spec = SOURCES[name] sig, smol = tokenizers() counts = dict(rows=0, kept=0, parse_error=0, no_assistant=0, swebench=0) rows = [] for key, r in read_unit(spec, path, unit): counts["rows"] += 1 row = convert(name, spec, rel, key, r) if isinstance(row, str): counts[row] += 1 continue rows.append(row) counts["kept"] = len(rows) if rows: for i in range(0, len(rows), TOKEN_BATCH): batch = rows[i:i + TOKEN_BATCH] texts = [render(x["messages"], x["tools"]) for x in batch] a = [len(e.ids) for e in sig.encode_batch_fast(texts, add_special_tokens=False)] b = [len(e.ids) for e in smol.encode_batch_fast(texts, add_special_tokens=False)] for x, t, na, nb in zip(batch, texts, a, b, strict=True): x.update(n_chars=len(t), n_tokens_sigdig=na, n_tokens_smollm3=nb, content_hash=hashlib.blake2b(t.encode("utf-8"), digest_size=8).hexdigest()) out = OUT / "parts" / name out.mkdir(parents=True, exist_ok=True) pq.write_table(pa.Table.from_pylist(rows, schema=schema()), out / f"{order:012d}.parquet", compression="zstd", compression_level=6, row_group_size=256) return counts def compact(name, shard, parts, keeps): """Write the kept rows of consecutive parts as OUT/data/NAME/train-SHARD.parquet. Returns sums of the kept rows.""" import pyarrow as pa import pyarrow.compute as pc import pyarrow.parquet as pq low_priority() out = OUT / "data" / CATEGORY / name / f"train-{shard:05d}.parquet" sums = dict(rows=0, chars=0, tokens_sigdig=0, tokens_smollm3=0, outcomes={}) with pq.ParquetWriter(out, schema(), compression="zstd", compression_level=6) as writer: for part, keep in zip(parts, keeps, strict=True): table = pq.read_table(part).filter(pa.array(keep)) writer.write_table(table, row_group_size=256) sums["rows"] += table.num_rows sums["chars"] += pc.sum(table["n_chars"]).as_py() or 0 sums["tokens_sigdig"] += pc.sum(table["n_tokens_sigdig"]).as_py() or 0 sums["tokens_smollm3"] += pc.sum(table["n_tokens_smollm3"]).as_py() or 0 for k, v in zip(*pc.value_counts(table["outcome"]).flatten(), strict=True): sums["outcomes"][k.as_py()] = sums["outcomes"].get(k.as_py(), 0) + v.as_py() return sums def plan_shards(name): """Keep masks (first copy of each content_hash in part order) and the parts of each shard.""" import pyarrow.parquet as pq parts = sorted((OUT / "parts" / name).glob("*.parquet")) seen, shards, cur, size, dropped = set(), [], [], 0, 0 for part in parts: t = pq.read_table(part, columns=["content_hash", "n_chars"]) keep = [] for h in t["content_hash"].to_pylist(): keep.append(h not in seen) seen.add(h) dropped += keep.count(False) cur.append((part, keep)) size += sum(c for c, k in zip(t["n_chars"].to_pylist(), keep, strict=True) if k) if size >= SHARD_CHARS: shards.append(cur) cur, size = [], 0 if cur: shards.append(cur) return shards, dropped # ---------------------------------------------------------------- driver def build(names, workers, do_upload): """Download, convert, deduplicate, shard (and upload) every source in `names`, all through one process pool. At most `workers` process tasks run at a time, and no new unit starts while memory_ok() is False.""" import multiprocessing low_priority() os.environ["RAYON_NUM_THREADS"] = "1" # parallelism comes from the processes TMP.mkdir(parents=True, exist_ok=True) t0 = time.time() # spawn, not fork: the driver also runs download and upload threads procs = ProcessPoolExecutor(max_workers=workers, mp_context=multiprocessing.get_context("spawn"), initializer=low_priority) downloads = ThreadPoolExecutor(max_workers=16) uploads = ThreadPoolExecutor(max_workers=1) state, pending, ready, file_left = {}, {}, deque(), {} busy = 0 # process tasks submitted and not done for name in names: spec = SOURCES[name] rev = revision(spec["ds"]) files = list_files(spec, rev) for d in (OUT / "parts" / name, OUT / "data" / CATEGORY / name): shutil.rmtree(d, ignore_errors=True) (OUT / "data" / CATEGORY / name).mkdir(parents=True, exist_ok=True) state[name] = dict(spec=spec, rev=rev, files=files, open=len(files), units=0, done_units=0, counts=dict(rows=0, kept=0, parse_error=0, no_assistant=0, swebench=0), shards=0, sums=[]) print(f"[{name}] {spec['ds']}@{rev[:10]}: {len(files)} files", flush=True) for i, rel in enumerate(files): pending[downloads.submit(fetch, spec, rev, rel)] = ("download", name, (i, rel)) def add_units(name, i, rel, path, units, base_order=0): file_left[path] = len(units) state[name]["units"] += len(units) for j, unit in enumerate(units): ready.append((name, rel, path, unit, i * 1_000_000 + base_order + j)) if not units: os.remove(path) def finish(name): st = state[name] tot = {k: sum(s[k] for s in st["sums"]) for k in ("rows", "chars", "tokens_sigdig", "tokens_smollm3")} outcomes = {} for s in st["sums"]: for k, v in s["outcomes"].items(): outcomes[k] = outcomes.get(k, 0) + v stats = dict(name=name, dataset=st["spec"]["ds"], revision=st["rev"], license=st["spec"]["license"], scaffold=st["spec"]["scaffold"], files=len(st["files"]), built=time.strftime("%Y-%m-%d"), rows=st["counts"]["rows"], kept=tot["rows"], parse_error=st["counts"]["parse_error"], no_assistant=st["counts"]["no_assistant"], swebench=st["counts"]["swebench"], duplicate=st["dropped"], outcomes=outcomes, chars=tot["chars"], tokens_sigdig=tot["tokens_sigdig"], tokens_smollm3=tot["tokens_smollm3"], shards=st["shards"]) (OUT / "stats" / CATEGORY).mkdir(parents=True, exist_ok=True) (OUT / "stats" / CATEGORY / f"{name}.json").write_text(json.dumps(stats, indent=1)) shutil.rmtree(OUT / "parts" / name, ignore_errors=True) shutil.rmtree(TMP / st["spec"]["ds"].replace("/", "__"), ignore_errors=True) print(f"[{name}] done in {time.time() - t0:.0f}s: {json.dumps(stats)}", flush=True) if do_upload: pending[uploads.submit(upload, [name])] = ("upload", name, None) waited = 0.0 while pending or ready: while ready and busy < workers: if not memory_ok(): break name, rel, path, unit, order = ready.popleft() pending[procs.submit(run_unit, name, rel, path, unit, order)] = ("unit", name, path) busy += 1 if not pending: # only units left, held back by memory_ok() time.sleep(5) waited += 5 continue done, _ = wait(list(pending), timeout=10, return_when=FIRST_COMPLETED) if not done and ready and not memory_ok(): waited += 10 for fut in done: kind, name, extra = pending.pop(fut) st = state[name] result = fut.result() # an error stops the build if kind == "download": i, rel = extra units = units_of(st["spec"], result) if units is None: pending[procs.submit(rechunk, name, result)] = ("rechunk", name, (i, rel)) busy += 1 else: st["open"] -= 1 add_units(name, i, rel, result, units) elif kind == "rechunk": busy -= 1 i, rel = extra st["open"] -= 1 for k, (chunk, first) in enumerate(result): add_units(name, i, rel, chunk, [("pq", 0, first)], base_order=k * 1000) elif kind == "unit": busy -= 1 st["done_units"] += 1 for k in st["counts"]: st["counts"][k] += result[k] file_left[extra] -= 1 if file_left[extra] == 0: os.remove(extra) del file_left[extra] if st["done_units"] % 500 == 0: print(f"[{name}] {st['done_units']}/{st['units']} units ({st['open']} files open), " f"{st['counts']['kept']} rows, {time.time() - t0:.0f}s, memory waits {waited:.0f}s", flush=True) elif kind == "shard": busy -= 1 st["sums"].append(result) if len(st["sums"]) == st["shards"]: finish(name) elif kind == "upload": print(f"[{name}] uploaded", flush=True) if kind in ("download", "rechunk", "unit") and st["open"] == 0 and st["done_units"] == st["units"] \ and "dropped" not in st: shards, st["dropped"] = plan_shards(name) st["shards"] = len(shards) print(f"[{name}] {st['units']} units converted; {st['dropped']} duplicates; {len(shards)} shards", flush=True) if not shards: finish(name) for k, shard in enumerate(shards): parts, keeps = zip(*shard, strict=True) pending[procs.submit(compact, name, k, list(parts), list(keeps))] = ("shard", name, None) busy += 1 procs.shutdown() downloads.shutdown() uploads.shutdown() # ---------------------------------------------------------------- probe, card, upload def probe(name, rows): """Parse a few rows of the middle file by range requests and print one normalized row.""" import pyarrow.parquet as pq from huggingface_hub import HfFileSystem spec = SOURCES[name] rev = revision(spec["ds"]) files = list_files(spec, rev) rel = files[len(files) // 2] print(f"[{name}] {spec['ds']}@{rev[:10]} {len(files)} files; probing {rel}") path = f"datasets/{spec['ds']}@{rev}/{rel}" raw = [] if spec["kind"] == "pq": with HfFileSystem().open(path, "rb", block_size=32 << 20) as f: for batch in pq.ParquetFile(f).iter_batches(batch_size=rows, columns=spec["cols"]): raw = batch.to_pylist()[:rows] break else: with HfFileSystem().open(path, "r", encoding="utf-8", block_size=8 << 20) as f: for i, line in enumerate(f): if i >= rows: break if line.strip(): raw.append(json.loads(line)) kept, reasons, outcomes = [], {}, {} for i, r in enumerate(raw): row = convert(name, spec, rel, i, r) if isinstance(row, str): reasons[row] = reasons.get(row, 0) + 1 continue kept.append(row) outcomes[row["outcome"]] = outcomes.get(row["outcome"], 0) + 1 if not kept: print("no row kept", reasons) return sig, _ = tokenizers() toks = [len(e.ids) for e in sig.encode_batch_fast([render(x["messages"], x["tools"]) for x in kept], add_special_tokens=False)] print(f"kept {len(kept)} dropped {reasons} outcomes {outcomes}; tokens median {sorted(toks)[len(toks) // 2]}") def upload(names): """Upload the built configs (data, stats) and this script. README.md and LICENSE.md are written by make_card.py from the cross-checked source facts, so this function does not touch them.""" import fcntl from huggingface_hub import HfApi api = HfApi() names = names or sorted(p.stem for p in (OUT / "stats" / CATEGORY).glob("*.json")) with open(OUT / ".upload.lock", "w") as lock: fcntl.flock(lock, fcntl.LOCK_EX) api.create_repo(REPO, repo_type="dataset", private=False, exist_ok=True) (OUT / "scripts").mkdir(exist_ok=True) shutil.copy(__file__, OUT / "scripts" / "build_pool.py") for attempt in range(3): # one commit per call; the Hub skips content it already has on a retry try: api.upload_folder(repo_id=REPO, repo_type="dataset", folder_path=str(OUT), commit_message=f"Add {CATEGORY}: {', '.join(names)}", allow_patterns=["scripts/build_pool.py", *[f"stats/{CATEGORY}/{n}.json" for n in names], *[f"data/{CATEGORY}/{n}/*" for n in names]], delete_patterns=[f"data/{CATEGORY}/{n}/*" for n in names]) return except Exception as error: # network or Hub errors print(f"upload attempt {attempt + 1} failed: {type(error).__name__}: {error}", flush=True) time.sleep(60) raise SystemExit(f"upload of {names} failed") def main(): ap = argparse.ArgumentParser() ap.add_argument("cmd", choices=["probe", "build", "upload"]) ap.add_argument("names", nargs="*") ap.add_argument("--rows", type=int, default=40) ap.add_argument("--workers", type=int, default=max(1, (os.cpu_count() or 4) - 2)) ap.add_argument("--upload", action="store_true", help="build: upload each source after it is built") a = ap.parse_args() for n in a.names: if n not in SOURCES: sys.exit(f"unknown source {n}; known: {sorted(SOURCES)}") if a.cmd == "probe": for n in a.names or sorted(SOURCES): probe(n, a.rows) elif a.cmd == "build": build(a.names or sorted(SOURCES), a.workers, a.upload) else: upload(a.names) if __name__ == "__main__": main()