Blame for code/build.py

"""Build one size of the dataset: python build.py 10M [source ...]

Per source: stream -> clean -> filter -> dedup until the word quota is met.
Output: work/<size>/<source>.jsonl, then assemble.py slices train/valid.
"""
import hashlib
import itertools
import json
import os
import re
import sys
import time
import unicodedata
from collections import Counter
from pathlib import Path

ROOT = Path(__file__).resolve().parent.parent
# HF_TOKEN lives in ../.env (never printed); must be set before importing datasets
_env = ROOT / ".env"
if _env.exists():
    for _l in _env.read_text(encoding="utf-8").splitlines():
        if "=" in _l and not _l.lstrip().startswith("#"):
            _k, _v = _l.split("=", 1)
            os.environ.setdefault(_k.strip(), _v.strip().strip("'\""))

import fasttext
import ftfy
from datasketch import MinHash, MinHashLSH
from wordfreq import top_n_list

import mix
import sources

QUOTES = str.maketrans({"‘": "'", "’": "'", "“": '"', "”": '"',
                        "–": "-", "—": " - ", "…": "...", " ": " "})
RE_URL = re.compile(r"https?://\S+|www\.\S+")
RE_EMAIL = re.compile(r"\S+@\S+\.\S+")
RE_PHONE = re.compile(r"\+?\d[\d\s().-]{8,}\d")
RE_HTML = re.compile(r"<[^>]{1,100}>")
RE_CODE = re.compile(r"```.*?```", re.S)
RE_HEAD = re.compile(r"^#{1,6}\s*", re.M)
RE_LATEX = re.compile(r"\$\$.*?\$\$|\\\(.*?\\\)|\\\[.*?\\\]", re.S)
LLM_TICS = re.compile(r"\bas an ai\b|\bdelve\b|\btapestry\b|\bcertainly!|\bin conclusion,|"
                      r"\bit'?s important to note\b|\bbustling\b|\bas a language model\b", re.I)
# deliberately small: only terms that are unambiguous in any context
BAD = re.compile(r"\b(fuck\w*|shit\w*|bitch\w*|cunt|porn\w*|nigg\w+|rape[sd]?|raping|"
                 r"cock|dick|pussy|slut|whore|orgasm\w*|erotic\w*|blowjob|masturbat\w*)\b", re.I)
# characters allowed in a document: ASCII, Latin-1 and Latin Extended-A/B, curly quotes, dashes,
# ellipsis, and a few math signs common in textbooks. Anything else (emoji, CJK, Greek, Cyrillic,
# Arabic, private-use) rejects the whole document, so rare scripts never reach the tokenizer
RE_CHARSET = re.compile(r"[^\x00-\x7f\u00a0-\u024f\u2013\u2014\u2018-\u201d\u2026"
                        r"\u00b1\u00d7\u00f7\u2212\u221a\u221e\u2248\u2260\u2264\u2265]")
STOP = {"the", "and", "to", "of", "a", "in", "that", "is", "it", "for"}
END_OK = ('.', '!', '?', '"', "'", ")")

lid = fasttext.load_model(str(ROOT / "work" / "lid.176.ftz"))


def normalize(t):
    t = ftfy.fix_text(t).translate(QUOTES)
    t = unicodedata.normalize("NFKC", t)
    for rx in (RE_CODE, RE_LATEX, RE_URL, RE_EMAIL, RE_HTML):
        t = rx.sub(" ", t)
    t = RE_PHONE.sub(" ", t)
    t = RE_HEAD.sub("", t)
    t = re.sub(r"[ \t]+", " ", t)
    t = re.sub(r" ?\n ?", "\n", t)
    t = re.sub(r"\n{3,}", "\n\n", t)
    return t.strip()


def syllables(w):
    n = len(re.findall(r"[aeiouy]+", w))
    if w.endswith("e") and n > 1 and not w.endswith("le"):
        n -= 1
    return max(n, 1)


def fk_grade(text):
    words = re.findall(r"[A-Za-z']+", text)
    sents = max(len(re.findall(r"[.!?]+(?:\s|$)", text)), 1)
    if not words:
        return 99
    syl = sum(syllables(w.lower()) for w in words)
    return 0.39 * len(words) / sents + 11.8 * syl / len(words) - 15.59


def vocab_coverage(text, vocab):
    # capitalised words (names, sentence starts) never match, so they are ignored
    toks = re.findall(r"\b[a-z']+\b", text)
    return sum(t in vocab for t in toks) / len(toks) if toks else 0


def gopher_ok(text):
    words = text.split()
    if not words:
        return False
    if not 3 <= sum(map(len, words)) / len(words) <= 10:
        return False
    if sum(not c.isalnum() and not c.isspace() and c not in ".,;:!?'\"()-" for c in text) / len(text) > 0.1:
        return False
    if sum(c.isdigit() for c in text) / len(text) > 0.1:
        return False
    lines = [l for l in text.split("\n") if l.strip()]
    if len(lines) > 3 and 1 - len(set(lines)) / len(lines) > 0.3:
        return False
    if sum(w.lower().strip(".,!?\"'") in STOP for w in words) < 2:
        return False
    bi = Counter(zip(words, words[1:]))
    return not bi or bi.most_common(1)[0][1] / max(len(words) - 1, 1) <= 0.2


def is_english(text):
    # lid.f.predict avoids fasttext's numpy-1 only wrapper; returns [(prob, label)]
    pred = lid.f.predict(text[:1000].replace("\n", " ") + "\n", 1, 0.0, "strict")
    return bool(pred) and pred[0][1] == "__label__en" and pred[0][0] >= 0.9


def split_long(text, title, doc_max):
    """Split at paragraph borders; the title is repeated so each chunk stays self-contained."""
    paras, chunks, cur, n = text.split("\n"), [], [], 0
    for p in paras:
        w = len(p.split())
        if cur and n + w > doc_max:
            chunks.append("\n".join(cur))
            cur, n = [], 0
        cur.append(p)
        n += w
    if cur:
        chunks.append("\n".join(cur))
    return [(f"{title}\n{c}" if title else c) for c in chunks if len(c.split()) >= mix.DOC_MIN]


class Dedup:
    def __init__(self):
        self.exact, self.lsh, self.n = set(), MinHashLSH(threshold=0.8, num_perm=64), 0

    def seen(self, text):
        h = hashlib.md5(re.sub(r"\W+", "", text.lower()).encode()).hexdigest()
        if h in self.exact:
            return True
        self.exact.add(h)
        w = text.lower().split()
        mh = MinHash(num_perm=64)
        mh.update_batch([" ".join(w[i:i + 5]).encode() for i in range(max(len(w) - 4, 1))])
        if self.lsh.query(mh):
            return True
        self.lsh.insert(str(self.n), mh)
        self.n += 1
        return False


def trim_tail(text):
    """Drop trailing headings and list stubs ("Other websites", "References") so a complete
    article is not rejected as truncated; real truncation leaves a long unfinished last line."""
    lines = text.split("\n")
    while len(lines) > 1 and (not lines[-1].strip() or
                              (len(lines[-1].split()) < 12 and not lines[-1].rstrip().endswith(END_OK))):
        lines.pop()
    return "\n".join(lines).strip()


def process(doc, genre, tier, vocab, src_name, cov):
    """Return (clean documents, None) or ([], rejection reason)."""
    if "turns" in doc:
        turns = [(s.strip(), normalize(t)) for s, t in doc["turns"]]
        turns = [(s, t.replace("\n", " ")) for s, t in turns if t]
        # assistant chats (User/Assistant) include 2-turn tasks (summarise, rewrite) and long answers,
        # so they get a lower turn minimum and a looser per-turn cap than named dialogues
        chat = all(s in ("User", "Assistant") for s, _ in turns)
        if len(turns) < (2 if chat else 4) or any(len(s) > 20 for s, _ in turns):
            return [], "dialogue_shape"
        if sum(len(t.split()) for _, t in turns) / len(turns) > tier["turn"] * (mix.CHAT_TURN_MULT if chat else 1):
            return [], "turn_length"
        text = "\n".join(f"{s}: {t}" for s, t in turns)
        title = None
    else:
        text, title = normalize(doc["text"]), doc.get("title")
        if "�" in text:
            return [], "mojibake"
        if genre != "poetry":
            text = trim_tail(text)
    nw = len(text.split())
    if RE_CHARSET.search(text):
        return [], "charset"
    if genre == "poetry":
        if nw < 20:
            return [], "short"
        return ([text], None) if is_english(text) else ([], "lang")
    if nw < mix.DOC_MIN:
        return [], "short"
    if len(LLM_TICS.findall(text)) > 2:
        return [], "llm_tics"
    if BAD.search(text):
        return [], "explicit"
    if src_name not in mix.LID_SKIP and not is_english(text):
        return [], "lang"
    if not text.rstrip().endswith(END_OK):
        return [], "truncated"
    if not gopher_ok(text):
        return [], "gopher"
    if genre != "dialogue":
        cap = tier["fk_exp"] if genre == "expository" else tier["fk"]
        if fk_grade(text) > cap and src_name not in ("simplewiki",):
            return [], "fk"
    if vocab_coverage(text, vocab) < cov:
        return [], "vocab"
    docs = split_long(text, title, tier["doc_max"]) if nw > tier["doc_max"] else [f"{title}\n{text}" if title else text]
    return docs, (None if docs else "short")


def doc_words(doc):
    return len(doc["text"].split()) if "text" in doc else sum(len(t.split()) for _, t in doc["turns"])


def at_step(tier, step):
    """Tier and vocabulary-coverage threshold at a relaxation-ladder step."""
    dfk, dcov = mix.LADDER[step]
    return dict(tier, fk=tier["fk"] + dfk, fk_exp=tier["fk_exp"] + dfk), mix.VOCAB_COVERAGE + dcov


def probe(name, size, genre, tier, vocab, quota):
    """Mechanism 1: sample the first docs and pick the first ladder step whose projected
    scan fits comfortably in the budget (yield >= 2/MAX_SCAN). Returns (step, report)."""
    docs = list(itertools.islice(sources.REGISTRY[name](size), mix.PROBE_DOCS))
    scanned = sum(doc_words(d) for d in docs) or 1
    report = []
    for step in range(len(mix.LADDER)):
        t, cov = at_step(tier, step)
        rej, kept = Counter(), 0
        for d in docs:
            out, why = process(d, genre, t, vocab, name, cov)
            kept += sum(len(x.split()) for x in out)
            if why:
                rej[why] += 1
        yield_ = kept / scanned
        report.append(dict(step=step, yield_pct=round(100 * yield_, 1), top_rejections=rej.most_common(3)))
        if yield_ >= 2 / mix.MAX_SCAN:
            return step, report
    return len(mix.LADDER) - 1, report


def build_source(name, size, dedup, quota=None, tag=""):
    """Fill one source's quota. `tag=".topup"` writes an extra file for fallback top-ups."""
    genre, quotas = mix.MIX[name]
    if quota is None:
        quota = quotas[mix.SIZES[size]] * 1_000_000
    if quota <= 0:
        return None
    out = ROOT / "work" / size / f"{name}{tag}.jsonl"
    done = out.with_suffix(".done")
    if done.exists():
        stats = json.loads(done.read_text())
        if abs(stats["target_M"] - quota / 1e6) < 1e-6:
            for l in out.open(encoding="utf-8"):  # reload so global dedup stays consistent
                dedup.seen(json.loads(l)["text"])
            return stats
    base = mix.TIERS[size]
    vocab = set(top_n_list("en", base["vocab"]))
    t0 = time.time()
    step, probe_report = probe(name, size, genre, base, vocab, quota)
    print(f"  probe {name}{tag}: start at ladder step {step}; {probe_report[-1]}", flush=True)
    tier, cov = at_step(base, step)
    got = scanned = kept = seen_docs = 0
    openers, rej = Counter(), Counter()
    win_scanned = win_kept = win_docs = 0
    relaxed, abort = [dict(step=step, at_words=0)], None
    with out.open("w", encoding="utf-8") as f:
        for doc in sources.REGISTRY[name](size):
            seen_docs += 1
            win_docs += 1
            w = doc_words(doc)
            scanned += w
            win_scanned += w
            if scanned > quota * mix.MAX_SCAN:
                abort = "scan_cap"
                break
            docs, why = process(doc, genre, tier, vocab, name, cov)
            if why:
                rej[why] += 1
            for text in docs:
                # anti-template: no 4-word opening may exceed 0.5% of the accepted docs
                op = " ".join(text.lower().split()[:4])
                if genre != "poetry" and openers[op] >= max(5, 0.005 * kept):
                    rej["opener_cap"] += 1
                    continue
                if dedup.seen(text):
                    rej["duplicate"] += 1
                    continue
                openers[op] += 1
                kept += 1
                n = len(text.split())
                got += n
                win_kept += n
                f.write(json.dumps({"text": text, "genre": genre, "src": name}) + "\n")
            if got >= quota:
                break
            if seen_docs % 2000 == 0:
                print(f"  {name}{tag}: {seen_docs} docs, kept {kept}, {got/1e6:.2f}M/{quota/1e6:.2f}M words, "
                      f"{time.time()-t0:.0f}s, top rejections {rej.most_common(3)}", flush=True)
            if win_docs >= mix.WINDOW:
                # mechanisms 2+4: if the recent yield cannot finish within the scan budget,
                # climb one ladder step; at the top of the ladder give up on this source
                recent = win_kept / win_scanned if win_scanned else 0
                need = (quota - got) / recent if recent else float("inf")
                if need > quota * mix.MAX_SCAN - scanned:
                    if step + 1 < len(mix.LADDER):
                        step += 1
                        tier, cov = at_step(base, step)
                        relaxed.append(dict(step=step, at_words=got))
                        print(f"  {name}{tag}: yield {100*recent:.1f}% too low, relaxing to step {step}", flush=True)
                    else:
                        abort = "projected_shortfall"
                        break
                win_scanned = win_kept = win_docs = 0
    stats = dict(source=name + tag, genre=genre, target_M=quota / 1e6, words_M=round(got / 1e6, 3),
                 docs=kept, scanned_docs=seen_docs, scanned_words_M=round(scanned / 1e6, 1),
                 seconds=round(time.time() - t0), stopped="quota" if got >= quota else (abort or "source_exhausted"),
                 relaxation=relaxed, probe=probe_report, rejections=dict(rej.most_common()))
    done.write_text(json.dumps(stats))
    return stats


def plan_fallbacks(size, results):
    """Mechanism 3: spread each source's shortfall over same-genre substitutes, capped."""
    idx = mix.SIZES[size]
    quota = {n: q[idx] * 1e6 for n, (_, q) in mix.MIX.items()}
    target = sum(quota.values())
    got = {r["source"]: r["words_M"] * 1e6 for r in results if "words_M" in r}
    extra, plan, log = Counter(), Counter(), []
    for src, q in quota.items():
        gap = q - got.get(src, 0) if q > 0 else 0
        if gap < 0.01 * q:
            continue
        for sub in mix.FALLBACKS.get(src, []):
            if gap <= 0:
                break
            room = max(mix.EXTRA_FRAC * quota[sub], mix.EXTRA_FLOOR * target) - extra[sub]
            room = min(room, mix.SHARE_CAP * target - got.get(sub, 0) - extra[sub])
            amt = min(gap, room)
            if amt < 0.005 * target:
                continue
            extra[sub] += amt
            plan[sub] += amt
            gap -= amt
            log.append(dict(missing_from=src, filled_by=sub, words_M=round(amt / 1e6, 3)))
        if gap > 0:
            log.append(dict(missing_from=src, unfilled_M=round(gap / 1e6, 3)))
    return plan, log


def main():
    size = sys.argv[1]
    only = sys.argv[2:]
    (ROOT / "work" / size).mkdir(parents=True, exist_ok=True)
    dedup, results = Dedup(), []

    def run(name, **kw):
        print(f"== {name}{kw.get('tag', '')}", flush=True)
        try:
            r = build_source(name, size, dedup, **kw)
        except Exception as e:  # keep going; a failed source is reported, not hidden
            print(f"  FAILED {name}: {e!r}", flush=True)
            r = dict(source=name + kw.get("tag", ""), error=repr(e))
        if r:
            print("  ", {k: v for k, v in r.items() if k not in ("probe", "relaxation")}, flush=True)
            results.append(r)

    for name in mix.MIX:
        if not only or name in only:
            run(name)
    fallback_log = []
    if not only:
        plan, fallback_log = plan_fallbacks(size, [r for r in results if "tag" not in r])
        print("== fallback plan", fallback_log, flush=True)
        for sub, words in plan.items():
            run(sub, quota=words, tag=".topup")
    total = sum(r.get("words_M", 0) for r in results)
    print(f"== total {total:.2f}M words", flush=True)
    (ROOT / "work" / size / "stats.json").write_text(
        json.dumps(dict(total_M=round(total, 3), fallbacks=fallback_log, sources=results), indent=1))


if __name__ == "__main__":
    main()