| |
| """Build Polish DynaWord parquet shards from SpeakLeash .jsonl.zst sources. |
| |
| Parallel pipeline (uses all cores). Per source (paper 2508.02271, minimal gates): |
| stream jsonl.zst -> [workers: parse + Polish-lang check + drop-short + |
| OCR alpha-ratio + tiktoken token_count + sha1] -> [main: cross-source exact |
| dedup + id + parquet write]. |
| |
| Sources processed in priority order so earlier sources win duplicates |
| (wikipedia > wikisource > ...). Heavy quality filtering + mix-weighting are |
| downstream (CPT), not here. token_count is a fast tiktoken proxy (~1% off |
| Llama-3); canonical Llama-3 recount happens at release. |
| |
| Usage: |
| python3 src/build_dynaword.py --all --speakleash-dir ~/speakleash --out ~/dynaword |
| python3 src/build_dynaword.py --sources gutenberg --jobs 16 |
| """ |
| from __future__ import annotations |
| import argparse, hashlib, json, os, re, subprocess, sys, time |
| from itertools import islice |
| import multiprocessing as mp |
| from pathlib import Path |
| import pyarrow as pa |
| import pyarrow.parquet as pq |
|
|
| sys.path.insert(0, str(Path(__file__).resolve().parent)) |
| from sources import SOURCES, ADDED |
|
|
| POLISH_RE = re.compile(r"[ąćęłńóśźżĄĆĘŁŃÓŚŹŻ]") |
| ALPHA_RE = re.compile(r"[^\W\d_]", re.UNICODE) |
| MIN_CHARS = 200 |
| MIN_POLISH_RATIO = 0.005 |
| MIN_ALPHA_RATIO = 0.70 |
|
|
| SCHEMA = pa.schema([ |
| ("id", pa.string()), ("text", pa.string()), ("source", pa.string()), |
| ("added", pa.string()), ("created", pa.string()), ("token_count", pa.int64()), |
| ("license", pa.string()), ("author", pa.string()), |
| ]) |
|
|
| _ENC = None |
|
|
|
|
| def _init_worker(): |
| global _ENC |
| import tiktoken |
| _ENC = tiktoken.get_encoding("cl100k_base") |
|
|
|
|
| def _polish_ratio(text): |
| letters = ALPHA_RE.findall(text) |
| return len(POLISH_RE.findall(text)) / len(letters) if letters else 0.0 |
|
|
|
|
| def _first_text(value) -> str: |
| if value is None: |
| return "" |
| if isinstance(value, list): |
| return "; ".join(str(item).strip() for item in value if str(item).strip()) |
| return str(value).strip() |
|
|
|
|
| def _meta_value(row: dict, keys: tuple[str, ...], default: str = "") -> str: |
| for key in keys: |
| value = _first_text(row.get(key)) |
| if value: |
| return value |
| return default |
|
|
|
|
| def _process_chunk(args): |
| """Worker: gate + tokenize a batch of raw lines. Returns (records, stats).""" |
| is_ocr, created, default_license, lines = args |
| kept, texts = [], [] |
| st = [0, 0, 0, 0] |
| metas = [] |
| for line in lines: |
| st[0] += 1 |
| try: |
| row = json.loads(line) |
| text = (row.get("text") or "").strip() |
| except Exception: |
| continue |
| if len(text) < MIN_CHARS: |
| st[1] += 1; continue |
| if _polish_ratio(text) < MIN_POLISH_RATIO: |
| st[2] += 1; continue |
| if is_ocr: |
| ar = len(ALPHA_RE.findall(text)) / len(text) if text else 0.0 |
| if ar < MIN_ALPHA_RATIO: |
| st[3] += 1; continue |
| texts.append(text) |
| metas.append(( |
| _meta_value(row, ("license", "licence", "rights", "edm:rights"), default_license), |
| _meta_value(row, ("author", "authors", "creator", "creators")), |
| )) |
| toks = [len(t) for t in _ENC.encode_ordinary_batch(texts, num_threads=1)] if texts else [] |
| for t, (license_value, author), tk in zip(texts, metas, toks): |
| kept.append((t, created, tk, license_value, author, hashlib.sha1(t.encode("utf-8")).digest())) |
| return kept, st |
|
|
|
|
| def _chunks(iterable, n): |
| it = iter(iterable) |
| while batch := list(islice(it, n)): |
| yield batch |
|
|
|
|
| def build_source(name, cfg, sl_dir, out_root, pool, seen, counter): |
| src_path = sl_dir / f"{cfg.get('file_key', cfg.get('speakleash_key'))}.jsonl.zst" |
| if not src_path.exists(): |
| print(f" ! missing {src_path}"); return None |
| out_dir = out_root / "data" / name |
| out_dir.mkdir(parents=True, exist_ok=True) |
| writer = pq.ParquetWriter(out_dir / f"{name}.parquet", SCHEMA, compression="zstd") |
| st = {"read": 0, "kept": 0, "drop_short": 0, "drop_lang": 0, |
| "drop_dup": 0, "drop_ocr": 0, "chars": 0, "tokens": 0, |
| "licenses": {}, "authors_with_value": 0} |
| t0 = time.time() |
| is_ocr, created = bool(cfg.get("is_ocr")), cfg.get("created", "") |
| default_license = cfg.get("license", "") |
| bid, btext, bcre, btok, blic, baut = [], [], [], [], [], [] |
|
|
| def flush(): |
| if not btext: |
| return |
| n = len(btext) |
| writer.write(pa.record_batch([ |
| pa.array(bid), pa.array(btext), pa.array([name] * n), |
| pa.array([ADDED] * n), pa.array(bcre), pa.array(btok, pa.int64()), |
| pa.array(blic), pa.array(baut), |
| ], schema=SCHEMA)) |
| bid.clear(); btext.clear(); bcre.clear(); btok.clear(); blic.clear(); baut.clear() |
|
|
| proc = subprocess.Popen(["zstd", "-dc", str(src_path)], |
| stdout=subprocess.PIPE, bufsize=1 << 22) |
| line_iter = (ln for ln in proc.stdout if ln.strip()) |
| arg_iter = ((is_ocr, created, default_license, ch) for ch in _chunks(line_iter, 2000)) |
| for kept, cst in pool.imap_unordered(_process_chunk, arg_iter, chunksize=1): |
| st["read"] += cst[0]; st["drop_short"] += cst[1] |
| st["drop_lang"] += cst[2]; st["drop_ocr"] += cst[3] |
| for text, cre, tok, license_value, author, h in kept: |
| if h in seen: |
| st["drop_dup"] += 1; continue |
| seen.add(h) |
| bid.append(f"{name}_{counter[0]}"); counter[0] += 1 |
| btext.append(text); bcre.append(cre); btok.append(tok) |
| blic.append(license_value); baut.append(author) |
| st["chars"] += len(text); st["tokens"] += tok; st["kept"] += 1 |
| st["licenses"][license_value] = st["licenses"].get(license_value, 0) + 1 |
| if author: |
| st["authors_with_value"] += 1 |
| if len(btext) >= 2000: |
| flush() |
| flush(); writer.close(); proc.stdout.close(); proc.wait() |
| st["secs"] = round(time.time() - t0, 1) |
| print(f" {name}: read {st['read']:,} kept {st['kept']:,} | -short {st['drop_short']:,} " |
| f"-lang {st['drop_lang']:,} -dup {st['drop_dup']:,} -ocr {st['drop_ocr']:,} | " |
| f"{st['chars']/1e6:.0f}M chars, {st['tokens']/1e6:.1f}M tok | {st['secs']}s", flush=True) |
| (out_dir / f"{name}.stats.json").write_text(json.dumps({**st, "license": cfg["license"]}, indent=2)) |
| return st |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--sources", nargs="*", default=None) |
| ap.add_argument("--all", action="store_true") |
| ap.add_argument("--speakleash-dir", default="~/speakleash") |
| ap.add_argument("--out", default=".") |
| ap.add_argument("--jobs", type=int, default=os.cpu_count()) |
| args = ap.parse_args() |
|
|
| names = list(SOURCES) if args.all else (args.sources or []) |
| if not names: |
| print("specify --sources <names> or --all"); return |
| sl_dir = Path(args.speakleash_dir).expanduser().resolve() |
| out_root = Path(args.out).expanduser().resolve() |
| print(f"jobs={args.jobs} | speakleash={sl_dir} | out={out_root} | sources={names}", flush=True) |
|
|
| seen, counter, totals = set(), [0], [] |
| t0 = time.time() |
| with mp.Pool(args.jobs, initializer=_init_worker) as pool: |
| for name in names: |
| if name not in SOURCES: |
| print(f" ? unknown {name}"); continue |
| print(f"[{name}]", flush=True) |
| st = build_source(name, SOURCES[name], sl_dir, out_root, pool, seen, counter) |
| if st: |
| totals.append((name, st)) |
| tt = sum(s["tokens"] for _, s in totals) |
| td = sum(s["kept"] for _, s in totals) |
| print(f"\nTOTAL: {td:,} docs, {tt/1e9:.2f}B tok (tiktoken proxy), " |
| f"{len(seen):,} unique | wall {round(time.time()-t0,1)}s", flush=True) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
