| """Corpus construction for the bilingual English/Russian pretraining set.
|
|
|
| This module implements the pipeline described in ``docs/data_plan.md``:
|
|
|
| fetch -> normalise -> quality filter -> deduplicate -> mix -> split
|
|
|
| It deliberately has no third-party dependencies beyond the standard library so
|
| that the corpus can be rebuilt on a bare machine. The three things it is
|
| careful about are:
|
|
|
| * **licences** -- every shard is recorded with ``source``, ``licence``,
|
| ``url`` and ``sha256``; a shard without a known licence is rejected by
|
| :func:`record_shard`;
|
| * **language** -- a fast heuristic (script shares) instead of a model, so the
|
| filter is explainable and reproducible;
|
| * **boilerplate** -- MediaWiki pages are cleaned of templates, references,
|
| tables and image links before they are counted as text.
|
|
|
| The module is used by ``scripts/build_bilingual.py``.
|
| """
|
| from __future__ import annotations
|
|
|
| import gzip
|
| import hashlib
|
| import json
|
| import re
|
| import unicodedata
|
| import zlib
|
| from dataclasses import dataclass, field, asdict
|
| from pathlib import Path
|
| from typing import Iterable, Iterator, Optional, Sequence
|
|
|
|
|
|
|
|
|
|
|
|
|
| BOILERPLATE_SECTIONS = {
|
|
|
| "примечания", "литература", "ссылки", "источники", "см. также",
|
| "библиография", "комментарии", "сноски", "внешние ссылки",
|
|
|
| "references", "external links", "see also", "further reading",
|
| "notes", "bibliography", "citations", "sources", "footnotes",
|
| }
|
|
|
| _RE_COMMENT = re.compile(r"<!--.*?-->", re.S)
|
| _RE_REF = re.compile(r"<ref[^>]*?/>|<ref[^>]*?>.*?</ref>", re.S | re.I)
|
| _RE_TAG = re.compile(r"</?[a-zA-Z][^>]{0,200}>")
|
| _RE_TABLE = re.compile(r"\{\|.*?\|\}", re.S)
|
| _RE_MATH = re.compile(r"<math>(.*?)</math>", re.S | re.I)
|
| _RE_HEADING = re.compile(r"^(={2,6})\s*(.+?)\s*\1\s*$", re.M)
|
| _RE_FILE = re.compile(
|
| r"\[\[(?:Файл|File|Изображение|Image|Медиа|Media):[^\[\]]*?(?:\[\[[^\]]*\]\][^\[\]]*?)*\]\]",
|
| re.I)
|
| _RE_CATEGORY = re.compile(
|
| r"\[\[(?:Категория|Category):[^\[\]]*\]\]", re.I)
|
| _RE_INTERWIKI = re.compile(r"\[\[[a-z]{2,3}:[^\[\]]*\]\]")
|
| _RE_LINK = re.compile(r"\[\[([^\[\]|]+)(?:\|([^\[\]]*))?\]\]")
|
| _RE_EXTLINK = re.compile(r"\[(?:https?|ftp)://[^\s\]]+\s*([^\]]*)\]")
|
| _RE_BOLD = re.compile(r"'{2,5}")
|
| _RE_LIST = re.compile(r"^[ \t]*[*#:;]+[ \t]*", re.M)
|
| _RE_WS = re.compile(r"[ \t]+")
|
| _RE_BLANKLINES = re.compile(r"\n{3,}")
|
|
|
|
|
| def _strip_templates(text: str) -> str:
|
| """Remove ``{{...}}`` blocks, handling nesting.
|
|
|
| MediaWiki templates are balanced but not regular, so this walks the string
|
| once with a depth counter instead of using a regex.
|
| """
|
| out: list[str] = []
|
| depth = 0
|
| i = 0
|
| n = len(text)
|
| while i < n:
|
| if text.startswith("{{", i):
|
| depth += 1
|
| i += 2
|
| continue
|
| if text.startswith("}}", i) and depth:
|
| depth -= 1
|
| i += 2
|
| continue
|
| if depth == 0:
|
| out.append(text[i])
|
| i += 1
|
| return "".join(out)
|
|
|
|
|
| def _drop_sections(text: str) -> str:
|
| """Drop whole sections whose heading is boilerplate (references, links)."""
|
| lines = text.split("\n")
|
| kept: list[str] = []
|
| skip_level: Optional[int] = None
|
| for line in lines:
|
| m = _RE_HEADING.match(line)
|
| if m:
|
| level = len(m.group(1))
|
| title = m.group(2).strip().lower().rstrip(":")
|
| if skip_level is not None and level <= skip_level:
|
| skip_level = None
|
| if skip_level is None and title in BOILERPLATE_SECTIONS:
|
| skip_level = level
|
| continue
|
| if skip_level is None:
|
| kept.append(line)
|
| return "\n".join(kept)
|
|
|
|
|
| def clean_wikitext(text: str) -> str:
|
| """Convert MediaWiki wikitext to plain prose.
|
|
|
| The cleaner is intentionally conservative: it removes markup that never
|
| contains prose (templates, references, tables, files, categories) and
|
| unwraps markup that wraps prose (links, bold, headings). It does not try
|
| to be a full parser; residual markup is filtered later by the symbol-ratio
|
| check.
|
|
|
| Args:
|
| text: raw wikitext of one article.
|
|
|
| Returns:
|
| Plain text with paragraphs separated by a single blank line.
|
| """
|
| text = _RE_COMMENT.sub(" ", text)
|
| text = _RE_REF.sub(" ", text)
|
| text = _RE_TABLE.sub(" ", text)
|
| text = _strip_templates(text)
|
| text = _RE_MATH.sub(lambda m: " " + m.group(1).strip() + " ", text)
|
| text = _drop_sections(text)
|
| text = _RE_FILE.sub(" ", text)
|
| text = _RE_CATEGORY.sub(" ", text)
|
| text = _RE_INTERWIKI.sub(" ", text)
|
|
|
| text = _RE_HEADING.sub(lambda m: "\n\n" + m.group(2).strip() + "\n\n", text)
|
| text = _RE_LINK.sub(lambda m: (m.group(2) or m.group(1)).strip(), text)
|
| text = _RE_EXTLINK.sub(lambda m: (m.group(1) or "").strip(), text)
|
| text = _RE_BOLD.sub("", text)
|
| text = _RE_LIST.sub("", text)
|
| text = _RE_TAG.sub(" ", text)
|
| text = text.replace(" ", " ").replace("&", "&")
|
| text = text.replace("<", "<").replace(">", ">").replace(""", '"')
|
| return normalize(text)
|
|
|
|
|
| def normalize(text: str, keep_indent: bool = False) -> str:
|
| """Unicode-normalise and clean whitespace.
|
|
|
| Args:
|
| text: input text.
|
| keep_indent: keep leading indentation and blank lines (used for code,
|
| where indentation carries meaning).
|
|
|
| Returns:
|
| Normalised text, paragraphs separated by ``\\n\\n``.
|
| """
|
| text = unicodedata.normalize("NFKC", text)
|
| text = text.replace("\r\n", "\n").replace("\r", "\n")
|
| text = text.replace("\u00ad", "")
|
| text = text.replace("\ufeff", "")
|
| for space in ("\u00a0", "\u2009", "\u202f", "\u2007"):
|
| text = text.replace(space, " ")
|
| if keep_indent:
|
| lines = [ln.rstrip() for ln in text.split("\n")]
|
| out: list[str] = []
|
| for ln in lines:
|
| out.append(ln)
|
| return _RE_BLANKLINES.sub("\n\n\n", "\n".join(out)).strip("\n")
|
| lines = []
|
| for ln in text.split("\n"):
|
| ln = _RE_WS.sub(" ", ln).strip()
|
| lines.append(ln)
|
| text = "\n".join(lines)
|
| text = _RE_BLANKLINES.sub("\n\n", text)
|
| return text.strip()
|
|
|
|
|
|
|
|
|
|
|
|
|
| _CYRILLIC = re.compile(r"[\u0400-\u04FF]")
|
| _LATIN = re.compile(r"[A-Za-z]")
|
| _LETTER = re.compile(r"[^\W\d_]", re.UNICODE)
|
| _DIGIT = re.compile(r"\d")
|
| _SYMBOL = re.compile(r"[^\w\s]", re.UNICODE)
|
|
|
|
|
| @dataclass
|
| class QualityStats:
|
| """Measured properties of one document."""
|
|
|
| chars: int
|
| words: int
|
| letters: int
|
| digits: int
|
| symbols: int
|
| cyrillic: int
|
| latin: int
|
| repeat_ratio: float
|
| compression: float
|
| ok: bool
|
| reasons: list[str] = field(default_factory=list)
|
|
|
|
|
| def _repeat_ratio(words: Sequence[str], n: int = 5) -> float:
|
| """Fraction of ``n``-grams that occur more than once."""
|
| if len(words) < n:
|
| return 0.0
|
| grams = [tuple(words[i:i + n]) for i in range(len(words) - n + 1)]
|
| if not grams:
|
| return 0.0
|
| unique = len(set(grams))
|
| return 1.0 - unique / len(grams)
|
|
|
|
|
| def quality(text: str, language: Optional[str] = None,
|
| min_chars: int = 400, max_symbol_ratio: float = 0.20,
|
| max_digit_ratio: float = 0.12,
|
| max_repeat_ratio: float = 0.30,
|
| min_compression: float = 0.22,
|
| max_compression: float = 0.80) -> QualityStats:
|
| """Score a document and decide whether it may enter the corpus.
|
|
|
| The thresholds are calibrated on the pilot, not on theory: they remove
|
| lists, tables, navigation residue and machine-generated text while keeping
|
| dense prose and formulas.
|
|
|
| Args:
|
| text: normalised document.
|
| language: ``"en"`` or ``"ru"``; ``None`` skips the script check.
|
| min_chars: minimum document length in characters.
|
| max_symbol_ratio: maximum share of non-alphanumeric characters.
|
| max_digit_ratio: maximum share of digits (filters data dumps).
|
| max_repeat_ratio: maximum share of repeated 5-grams.
|
| min_compression: minimum zlib ratio (too uniform text is suspicious).
|
| max_compression: maximum zlib ratio (too random text is suspicious).
|
|
|
| Returns:
|
| A :class:`QualityStats` with ``ok`` set to the verdict.
|
| """
|
| n = len(text)
|
| letters = len(_LETTER.findall(text))
|
| digits = len(_DIGIT.findall(text))
|
| symbols = len(_SYMBOL.findall(text))
|
| cyr = len(_CYRILLIC.findall(text))
|
| lat = len(_LATIN.findall(text))
|
| words = text.split()
|
| comp = len(zlib.compress(text.encode("utf-8"), 6)) / max(1, len(text.encode("utf-8")))
|
| rep = _repeat_ratio(words)
|
|
|
| reasons: list[str] = []
|
| if n < min_chars:
|
| reasons.append("short")
|
| if n and symbols / n > max_symbol_ratio:
|
| reasons.append("symbols")
|
| if n and digits / n > max_digit_ratio:
|
| reasons.append("digits")
|
| if rep > max_repeat_ratio:
|
| reasons.append("repetition")
|
| if not (min_compression <= comp <= max_compression):
|
| reasons.append("compression")
|
| if language == "ru" and (cyr + lat) and cyr / (cyr + lat) < 0.60:
|
| reasons.append("not_ru")
|
| if language == "en" and (cyr + lat) and lat / (cyr + lat) < 0.80:
|
| reasons.append("not_en")
|
|
|
| return QualityStats(chars=n, words=len(words), letters=letters,
|
| digits=digits, symbols=symbols, cyrillic=cyr,
|
| latin=lat, repeat_ratio=round(rep, 4),
|
| compression=round(comp, 4), ok=not reasons,
|
| reasons=reasons)
|
|
|
|
|
|
|
|
|
|
|
|
|
| def _shingles(text: str, k: int = 5) -> set[int]:
|
| """Hashed word shingles of a document."""
|
| words = text.lower().split()
|
| if len(words) < k:
|
| return {hash(tuple(words))}
|
| return {hash(tuple(words[i:i + k])) for i in range(len(words) - k + 1)}
|
|
|
|
|
| def minhash(text: str, permutations: int = 64, k: int = 5,
|
| seed: int = 13) -> tuple[int, ...]:
|
| """MinHash signature used for near-duplicate detection."""
|
| import random
|
|
|
| rng = random.Random(seed)
|
| a = [rng.randrange(1, 2**61 - 1) for _ in range(permutations)]
|
| b = [rng.randrange(0, 2**61 - 1) for _ in range(permutations)]
|
| sig = []
|
| sh = _shingles(text, k)
|
| for i in range(permutations):
|
| sig.append(min(((a[i] * s + b[i]) % (2**61 - 1)) for s in sh))
|
| return tuple(sig)
|
|
|
|
|
| def _bands(sig: Sequence[int], bands: int) -> Iterator[tuple]:
|
| step = max(1, len(sig) // bands)
|
| for i in range(0, len(sig), step):
|
| yield (i, tuple(sig[i:i + step]))
|
|
|
|
|
| def dedup(docs: Iterable[dict], threshold: float = 0.8,
|
| text_key: str = "text") -> tuple[list[dict], int]:
|
| """Remove exact and near duplicates.
|
|
|
| Exact duplicates are dropped by SHA-256 of the normalised text, near
|
| duplicates by MinHash banding with a Jaccard cutoff. The first document
|
| wins, so callers should feed sources in priority order.
|
|
|
| Args:
|
| docs: documents with at least ``text`` (and ``sha256`` optionally).
|
| threshold: Jaccard similarity above which two documents are duplicates.
|
| text_key: key holding the text.
|
|
|
| Returns:
|
| ``(kept, dropped)``.
|
| """
|
| seen_exact: set[str] = set()
|
| buckets: dict[tuple, list[tuple[int, ...]]] = {}
|
| kept: list[dict] = []
|
| dropped = 0
|
| for doc in docs:
|
| text = doc[text_key]
|
| h = doc.get("sha256") or hashlib.sha256(text.encode("utf-8")).hexdigest()
|
| if h in seen_exact:
|
| dropped += 1
|
| continue
|
| sig = minhash(text)
|
| is_dup = False
|
| for band in _bands(sig, 16):
|
| bucket = buckets.setdefault(band, [])
|
| for other in bucket:
|
| same = sum(1 for x, y in zip(sig, other) if x == y)
|
| if same / len(sig) >= threshold:
|
| is_dup = True
|
| break
|
| if is_dup:
|
| break
|
| if is_dup:
|
| dropped += 1
|
| continue
|
| for band in _bands(sig, 16):
|
| buckets.setdefault(band, []).append(sig)
|
| seen_exact.add(h)
|
| doc["sha256"] = h
|
| kept.append(doc)
|
| return kept, dropped
|
|
|
|
|
|
|
|
|
|
|
|
|
| REQUIRED_FIELDS = ("source", "licence", "url", "language", "domain",
|
| "sha256", "bytes")
|
|
|
|
|
| @dataclass
|
| class Shard:
|
| """One corpus shard and its provenance."""
|
|
|
| source: str
|
| licence: str
|
| url: str
|
| language: str
|
| domain: str
|
| sha256: str
|
| bytes: int
|
| docs: int = 0
|
| path: str = ""
|
| note: str = ""
|
|
|
| def as_dict(self) -> dict:
|
| return asdict(self)
|
|
|
|
|
| def sha256_file(path: Path) -> str:
|
| """SHA-256 of a file, streamed."""
|
| h = hashlib.sha256()
|
| with open(path, "rb") as f:
|
| for chunk in iter(lambda: f.read(1 << 20), b""):
|
| h.update(chunk)
|
| return h.hexdigest()
|
|
|
|
|
| def record_shard(path: Path, manifest: Path, source: str, licence: str,
|
| url: str, language: str, domain: str, docs: int = 0,
|
| note: str = "") -> Shard:
|
| """Append one shard to the JSONL manifest.
|
|
|
| Args:
|
| path: shard file on disk.
|
| manifest: JSONL manifest path.
|
| source: human-readable source name.
|
| licence: licence identifier; must be known.
|
| url: canonical source URL.
|
| language: ``en`` or ``ru``.
|
| domain: ``math``, ``science``, ``logic``, ``literature``, ``code``
|
| or ``encyclopedic``.
|
| docs: number of documents in the shard.
|
| note: free-form remark.
|
|
|
| Raises:
|
| ValueError: if the licence is unknown or a required field is empty.
|
| """
|
| if licence.strip().lower() in {"", "unknown", "n/a", "none"}:
|
| raise ValueError(f"shard {path} has no known licence")
|
| if language not in {"en", "ru"}:
|
| raise ValueError(f"unexpected language {language!r}")
|
| if domain not in {"math", "science", "logic", "literature", "code",
|
| "encyclopedic", "ml", "cs", "humour", "identity"}:
|
| raise ValueError(f"unexpected domain {domain!r}")
|
| shard = Shard(source=source, licence=licence, url=url, language=language,
|
| domain=domain, sha256=sha256_file(path),
|
| bytes=path.stat().st_size, docs=docs, path=str(path),
|
| note=note)
|
| manifest.parent.mkdir(parents=True, exist_ok=True)
|
| with open(manifest, "a", encoding="utf-8") as f:
|
| f.write(json.dumps(shard.as_dict(), ensure_ascii=False) + "\n")
|
| return shard
|
|
|
|
|
|
|
|
|
|
|
|
|
| DOMAIN_QUOTAS = {
|
| "math": 0.25,
|
| "science": 0.14,
|
| "code": 0.15,
|
| "logic": 0.10,
|
| "literature": 0.11,
|
| "encyclopedic": 0.09,
|
|
|
|
|
|
|
| "cs": 0.03,
|
| "ml": 0.12,
|
|
|
| "humour": 0.01,
|
|
|
|
|
|
|
| "identity": 0.01,
|
| }
|
|
|
|
|
| def mix_corpus(shards: Sequence[Shard], total_bytes: int,
|
| language_ratio: float = 0.40,
|
| quotas: Optional[dict[str, float]] = None,
|
| ) -> dict[str, list[tuple[Shard, int]]]:
|
| """Allocate a byte budget per language and domain.
|
|
|
| English receives ``1 - language_ratio`` of the total and Russian
|
| ``language_ratio``. Inside a language the domain quotas are applied to
|
| whatever is available; a starved domain is simply under-filled, which the
|
| caller can detect by comparing the allocation with the quota.
|
|
|
| Args:
|
| shards: available shards.
|
| total_bytes: budget for the whole corpus, both languages.
|
| language_ratio: share of Russian bytes (0.40 in the plan).
|
| quotas: domain shares; defaults to :data:`DOMAIN_QUOTAS`.
|
|
|
| Returns:
|
| Mapping ``language -> [(shard, allocated_bytes), ...]``.
|
| """
|
| quotas = quotas or DOMAIN_QUOTAS
|
| plan: dict[str, list[tuple[Shard, int]]] = {"en": [], "ru": []}
|
| for lang, share in (("en", 1.0 - language_ratio), ("ru", language_ratio)):
|
| lang_budget = int(total_bytes * share)
|
| by_domain: dict[str, list[Shard]] = {}
|
| for s in shards:
|
| if s.language == lang:
|
| by_domain.setdefault(s.domain, []).append(s)
|
| for domain, quota in quotas.items():
|
| want = int(lang_budget * quota)
|
| pool = by_domain.get(domain, [])
|
| have = sum(s.bytes for s in pool)
|
| take = min(want, have)
|
| if take <= 0:
|
| continue
|
| for s in pool:
|
| alloc = int(round(take * s.bytes / have))
|
| if alloc:
|
| plan[lang].append((s, min(alloc, s.bytes)))
|
| return plan
|
|
|
|
|
| def write_heldout(docs: Iterable[dict], out_dir: Path, per_language_bytes: int,
|
| language: str) -> Path:
|
| """Write a deterministic held-out slice (first documents, fixed order)."""
|
| out_dir.mkdir(parents=True, exist_ok=True)
|
| path = out_dir / f"heldout_{language}.txt"
|
| written = 0
|
| with open(path, "w", encoding="utf-8") as f:
|
| for doc in docs:
|
| if written >= per_language_bytes:
|
| break
|
| text = doc["text"]
|
| f.write(text + "\n\n")
|
| written += len(text.encode("utf-8"))
|
| return path
|
|
|
|
|
| def quota_mix(docs: Sequence[dict], budget_per_language: int,
|
| quotas: Optional[dict[str, float]] = None,
|
| heldout_bytes: int = 0,
|
| budgets: Optional[dict[str, int]] = None) -> dict:
|
| """Split a held-out slice and apply the domain quotas.
|
|
|
| Fetching is deliberately generous and uneven; this is where the plan is
|
| enforced. Both the held-out reservation and the quota selection walk
|
| documents in SHA-256 order, so the same input always yields the same
|
| corpus.
|
|
|
| Args:
|
| docs: deduplicated documents with ``language``, ``domain``, ``sha256``
|
| and ``text``.
|
| budget_per_language: maximum training bytes per language.
|
| quotas: domain shares inside a language; defaults to
|
| :data:`DOMAIN_QUOTAS`.
|
| heldout_bytes: total held-out budget, split evenly across
|
| ``2 * len(quotas)`` buckets.
|
| budgets: per-language override of ``budget_per_language``; used to
|
| enforce the 60/40 byte ratio when the fetched volumes differ.
|
|
|
| Returns:
|
| ``{"train": {lang: {domain: [docs]}}, "heldout": {lang: [docs]},
|
| "shortfalls": [str], "bytes": {lang: {domain: int}}}``.
|
| """
|
| quotas = quotas or DOMAIN_QUOTAS
|
| ordered = sorted(docs, key=lambda d: d.get("sha256") or "")
|
| buckets: dict[tuple, list[dict]] = {}
|
| for doc in ordered:
|
| buckets.setdefault((doc["language"], doc["domain"]), []).append(doc)
|
|
|
| per_bucket = int(heldout_bytes / max(1, 2 * len(quotas)))
|
| heldout: dict[str, list[dict]] = {"en": [], "ru": []}
|
| pool: dict[tuple, list[dict]] = {}
|
| for key, items in buckets.items():
|
| bucket_bytes = sum(len(d["text"].encode("utf-8")) for d in items)
|
|
|
|
|
|
|
| budget = per_bucket if bucket_bytes >= 5_000_000 else 0
|
| taken = 0
|
| n = 0
|
| while n < len(items) and taken < budget:
|
| taken += len(items[n]["text"].encode("utf-8"))
|
| n += 1
|
| heldout.setdefault(key[0], []).extend(items[:n])
|
| pool[key] = items[n:]
|
|
|
| train: dict[str, dict[str, list[dict]]] = {"en": {}, "ru": {}}
|
| sizes: dict[str, dict[str, int]] = {"en": {}, "ru": {}}
|
| shortfalls: list[str] = []
|
| for lang in ("en", "ru"):
|
| available = sum(len(d["text"].encode("utf-8"))
|
| for key, items in pool.items() if key[0] == lang
|
| for d in items)
|
| lang_budget = int((budgets or {}).get(lang, budget_per_language))
|
| budget = min(available, lang_budget)
|
| for domain, quota in quotas.items():
|
| want = int(budget * quota)
|
| items = pool.get((lang, domain), [])
|
| chosen: list[dict] = []
|
| taken = 0
|
| for doc in items:
|
| if taken >= want:
|
| break
|
| chosen.append(doc)
|
| taken += len(doc["text"].encode("utf-8"))
|
| if not chosen:
|
| shortfalls.append(f"{lang}/{domain}: empty")
|
| continue
|
| if taken < want * 0.8:
|
| shortfalls.append(f"{lang}/{domain}: "
|
| f"{taken/1e6:.1f} MB of {want/1e6:.1f} MB")
|
| train[lang][domain] = chosen
|
| sizes[lang][domain] = taken
|
| return {"train": train, "heldout": heldout, "shortfalls": shortfalls,
|
| "bytes": sizes}
|
|
|
|
|
| def iter_jsonl(path: Path) -> Iterator[dict]:
|
| """Stream documents from a JSONL file."""
|
| with open(path, encoding="utf-8") as f:
|
| for line in f:
|
| line = line.strip()
|
| if line:
|
| yield json.loads(line)
|
|
|
|
|
| def append_jsonl(path: Path, docs: Iterable[dict]) -> int:
|
| """Append documents to a JSONL file and return how many were written."""
|
| path.parent.mkdir(parents=True, exist_ok=True)
|
| n = 0
|
| with open(path, "a", encoding="utf-8") as f:
|
| for doc in docs:
|
| f.write(json.dumps(doc, ensure_ascii=False) + "\n")
|
| n += 1
|
| return n
|
|
|
|
|
| def corpus_report(shards: Sequence[Shard], out_path: Path) -> dict:
|
| """Summarise a manifest into a JSON report (bytes, docs, licences)."""
|
| report: dict = {"total_bytes": 0, "total_docs": 0, "by_language": {},
|
| "by_domain": {}, "by_licence": {}, "shards": len(shards)}
|
| for s in shards:
|
| report["total_bytes"] += s.bytes
|
| report["total_docs"] += s.docs
|
| lang = report["by_language"].setdefault(
|
| s.language, {"bytes": 0, "docs": 0, "domains": {}})
|
| lang["bytes"] += s.bytes
|
| lang["docs"] += s.docs
|
| lang["domains"][s.domain] = lang["domains"].get(s.domain, 0) + s.bytes
|
| dom = report["by_domain"].setdefault(s.domain, {"bytes": 0, "docs": 0})
|
| dom["bytes"] += s.bytes
|
| dom["docs"] += s.docs
|
| report["by_licence"][s.licence] = (
|
| report["by_licence"].get(s.licence, 0) + s.bytes)
|
| total = max(1, report["total_bytes"])
|
| report["language_share"] = {
|
| k: round(v["bytes"] / total, 4)
|
| for k, v in report["by_language"].items()}
|
| report["domain_share"] = {
|
| k: round(v["bytes"] / total, 4)
|
| for k, v in report["by_domain"].items()}
|
| out_path.parent.mkdir(parents=True, exist_ok=True)
|
| out_path.write_text(json.dumps(report, indent=2, ensure_ascii=False),
|
| encoding="utf-8")
|
| return report
|
|
|
|
|
| def read_manifest(path: Path) -> list[Shard]:
|
| """Load a JSONL manifest into :class:`Shard` objects."""
|
| out = []
|
| if not path.exists():
|
| return out
|
| for line in path.read_text(encoding="utf-8").splitlines():
|
| line = line.strip()
|
| if line:
|
| out.append(Shard(**json.loads(line)))
|
| return out
|
|
|
|
|
| def pack_shard(docs: Iterable[dict], path: Path, compress: bool = True) -> int:
|
| """Write documents to one shard file, optionally gzip-compressed.
|
|
|
| Shards are newline-delimited JSON so that they can be streamed without
|
| loading the whole corpus into memory.
|
|
|
| Returns:
|
| Number of documents written.
|
| """
|
| path.parent.mkdir(parents=True, exist_ok=True)
|
| opener = gzip.open if compress else open
|
| n = 0
|
| with opener(path, "wt", encoding="utf-8") as f:
|
| for doc in docs:
|
| f.write(json.dumps(doc, ensure_ascii=False) + "\n")
|
| n += 1
|
| return n
|
|
|
