Super-squash branch 'main' using huggingface_hub

Co-authored-by: amannagarkar <amannagarkar@users.noreply.huggingface.co>

README.md

@@ -0,0 +1,10 @@
+---
+A mixture of datasets focused on Source/Intermediate Representation training for multilingual code generation.
+For SCU CSEN346.
+
+
+Sources:
+UKPLab/SLTrans
+bigcode/the-stack
+allenai/peS2o
+open-web-math/open-web-math

build_mixed_dataset.py

@@ -0,0 +1,504 @@
+#!/usr/bin/env python3
+"""
+build_mixed_dataset.py — Four-source mixed pre-training corpus builder.
+
+Sources
+-------
+  SLTrans      local parquet  (balanced language x IR-type)   --sltrans-tokens
+  peS2o        allenai/peS2o  (open scientific papers)        --pes2o-tokens
+  TheStack     bigcode/the-stack (permissively licensed code)  --stack-tokens
+  OpenWebMath  open-web-math/open-web-math (math web text)    --owm-tokens
+
+Set any cap to 0 to skip that source.
+
+Output
+------
+  JSONL shards under --output-dir, one filename prefix per source:
+    sltrans-00000.jsonl, pes2o-00000.jsonl, the_stack-00000.jsonl, ...
+  Each record:
+    {"text": "...", "source": "...", "meta": {...}, "est_tokens": N}
+  Plus manifest.json summarising the run.
+
+Usage
+-----
+  pip install "datasets>=2.18" pyarrow pandas tqdm
+  huggingface-cli login          # peS2o and the-stack are gated
+
+  python build_mixed_dataset.py
+  python build_mixed_dataset.py --sltrans-tokens 500e6 --owm-tokens 200e6
+  python build_mixed_dataset.py --stack-tokens 0      # skip TheStack
+  python build_mixed_dataset.py --stack-langs python,rust,go
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import random
+import re
+import socket
+import sys
+import time
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+
+import pandas as pd
+import pyarrow.parquet as pq
+from tqdm import tqdm
+
+socket.setdefaulttimeout(90)
+
+# ── constants ──────────────────────────────────────────────────────────────────
+SLTRANS_PROBE_ROWS = 200
+SLTRANS_SKIP_DIRS  = {".venv", "__pycache__", ".git"}
+
+THE_STACK_LANGS = [
+    "python", "c", "cpp", "rust", "go",
+    "java", "javascript", "typescript",
+]
+
+_TRANSIENT_ERRORS = ("ssl", "timeout", "handshake", "connection", "timed out")
+
+
+# ── token estimation ───────────────────────────────────────────────────────────
+
+def estimate_tokens(text: str) -> int:
+    return int(len(text.split()) * 1.5)
+
+
+# ── JSONL shard writer ─────────────────────────────────────────────────────────
+
+class ShardWriter:
+    def __init__(self, out_dir: Path, prefix: str, records_per_shard: int):
+        out_dir.mkdir(parents=True, exist_ok=True)
+        self._dir, self._pfx, self._rps = out_dir, prefix, records_per_shard
+        self._idx = self._n = 0
+        self._fh = None
+        self._roll()
+
+    def _roll(self):
+        if self._fh:
+            self._fh.close()
+        self._fh = (self._dir / f"{self._pfx}-{self._idx:05d}.jsonl").open("w", encoding="utf-8")
+        self._n = 0
+        self._idx += 1
+
+    def write(self, record: dict):
+        self._fh.write(json.dumps(record, ensure_ascii=False) + "\n")
+        self._n += 1
+        if self._n >= self._rps:
+            self._roll()
+
+    def close(self):
+        if self._fh:
+            self._fh.close()
+            self._fh = None
+
+
+# ── SLTrans (local parquet) ────────────────────────────────────────────────────
+
+def _sltrans_find_groups(root: Path) -> dict[tuple[str, str], list[Path]]:
+    """Return {(language, ir_type): [sorted shard paths]}."""
+    groups: dict[tuple[str, str], list[Path]] = {}
+    for d in sorted(root.iterdir()):
+        if not d.is_dir() or d.name in SLTRANS_SKIP_DIRS:
+            continue
+        for f in sorted(d.glob("*.parquet")):
+            m = re.match(r"^(Perf_Optimized|Size_Optimized)", f.name)
+            if m:
+                groups.setdefault((d.name, m.group(1)), []).append(f)
+    return groups
+
+
+def _pq_nrows(files: list[Path]) -> int:
+    return sum(pq.ParquetFile(f).metadata.num_rows for f in files)
+
+
+def _est_tok_df(src: pd.Series, ir: pd.Series) -> pd.Series:
+    src_w = src.fillna("").str.split().str.len().fillna(0)
+    ir_w  = ir.fillna("").str.split().str.len().fillna(0)
+    return ((src_w + ir_w + 5) * 1.5).astype(int)
+
+
+def _probe_avg_tokens(files: list[Path], n: int, rng: random.Random) -> float:
+    frames = []
+    seed = rng.randint(0, 2**31)
+    for f in files:
+        df = pq.ParquetFile(f).read_row_group(0).to_pandas()
+        if not df.empty:
+            frames.append(df.sample(min(n, len(df)), random_state=seed))
+        if sum(len(x) for x in frames) >= n:
+            break
+    if not frames:
+        return 0.0
+    p = pd.concat(frames, ignore_index=True).head(n)
+    p = p.dropna(subset=["Source_Code", "IR_Original"])
+    p = p[(p["Source_Code"] != "") & (p["IR_Original"] != "")]
+    return float(_est_tok_df(p["Source_Code"], p["IR_Original"]).mean()) if len(p) else 0.0
+
+
+def _sltrans_allocate(
+    groups: dict[tuple[str, str], list[Path]],
+    total: int,
+    rng: random.Random,
+) -> dict[tuple[str, str], int]:
+    """Equal-share budget with deficit redistribution for small groups."""
+    keys = sorted(groups)
+    avail: dict[tuple[str, str], int] = {}
+    for k in tqdm(keys, desc="      probe", unit="grp", leave=False):
+        rows = _pq_nrows(groups[k])
+        avg  = _probe_avg_tokens(groups[k], SLTRANS_PROBE_ROWS, rng)
+        avail[k] = int(rows * avg)
+        tqdm.write(
+            f"      {k[0]:>15}/{k[1]:<16}  ~{avail[k]:>14,} tok"
+            f"  ({rows:,} rows, avg {avg:.0f})"
+        )
+    budgets = {k: total // len(keys) for k in keys}
+    for _ in range(len(keys)):
+        capped  = {k: min(budgets[k], avail[k]) for k in keys}
+        deficit = sum(budgets[k] - capped[k] for k in keys)
+        if not deficit:
+            break
+        room = [k for k in keys if capped[k] < avail[k]]
+        if not room:
+            break
+        bonus = deficit // len(room)
+        for k in room:
+            capped[k] = min(capped[k] + bonus, avail[k])
+        budgets = capped
+    return budgets
+
+
+def write_sltrans(
+    root: Path,
+    budget: int,
+    writer: ShardWriter,
+    rng: random.Random,
+    min_tokens: int,
+) -> int:
+    groups = _sltrans_find_groups(root)
+    if not groups:
+        print(f"    WARNING: no SLTrans parquet files found in {root}", file=sys.stderr)
+        return 0
+
+    budgets = _sltrans_allocate(groups, budget, rng)
+    total_written = 0
+    bar = tqdm(total=budget, unit="tok", unit_scale=True,
+               desc="      write", dynamic_ncols=True)
+
+    for (lang, ir_type) in sorted(groups):
+        g_budget  = budgets[(lang, ir_type)]
+        g_written = 0
+        files = list(groups[(lang, ir_type)])
+        rng.shuffle(files)
+
+        for f in files:
+            if g_written >= g_budget:
+                break
+            pf = pq.ParquetFile(f)
+            for gi in range(pf.num_row_groups):
+                if g_written >= g_budget:
+                    break
+                df = pf.read_row_group(gi).to_pandas()
+                df = df.dropna(subset=["Source_Code", "IR_Original"])
+                df = df[(df["Source_Code"] != "") & (df["IR_Original"] != "")]
+                if df.empty:
+                    continue
+                df = df.sample(frac=1, random_state=rng.randint(0, 2**31)).reset_index(drop=True)
+                df["_t"] = _est_tok_df(df["Source_Code"], df["IR_Original"])
+
+                remaining = g_budget - g_written
+                cutoff = max(int((df["_t"].cumsum() <= remaining).sum()), 1)
+                for row in df.iloc[:cutoff].to_dict("records"):
+                    toks = int(row["_t"])
+                    if toks < min_tokens:
+                        continue
+                    text = (
+                        f"<source>\n{row['Source_Code']}\n</source>\n"
+                        f"<llvm_ir>\n{row['IR_Original']}\n</llvm_ir>"
+                    )
+                    writer.write({
+                        "text": text,
+                        "source": "sltrans",
+                        "meta": {"language": lang, "ir_type": ir_type},
+                        "est_tokens": toks,
+                    })
+                    g_written    += toks
+                    total_written += toks
+                    bar.update(min(toks, budget - bar.n))
+    bar.close()
+    return total_written
+
+
+# ── HuggingFace streaming ──────────────────────────────────────────────────────
+
+def _hf_open(
+    hf_path: str,
+    split: str = "train",
+    hf_config: str | None = None,
+    data_dir: str | None = None,
+):
+    """Open one HF streaming dataset with exponential-backoff retry."""
+    from datasets import load_dataset
+
+    kw: dict = {"split": split, "streaming": True}
+    if hf_config:
+        kw["name"] = hf_config
+    if data_dir:
+        kw["data_dir"] = data_dir
+
+    for attempt in range(5):
+        try:
+            return load_dataset(hf_path, **kw)
+        except ValueError as e:
+            if "Bad split" in str(e):
+                return None
+            raise
+        except Exception as e:
+            if attempt < 4 and any(k in str(e).lower() for k in _TRANSIENT_ERRORS):
+                time.sleep(2 ** attempt)
+                continue
+            raise
+    return None
+
+
+def _hf_iter(
+    hf_path: str,
+    split: str = "train",
+    hf_config: str | None = None,
+    subsets: list[str] | None = None,
+):
+    """
+    Yield rows from a HuggingFace streaming dataset.
+    For TheStack, pass subsets; streams are resolved in parallel and interleaved.
+    """
+    if not subsets:
+        ds = _hf_open(hf_path, split=split, hf_config=hf_config)
+        if ds is not None:
+            yield from ds
+        return
+
+    # Resolve subset streams in parallel (each resolution is an HTTP round-trip).
+    def _open_sub(sub: str):
+        return _hf_open(hf_path, split=split, data_dir=f"data/{sub}")
+
+    with ThreadPoolExecutor(max_workers=min(4, len(subsets))) as pool:
+        streams = [s for s in pool.map(_open_sub, subsets) if s is not None]
+
+    if streams:
+        from datasets import interleave_datasets
+        yield from interleave_datasets(streams, stopping_strategy="all_exhausted")
+
+
+def write_hf_source(
+    source_name: str,
+    budget: int,
+    writer: ShardWriter,
+    rng: random.Random,
+    min_tokens: int,
+    hf_path: str,
+    text_fn,
+    meta_fn,
+    hf_config: str | None = None,
+    split: str = "train",
+    subsets: list[str] | None = None,
+) -> int:
+    written = skipped = 0
+    bar = tqdm(total=budget, unit="tok", unit_scale=True,
+               desc=f"      {source_name:<12}", dynamic_ncols=True, smoothing=0.05)
+    try:
+        for row in _hf_iter(hf_path, split=split, hf_config=hf_config, subsets=subsets):
+            text = text_fn(row)
+            if not text:
+                skipped += 1
+                continue
+            toks = estimate_tokens(text)
+            if toks < min_tokens:
+                skipped += 1
+                continue
+            writer.write({
+                "text": text,
+                "source": source_name,
+                "meta": meta_fn(row),
+                "est_tokens": toks,
+            })
+            written += toks
+            bar.update(min(toks, budget - bar.n))
+            if written >= budget:
+                break
+    finally:
+        bar.close()
+    print(f"      done: {written:,} tokens written, {skipped:,} rows skipped")
+    return written
+
+
+# ── text / meta extractors ─────────────────────────────────────────────────────
+
+def _get(row: dict, *keys: str, default: str = "") -> str:
+    for k in keys:
+        v = row.get(k)
+        if v:
+            return str(v)
+    return default
+
+
+def pes2o_text(row):  return _get(row, "text", "content")
+def pes2o_meta(row):  return {"id": _get(row, "id", "doc_id"), "source": _get(row, "source", "venue")}
+
+def stack_text(row):  return _get(row, "content", "text", "code")
+def stack_meta(row):  return {
+    "lang":    _get(row, "lang", "language"),
+    "repo":    _get(row, "max_stars_repo_name", "repo_name"),
+    "license": _get(row, "license"),
+}
+
+def owm_text(row):    return _get(row, "text")
+def owm_meta(row):    return {"url": _get(row, "url")}
+
+
+# ── main ───────────────────────────────────────────────────────────────────────
+
+def main() -> None:
+    ap = argparse.ArgumentParser(
+        description=__doc__,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    ap.add_argument("--sltrans-root",   default=".",
+                    help="Root dir of downloaded SLTrans parquet files (default: .)")
+    ap.add_argument("--sltrans-tokens", type=float, default=700_000_000,
+                    help="Token cap for SLTrans   (default: 700M, 0=skip)")
+    ap.add_argument("--pes2o-tokens",   type=float, default=150_000_000,
+                    help="Token cap for peS2o     (default: 150M, 0=skip)")
+    ap.add_argument("--stack-tokens",   type=float, default=100_000_000,
+                    help="Token cap for TheStack  (default: 100M, 0=skip)")
+    ap.add_argument("--owm-tokens",     type=float, default=50_000_000,
+                    help="Token cap for OpenWebMath (default: 50M, 0=skip)")
+    ap.add_argument("--stack-langs",    default=",".join(THE_STACK_LANGS),
+                    help="Comma-separated TheStack language subsets")
+    ap.add_argument("--output-dir",     default="./mixed_pretrain",
+                    help="Output directory for JSONL shards (default: ./mixed_pretrain)")
+    ap.add_argument("--shard-size",     type=int, default=50_000,
+                    help="Records per JSONL shard (default: 50000)")
+    ap.add_argument("--min-tokens",     type=int, default=32,
+                    help="Drop records shorter than this (est. tokens, default: 32)")
+    ap.add_argument("--seed",           type=int, default=42)
+    args = ap.parse_args()
+
+    rng         = random.Random(args.seed)
+    out_dir     = Path(args.output_dir)
+    stack_langs = [s.strip() for s in args.stack_langs.split(",") if s.strip()]
+
+    budgets = {
+        "sltrans":     int(args.sltrans_tokens),
+        "pes2o":       int(args.pes2o_tokens),
+        "the_stack":   int(args.stack_tokens),
+        "openwebmath": int(args.owm_tokens),
+    }
+    active_sources = [name for name, tok in budgets.items() if tok > 0]
+    total_budget   = sum(budgets.values())
+
+    print("=" * 64)
+    print("Mixed pre-training dataset builder")
+    print(f"  Output : {out_dir.resolve()}")
+    print(f"  Seed   : {args.seed}")
+    print()
+    for name, toks in budgets.items():
+        if toks > 0:
+            print(f"  {name:<14}  {toks:>15,} tokens")
+        else:
+            print(f"  {name:<14}  (skipped)")
+    print(f"  {'TOTAL':<14}  {total_budget:>15,} tokens")
+    print("=" * 64)
+
+    summary: dict[str, int] = {}
+    n_active = len(active_sources)
+    step = 1
+
+    # ── SLTrans ────────────────────────────────────────────────────────────────
+    if budgets["sltrans"] > 0:
+        print(f"\n[{step}/{n_active}] SLTrans  (local parquet, balanced language x IR-type)")
+        step += 1
+        w = ShardWriter(out_dir, "sltrans", args.shard_size)
+        try:
+            summary["sltrans"] = write_sltrans(
+                Path(args.sltrans_root), budgets["sltrans"], w, rng, args.min_tokens,
+            )
+        finally:
+            w.close()
+
+    # ── peS2o ──────────────────────────────────────────────────────────────────
+    if budgets["pes2o"] > 0:
+        print(f"\n[{step}/{n_active}] peS2o  (allenai/peS2o, config=v2)")
+        step += 1
+        w = ShardWriter(out_dir, "pes2o", args.shard_size)
+        try:
+            summary["pes2o"] = write_hf_source(
+                "pes2o", budgets["pes2o"], w, rng, args.min_tokens,
+                hf_path="allenai/peS2o",
+                text_fn=pes2o_text, meta_fn=pes2o_meta,
+                hf_config="v2",
+            )
+        finally:
+            w.close()
+
+    # ── TheStack ───────────────────────────────────────────────────────────────
+    if budgets["the_stack"] > 0:
+        print(f"\n[{step}/{n_active}] TheStack  (bigcode/the-stack, {len(stack_langs)} language subsets)")
+        print(f"      langs: {', '.join(stack_langs)}")
+        step += 1
+        w = ShardWriter(out_dir, "the_stack", args.shard_size)
+        try:
+            summary["the_stack"] = write_hf_source(
+                "the_stack", budgets["the_stack"], w, rng, args.min_tokens,
+                hf_path="bigcode/the-stack",
+                text_fn=stack_text, meta_fn=stack_meta,
+                subsets=stack_langs,
+            )
+        finally:
+            w.close()
+
+    # ── OpenWebMath ────────────────────────────────────────────────────────────
+    if budgets["openwebmath"] > 0:
+        print(f"\n[{step}/{n_active}] OpenWebMath  (open-web-math/open-web-math)")
+        w = ShardWriter(out_dir, "openwebmath", args.shard_size)
+        try:
+            summary["openwebmath"] = write_hf_source(
+                "openwebmath", budgets["openwebmath"], w, rng, args.min_tokens,
+                hf_path="open-web-math/open-web-math",
+                text_fn=owm_text, meta_fn=owm_meta,
+            )
+        finally:
+            w.close()
+
+    # ── manifest ───────────────────────────────────────────────────────────────
+    manifest = {
+        "seed":                    args.seed,
+        "min_tokens_per_record":   args.min_tokens,
+        "sources": {
+            "sltrans":     {"root":     args.sltrans_root,                 "target_tokens": budgets["sltrans"]},
+            "pes2o":       {"hf_path":  "allenai/peS2o",                  "target_tokens": budgets["pes2o"]},
+            "the_stack":   {"hf_path":  "bigcode/the-stack",              "target_tokens": budgets["the_stack"],   "langs": stack_langs},
+            "openwebmath": {"hf_path":  "open-web-math/open-web-math",    "target_tokens": budgets["openwebmath"]},
+        },
+        "tokens_written": summary,
+    }
+    (out_dir / "manifest.json").write_text(json.dumps(manifest, indent=2))
+
+    # ── summary ────────────────────────────────────────────────────────────────
+    grand = sum(summary.values())
+    print("\n" + "=" * 62)
+    print(f"{'Source':<14}  {'Target':>15}  {'Written':>15}  {'Share':>6}")
+    print("-" * 58)
+    for name in ["sltrans", "pes2o", "the_stack", "openwebmath"]:
+        if budgets[name] == 0:
+            continue
+        written = summary.get(name, 0)
+        pct     = 100 * written / grand if grand else 0
+        print(f"{name:<14}  {budgets[name]:>15,}  {written:>15,}  {pct:>5.1f}%")
+    print("-" * 58)
+    print(f"{'TOTAL':<14}  {total_budget:>15,}  {grand:>15,}  100.0%")
+    print(f"\nOutput: {out_dir.resolve()}")
+
+
+if __name__ == "__main__":
+    main()

build_pretrain_dataset.py

@@ -0,0 +1,456 @@
+"""
+Build a mixed continued-pretraining dataset for a code LM.
+
+Sources (streamed from the Hub — no full download):
+  - UKPLab/SLTrans         (LLVM IR <-> source pairs; primary IRCoder signal)
+  - allenai/peS2o          (open scientific text)
+  - bigcode/the-stack      (permissively licensed source code)
+
+Mixing target (token-weighted): 70 / 15 / 15.
+
+Output: JSONL shards under OUT_DIR. Each line:
+    {"text": "...", "source": "sltrans" | "pes2o" | "the_stack", "meta": {...}}
+
+The token budget is approximate — we use a fast whitespace token estimate by default
+to avoid pulling a heavy tokenizer into the streaming loop. Swap in a real tokenizer
+(see TOKENIZER section) if you want exact counts against your model's vocab.
+
+Usage:
+    pip install "datasets>=2.18" huggingface_hub tqdm
+    huggingface-cli login        # SLTrans + the-stack are gated; you must accept their terms
+    python build_pretrain_dataset.py
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import random
+import sys
+import time
+from concurrent.futures import ThreadPoolExecutor
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Callable, Iterator
+
+import socket
+
+from datasets import interleave_datasets, load_dataset
+from tqdm import tqdm
+
+# Install hf-transfer and set this env var for significantly faster shard downloads.
+# pip install hf-transfer
+os.environ.setdefault("HF_HUB_ENABLE_HF_TRANSFER", "1")
+# Raise the per-shard download timeout (default 10s is too short for HF CDN under load).
+os.environ.setdefault("HF_HUB_DOWNLOAD_TIMEOUT", "120")
+
+# Apply a 90s socket-level timeout to every connection in this process.
+# This covers HF Hub file-listing API calls (which have no timeout by default)
+# and prevents indefinite hangs at 'resolving data files'.
+socket.setdefaulttimeout(90)
+
+# ============================================================================
+# CONFIG
+# ============================================================================
+
+@dataclass
+class SourceSpec:
+    name: str                       # short id used in output records
+    hf_path: str                    # HF dataset path
+    hf_config: str | None           # config name, if any
+    split: str                      # split to stream
+    target_fraction: float          # share of the total token budget
+    text_fn: Callable[[dict], str]  # extracts the training text from a row
+    meta_fn: Callable[[dict], dict] # extracts a small metadata dict
+    # the-stack is organized by language subset; SLTrans by source language.
+    # If `subsets` is set, we round-robin over them, each loaded as a separate stream.
+    subsets: list[str] | None = None
+
+
+# Total tokens in the final dataset (approximate).
+TOTAL_TOKEN_BUDGET = 1_500_000_000
+
+# Per-record length filters (in estimated tokens).
+MIN_TOKENS_PER_RECORD = 32
+MAX_TOKENS_PER_RECORD = 8192
+
+# Output.
+OUT_DIR = Path("./pretrain_mix")
+SHARD_RECORDS = 50_000               # records per .jsonl shard
+SEED = 17
+
+# Reservoir / sampling. We don't reservoir-sample (would require knowing N);
+# instead we accept records with probability `keep_prob` per source, tuned so
+# the stream yields roughly the target token count before exhaustion. Set to
+# 1.0 to take everything until budget is hit.
+KEEP_PROB = {
+    "sltrans":   1.0,
+    "pes2o":     1.0,
+    "the_stack": 0.5,   # the-stack is huge; subsample to diversify languages
+}
+
+# For the-stack, list languages you want represented. Keep this short for a
+# focused replication; expand for broader code coverage.
+THE_STACK_LANGS = [
+    "python", "c", "cpp", "rust", "go", "java", "javascript", "typescript",
+]
+
+# SLTrans subsets (source languages whose IR we want). None => use default split.
+SLTRANS_SUBSETS = [
+    f"{lang}/{split}"
+    for lang in ["C", "C++", "D", "Fortran", "Go", "Haskell", "Nim", "Objective-C", "Python", "Rust", "Swift"]
+    for split in ["Perf_Optimized", "Size_Optimized"]
+]
+
+# ============================================================================
+# TEXT / META EXTRACTORS
+# ============================================================================
+# These are intentionally defensive — different dataset versions name fields
+# differently. Adjust if a `KeyError` shows up in your run.
+
+def _first_present(row: dict, keys: list[str], default: str = "") -> str:
+    for k in keys:
+        if k in row and row[k]:
+            return row[k]
+    return default
+
+
+def sltrans_text(row: dict) -> str:
+    """SLTrans pairs source code with its LLVM IR. Concatenate with a marker so
+    the model learns to associate them — IRCoder-style."""
+    src = _first_present(row, ["source", "code", "src", "input"])
+    ir  = _first_present(row, ["ir", "llvm_ir", "llvm", "target", "output"])
+    if not src or not ir:
+        return ""
+    return f"<source>\n{src}\n</source>\n<llvm_ir>\n{ir}\n</llvm_ir>"
+
+
+def sltrans_meta(row: dict) -> dict:
+    return {
+        "lang": _first_present(row, ["language", "lang", "source_lang"]),
+    }
+
+
+def pes2o_text(row: dict) -> str:
+    return _first_present(row, ["text", "content"])
+
+
+def pes2o_meta(row: dict) -> dict:
+    return {
+        "id":     _first_present(row, ["id", "doc_id"]),
+        "source": _first_present(row, ["source", "venue"]),
+    }
+
+
+def the_stack_text(row: dict) -> str:
+    return _first_present(row, ["content", "text", "code"])
+
+
+def the_stack_meta(row: dict) -> dict:
+    return {
+        "lang":    _first_present(row, ["lang", "language"]),
+        "repo":    _first_present(row, ["max_stars_repo_name", "repo_name"]),
+        "license": _first_present(row, ["license"]),
+    }
+
+
+# ============================================================================
+# SOURCES
+# ============================================================================
+
+SOURCES: list[SourceSpec] = [
+    SourceSpec(
+        name="sltrans",
+        hf_path="UKPLab/SLTrans",
+        hf_config=None,
+        split="train",
+        target_fraction=0.70,
+        text_fn=sltrans_text,
+        meta_fn=sltrans_meta,
+        subsets=SLTRANS_SUBSETS,
+    ),
+    SourceSpec(
+        name="pes2o",
+        hf_path="allenai/peS2o",
+        hf_config="v2",
+        split="train",
+        target_fraction=0.15,
+        text_fn=pes2o_text,
+        meta_fn=pes2o_meta,
+    ),
+    SourceSpec(
+        name="the_stack",
+        hf_path="bigcode/the-stack",
+        hf_config=None,
+        # the-stack uses `data_dir` per language rather than HF configs.
+        split="train",
+        target_fraction=0.15,
+        text_fn=the_stack_text,
+        meta_fn=the_stack_meta,
+        subsets=THE_STACK_LANGS,
+    ),
+]
+
+
+# ============================================================================
+# TOKEN ESTIMATOR
+# ============================================================================
+# Whitespace-based estimate. For BPE tokenizers, real tokens ~= 1.3x words for
+# natural language and ~1.5–2x for code. We bake a 1.5x correction in here so
+# the budget is honest enough for planning. If you want exact counts:
+#
+#   from transformers import AutoTokenizer
+#   tok = AutoTokenizer.from_pretrained("Qwen/Qwen2.5-Coder-3B")
+#   def estimate_tokens(text: str) -> int:
+#       return len(tok.encode(text, add_special_tokens=False))
+
+def estimate_tokens(text: str) -> int:
+    return int(len(text.split()) * 1.5)
+
+
+# ============================================================================
+# STREAMING
+# ============================================================================
+
+def open_stream(spec: SourceSpec, subset: str | None):
+    """Return an IterableDataset for a (source, subset) pair, or None if unavailable."""
+    kwargs = {"split": spec.split, "streaming": True}
+    if spec.hf_config is not None:
+        kwargs["name"] = spec.hf_config
+
+    # the-stack uses data_dir to select a language.
+    if spec.hf_path == "bigcode/the-stack" and subset is not None:
+        kwargs["data_dir"] = f"data/{subset}"
+
+    # SLTrans subsets are encoded as "Lang/Split" (e.g. "Python/Perf_Optimized").
+    if spec.hf_path == "UKPLab/SLTrans" and subset is not None:
+        lang, slt_split = subset.rsplit("/", 1)
+        kwargs["name"] = lang
+        kwargs["split"] = slt_split
+
+    _TRANSIENT = ("ssl", "timeout", "handshake", "connection", "timed out")
+    for attempt in range(5):
+        try:
+            return load_dataset(spec.hf_path, **kwargs)
+        except ValueError as e:
+            if "Bad split" in str(e):
+                return None
+            raise
+        except Exception as e:
+            if attempt < 4 and any(k in str(e).lower() for k in _TRANSIENT):
+                time.sleep(2 ** attempt)  # 1s, 2s, 4s, 8s
+                continue
+            raise
+    return None
+
+
+def round_robin(spec: SourceSpec) -> Iterator[dict]:
+    """Yield rows from the source, interleaving across subsets if any.
+
+    Data-file resolution (the HF Hub HTTP round-trips that show as
+    'resolving data files') is parallelised across subsets so all
+    metadata fetches happen concurrently instead of one-by-one.
+    """
+    if not spec.subsets:
+        ds = open_stream(spec, None)
+        if ds is not None:
+            yield from ds
+        return
+
+    # Resolve all subset streams in parallel — resolution is I/O-bound so
+    # threads eliminate most of the serial 'resolving data files' wait.
+    with ThreadPoolExecutor(max_workers=min(4, len(spec.subsets))) as pool:
+        results = list(pool.map(open_stream, [spec] * len(spec.subsets), spec.subsets))
+
+    datasets = [ds for ds in results if ds is not None]
+    if not datasets:
+        return
+
+    yield from interleave_datasets(datasets, stopping_strategy="all_exhausted")
+
+
+# ============================================================================
+# WRITER
+# ============================================================================
+
+class ShardWriter:
+    def __init__(self, out_dir: Path, prefix: str, records_per_shard: int):
+        self.out_dir = out_dir
+        self.prefix = prefix
+        self.records_per_shard = records_per_shard
+        self.out_dir.mkdir(parents=True, exist_ok=True)
+        self._shard_idx = 0
+        self._records_in_shard = 0
+        self._fh = None
+        self._open_new_shard()
+
+    def _open_new_shard(self) -> None:
+        if self._fh is not None:
+            self._fh.close()
+        path = self.out_dir / f"{self.prefix}-{self._shard_idx:05d}.jsonl"
+        self._fh = path.open("w", encoding="utf-8")
+        self._records_in_shard = 0
+        self._shard_idx += 1
+
+    def write(self, record: dict) -> None:
+        self._fh.write(json.dumps(record, ensure_ascii=False) + "\n")
+        self._records_in_shard += 1
+        if self._records_in_shard >= self.records_per_shard:
+            self._open_new_shard()
+
+    def close(self) -> None:
+        if self._fh is not None:
+            self._fh.close()
+            self._fh = None
+
+
+# ============================================================================
+# MAIN
+# ============================================================================
+
+def sample_source(spec: SourceSpec, target_tokens: int, writer: ShardWriter,
+                  rng: random.Random) -> int:
+    """Stream `spec` until ~target_tokens have been written. Returns tokens written."""
+    keep_prob = KEEP_PROB.get(spec.name, 1.0)
+    tokens_written = 0
+    records_written = 0
+    rows_seen = 0
+    rows_skipped_filter = 0
+    rows_skipped_subsample = 0
+    rows_skipped_empty = 0
+    started = time.time()
+
+    # tqdm bar measured in tokens — the unit that actually matters for the budget.
+    # `unit_scale=True` formats large counts as 1.23M / 1.23B automatically.
+    bar = tqdm(
+        total=target_tokens,
+        unit="tok",
+        unit_scale=True,
+        desc=f"{spec.name:>10}",
+        dynamic_ncols=True,
+        smoothing=0.05,
+    )
+
+    def _refresh_postfix() -> None:
+        elapsed = max(time.time() - started, 1e-6)
+        bar.set_postfix({
+            "records": f"{records_written:,}",
+            "rows":    f"{rows_seen:,}",
+            "tok/s":   f"{tokens_written/elapsed:,.0f}",
+            "skip":    f"{rows_skipped_filter+rows_skipped_subsample+rows_skipped_empty:,}",
+        }, refresh=False)
+
+    try:
+        for row in round_robin(spec):
+            rows_seen += 1
+
+            if keep_prob < 1.0 and rng.random() > keep_prob:
+                rows_skipped_subsample += 1
+                continue
+
+            try:
+                text = spec.text_fn(row)
+            except Exception as e:
+                if rows_seen <= 3:
+                    bar.write(f"[{spec.name}] text_fn error on row {rows_seen}: {e!r}")
+                rows_skipped_empty += 1
+                continue
+
+            if not text:
+                rows_skipped_empty += 1
+                continue
+
+            n_tok = estimate_tokens(text)
+            if n_tok < MIN_TOKENS_PER_RECORD or n_tok > MAX_TOKENS_PER_RECORD:
+                rows_skipped_filter += 1
+                continue
+
+            record = {
+                "text":   text,
+                "source": spec.name,
+                "meta":   spec.meta_fn(row),
+                "est_tokens": n_tok,
+            }
+            writer.write(record)
+            tokens_written += n_tok
+            records_written += 1
+
+            # Don't overshoot the bar (tqdm clamps, but `min` keeps the math clean).
+            bar.update(min(n_tok, target_tokens - bar.n))
+
+            # Refresh the postfix every ~1k records — cheaper than every step.
+            if records_written % 1_000 == 0:
+                _refresh_postfix()
+
+            if tokens_written >= target_tokens:
+                break
+
+        _refresh_postfix()
+    finally:
+        bar.close()
+
+    elapsed = time.time() - started
+    print(f"[{spec.name}] DONE: {records_written:,} records, "
+          f"{tokens_written:,} tokens, {rows_seen:,} rows seen, "
+          f"skipped(filter={rows_skipped_filter:,} subsample={rows_skipped_subsample:,} "
+          f"empty={rows_skipped_empty:,}), {elapsed:.0f}s")
+    return tokens_written
+
+
+def main() -> None:
+    rng = random.Random(SEED)
+    OUT_DIR.mkdir(parents=True, exist_ok=True)
+
+    # Sanity-check fractions sum to ~1.
+    total_frac = sum(s.target_fraction for s in SOURCES)
+    if abs(total_frac - 1.0) > 1e-3:
+        print(f"WARN: source fractions sum to {total_frac}, not 1.0", file=sys.stderr)
+
+    # Banner — reassures the user something is happening before HF streams open.
+    print("=" * 64)
+    print(f"Building mixed pretrain corpus  →  {OUT_DIR.resolve()}")
+    print(f"Total token budget: {TOTAL_TOKEN_BUDGET:,}")
+    print(f"Per-record range: {MIN_TOKENS_PER_RECORD}–{MAX_TOKENS_PER_RECORD} tokens")
+    for s in SOURCES:
+        target = int(TOTAL_TOKEN_BUDGET * s.target_fraction)
+        kp = KEEP_PROB.get(s.name, 1.0)
+        subs = f", subsets={s.subsets}" if s.subsets else ""
+        print(f"  - {s.name:>10}: {s.target_fraction:>5.0%} → {target:>15,} tok  "
+              f"[keep_prob={kp}{subs}]")
+    print("=" * 64)
+
+    summary = {}
+    for spec in SOURCES:
+        target = int(TOTAL_TOKEN_BUDGET * spec.target_fraction)
+        writer = ShardWriter(OUT_DIR, prefix=spec.name,
+                             records_per_shard=SHARD_RECORDS)
+        try:
+            written = sample_source(spec, target, writer, rng)
+        finally:
+            writer.close()
+        summary[spec.name] = {"target": target, "written": written}
+
+    # Manifest.
+    manifest = {
+        "total_token_budget": TOTAL_TOKEN_BUDGET,
+        "seed": SEED,
+        "sources": [
+            {"name": s.name, "hf_path": s.hf_path,
+             "fraction": s.target_fraction, "subsets": s.subsets}
+            for s in SOURCES
+        ],
+        "tokens_written": summary,
+    }
+    (OUT_DIR / "manifest.json").write_text(json.dumps(manifest, indent=2))
+
+    print("\n=== SUMMARY ===")
+    grand_total = sum(v["written"] for v in summary.values())
+    for name, v in summary.items():
+        pct = 100 * v["written"] / grand_total if grand_total else 0
+        print(f"  {name:>10}: {v['written']:>15,} tokens ({pct:5.1f}%)")
+    print(f"  {'TOTAL':>10}: {grand_total:>15,} tokens")
+    print(f"\nOutput: {OUT_DIR.resolve()}")
+
+
+if __name__ == "__main__":
+    main()

sltrans_subset_1500M.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d896c84650b6dd23943264c919d898f215eb147c264df4c9ad2d1e28f715817d
+size 2230258908

sltrans_subset_500M.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dfac595fae04a9f8faf34f66d4ac1c555203259aab3e2717a7d3e5f49f47c368
+size 737917857

sltrans_subset_700M.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b44b696df0b58b07f6b88192da9aa022d16edaf21aefa45eaaabddb88e269a77
+size 1021734608