add csv data for topic modeling

.gitattributes

@@ -60,3 +60,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
 *.jsonl filter=lfs diff=lfs merge=lfs -text
 *.jsonl.gz filter=lfs diff=lfs merge=lfs -text
+*.csv filter=lfs diff=lfs merge=lfs -text

README.md

@@ -40,15 +40,17 @@ status categories are retained separately and do not exclude an article that has
 an active status. These are community editorial designations at this snapshot,
 not independent factual checks or current assessments.
 
-All selected articles are retained. There is no thematic filtering, sampling,
-NLP processing, subject-label assignment or research train/test split. There are
-no exact duplicate `wikitext` or `raw_text` values in this snapshot; the selection
+All selected articles are retained. Source selection applies no thematic filtering,
+sampling, subject-label assignment or research train/test split. The original JSON
+records are preserved; the optional preparation workflow below produces separate
+NLP CSV files. There are no exact duplicate `wikitext` or `raw_text` values in this snapshot; the selection
 procedure does not remove records because they share text. The `corpus`
 partition is a storage partition, not a research split.
 
 ## Loading
 
-Both configurations use compressed JSON Lines and require no dataset script.
+The `articles` configuration is the default. `articles` and `categories` use
+compressed JSON Lines and the `corpus` split, with no dataset script.
 With Hugging Face Datasets:
 
 ```python
@@ -75,6 +77,37 @@ categories = load_dataset(
 )
 ```
 
+The prepared NLP files `data/noow.csv` and `data/bow.csv` contain the same
+17,413 article IDs, in source order, with string columns `id`, `raw_text`,
+`vw_text`. Use the CSV reader for these files, separately from the repository's
+JSON Lines configurations:
+
+```python
+noow = load_dataset(
+    "csv",
+    data_files={"corpus": "hf://datasets/TopicNet/RuWiki-Good-2026-V2/data/noow.csv"},
+    split="corpus",
+)
+bow = load_dataset(
+    "csv",
+    data_files={"corpus": "hf://datasets/TopicNet/RuWiki-Good-2026-V2/data/bow.csv"},
+    split="corpus",
+)
+```
+
+From the parent of a downloaded repository:
+
+```python
+noow = load_dataset(
+    "csv", data_files={"corpus": "RuWiki-Good-2026-V2/data/noow.csv"}, split="corpus"
+)
+bow = load_dataset(
+    "csv", data_files={"corpus": "RuWiki-Good-2026-V2/data/bow.csv"}, split="corpus"
+)
+```
+
+The NLP preparation section describes the normalized namespaces and text fields.
+
 ## Article fields
 
 | Field | JSON type | Meaning |
@@ -187,6 +220,106 @@ fragments of markup or awkward text may remain. `wikitext` is retained so reader
 can inspect these losses or apply a different extraction procedure. Neither
 `raw_text` nor the category metadata is a manually corrected annotation.
 
+## NLP preparation
+
+The standalone [preparation code](preprocessing/prepare.py) builds `noow.csv` and
+`bow.csv` from the pinned article snapshots without modifying their JSON files.
+Full uses all 17,413 articles. Each CSV has exactly three columns:
+`id`, `raw_text`, `vw_text`. IDs and article order are preserved. CSV `raw_text`
+is the title, two LF characters and the original readable body with only its
+leading CR/LF characters removed. In the original JSON, `raw_text` remains the
+readable body alone. Standard CSV quoting preserves embedded newlines.
+
+`vw_text` uses Vowpal Wabbit namespaces in this order:
+
+| Namespace | Contents |
+| --- | --- |
+| `@title` | Normalized title tokens. |
+| `@word` | Normalized body tokens only; the title is not prepended. |
+| `@bigram` | Accepted adjacent body bigrams. |
+| `@trigram` | Accepted adjacent body trigrams. |
+| `@category` | All direct Wikipedia categories, including service and maintenance categories. |
+
+NOOW preserves the normalized token sequence within each namespace, not the raw
+prose. BOW counts exactly those NOOW tokens independently in each namespace.
+It does not trim the token sequence or remove articles. There are no research
+splits, deduplication, model training or chain extraction in this workflow.
+
+Normalization uses `spacy.blank("ru")`, pymorphy3 normal forms and the union of
+spaCy Russian and NLTK Russian stopwords. Punctuation and whitespace tokens are
+removed; HTML tags, URLs and email addresses become `<TAG>`, `<URL>` and `<MAIL>`.
+Cyrillic stress marks are removed; lexical Cyrillic compounds with ASCII hyphen,
+U+2010 or U+2011 are normalized to ASCII hyphens and kept as single tokens.
+Person names are not masked.
+
+Bigrams and trigrams are selected independently using NLTK PMI after a corpus
+frequency threshold of 5, with `nbest(32100)[100:]` for each order. Selection uses
+all normalized article bodies in the chosen collection; it is **corpus-global**,
+not fitted only on a later training split. Full and Selected therefore have
+separately selected n-gram vocabularies. These CSVs are not a claim of evaluation
+without information from held-out documents. For text-only experiments, use only
+`@word`; title, category and subject metadata may reveal evaluation targets.
+
+Run from the downloaded `preprocessing` directory. Python 3.11.15 is the pinned
+runtime. On Linux x86-64, the supplied locks reproduce the preparation environment:
+
+```bash
+conda create --name ruwiki-nlp --file conda-linux-64.lock.txt
+conda activate ruwiki-nlp
+python -m pip install -r pip-linux-x86_64.lock.txt
+python prepare.py --help
+python prepare.py --action download --dataset both --sources-dir ./sources
+python prepare.py --action build --dataset both --sources-dir ./sources --output-dir ./output --scratch-dir ./scratch
+python prepare.py --action verify --dataset both --sources-dir ./sources --output-dir ./output
+```
+
+`requirements.txt` lists the direct NLP dependencies. The locks include the
+complete previously used environment; no downloaded spaCy language model is
+needed. The [pinned preparation contract](preprocessing/wikipedia-quality-nlp-20261001.json)
+records source revisions, SHA-256 hashes and runtime requirements. Download
+reuses existing source files after checking their pinned hashes, downloads any
+missing source files, then acquires the pinned NLTK stopwords archive at
+`sources/nltk_data/corpora/stopwords.zip`. To reuse local snapshots, first place
+them at `sources/full/articles.jsonl.gz`, `sources/selected/articles.jsonl.gz` and
+`sources/selected/topics.jsonl.gz`, then run the same download command. This
+creates the NLTK resource directory; an existing environment's `nltk_data`
+directory is not required.
+
+Hugging Face files are downloaded anonymously with Python `urllib`. Restricted
+repositories require access: download their pinned source files separately with
+authenticated tools, put them at the paths above, and rerun the download action.
+The preparation script does not handle authentication tokens.
+
+Both build and verify must use Python 3.11.15: VW escaping depends on the
+runtime Unicode database. Verify requires no NLP packages. Build runs offline
+and checks runtime versions and the Russian stopword content.
+Use `--nltk-data` to provide a different local NLTK resource directory.
+`--dataset full`, `selected` or `both` controls the collection. Source paths are
+`full/articles.jsonl.gz`, `selected/articles.jsonl.gz` and
+`selected/topics.jsonl.gz` beneath `--sources-dir`. Generated files are placed
+under `output/full` and `output/selected`, with a build manifest. Build prints
+phase and document-count progress. The manifest records counts and ordered IDs
+of articles with an empty `@word` namespace; these articles are retained. Verification
+checks pinned source identities, output hashes, schemas, source text and
+NOOW/BOW token-count agreement without NLP dependencies. It does not replay
+tokenization, lemmatization or PMI selection; a manifest self-hash alone does
+not establish independent authenticity.
+
+Load a generated CSV directly:
+
+```python
+noow = load_dataset(
+    "csv", data_files={"corpus": "output/full/noow.csv"}, split="corpus"
+)
+bow = load_dataset(
+    "csv", data_files={"corpus": "output/full/bow.csv"}, split="corpus"
+)
+```
+
+The code in `preprocessing/` is available under its [MIT license](preprocessing/LICENSE).
+The article text and its normalized derivatives retain the CC BY-SA 4.0 terms
+and attribution requirements described below.
+
 ## Attribution, license and use
 
 Article text and wikitext are attributed to **Russian Wikipedia contributors**
@@ -206,12 +339,15 @@ small, editorially selected portion of Russian Wikipedia, not a representative
 sample of Russian writing or an evenly balanced subject collection. Quality
 status does not guarantee accuracy, neutrality, completeness or suitability for
 any downstream application. Articles can contain sensitive, biased, outdated or
-offensive material. Any subject labels, deduplication policy, preprocessing and
-research splits needed for a downstream study must be specified separately.
+offensive material. Any further subject labels, deduplication policy,
+preprocessing and research splits needed for a downstream study must be specified
+separately.
 
 ## Published file identity
 
-| File | Compressed bytes | SHA-256 |
+| File | Bytes | SHA-256 |
 | --- | ---: | --- |
 | `data/articles.jsonl.gz` | 409,970,311 | `c51f9b6bee4c85f25ffb861060f52490a9276bae289d2aa2db7e0d10e2dda950` |
 | `data/categories.jsonl.gz` | 22,459,573 | `d07ab1e6c07da28cc162d786853a73c54e300289e21bcc6667c4072158abdf8f` |
+| `data/noow.csv` | 1,128,356,201 | `041250c048b0441cc88d516b92e1d65c0f80db3c82b400b7ae6b9db379c2ed33` |
+| `data/bow.csv` | 883,080,852 | `a45edd3e9287009e353c0f3ffc4404ffadc393293dada691e2d275a0bc0d2f5d` |

data/bow.csv

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

data/noow.csv

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

preprocessing/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 RuWiki-Good-2026 contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

preprocessing/_wikigood/__init__.py

@@ -0,0 +1 @@
+"""Standalone source snapshot for the Russian Wikipedia CSV preparation."""

preprocessing/_wikigood/wikigood_ru_content.py

@@ -0,0 +1,557 @@
+"""Bounded extraction of selected pages from a Wikimedia multistream dump."""
+
+from __future__ import annotations
+
+import bz2
+from contextlib import ExitStack
+from dataclasses import dataclass
+from datetime import datetime
+from hashlib import sha256
+import os
+from pathlib import Path
+import re
+from typing import BinaryIO, Iterable
+from xml.etree import ElementTree
+
+
+_DECIMAL = re.compile(r"[0-9]+\Z")
+_PAGE_START = re.compile(br"<page(?:\s[^>]*)?>")
+_PAGE_END = b"</page>"
+_READ_SIZE = 64 * 1024
+_HTML_SPAN = re.compile(r"<!--.*?-->|<![^<>]*>|</?[A-Za-z][^<>]*?>", re.DOTALL)
+_SPECIAL_TAG_OPEN = re.compile(
+    r"<(?:gallery|imagemap|mapframe)(?:\s|>)", re.IGNORECASE
+)
+_TAG_SENTINEL = "WIKIGOODRUTAGPLACEHOLDER"
+_MEDIA_NAMESPACES = frozenset(("file", "image", "файл", "изображение"))
+_MEDIA_LINK_OPEN = re.compile(
+    r"\[\[\s*(?:file|image|файл|изображение)\s*:", re.IGNORECASE
+)
+_FILE_DESCRIPTION_TEMPLATE_OPEN = re.compile(
+    r"\{\{\s*файл\s+с\s+описанием(?=\s*(?:\||\}\}))", re.IGNORECASE
+)
+_MALFORMED_IMAGE_PARAMETER_LINE = re.compile(
+    r"^[^\S\r\n]*\|[^\S\r\n]*(?:image|изображение)[^\S\r\n]*="
+    r"[^\r\n]*\.(?:jpe?g|png|gif|svg|webp|tiff?|ogg|ogv|webm)"
+    r"[^\S\r\n]*(?:\r?\n|$)",
+    re.IGNORECASE | re.MULTILINE,
+)
+_ORPHAN_MEDIA_FLAG = re.compile(
+    r"(?<!\S)(?:thumb|thumbnail|мини|миниатюра)[^\S\r\n]*\|"
+    r"[^\S\r\n]*",
+    re.IGNORECASE,
+)
+_MEDIA_FLAG_OPTIONS = frozenset(
+    (
+        "thumb", "thumbnail", "мини", "миниатюра",
+        "frame", "framed", "enframed", "обрамить",
+        "frameless", "безрамки", "border", "граница",
+        "left", "слева", "right", "справа", "center", "centre", "центр",
+        "none", "без", "baseline", "основание", "sub", "под", "super", "sup", "над",
+        "top", "сверху", "text-top", "текст-сверху", "middle", "посередине",
+        "bottom", "снизу", "text-bottom", "текст-снизу",
+        "upright", "сверхусправа",
+    )
+)
+_MEDIA_VALUE_OPTION = re.compile(
+    r"(?:(?:alt|альт|альтернативный\s+текст|link|ссылка|"
+    r"thumbtime|start|end|poster)\s*=\s*.*|"
+    r"(?:class|lang)\s*=\s*.+|"
+    r"(?:thumb|thumbnail|мини|миниатюра)\s*=\s*.*|"
+    r"(?:page|страница)(?:\s*=\s*[0-9]*|\s+[0-9]+)|"
+    r"(?:upright|сверхусправа)"
+    r"(?:\s*=\s*[0-9]*(?:\.[0-9]+)?|\s+[0-9]+(?:\.[0-9]+)?)?|"
+    r"(?:[0-9]+|[0-9]*x[0-9]+)\s*(?:px|пкс))\Z",
+    re.IGNORECASE,
+)
+
+
+@dataclass(frozen=True, slots=True)
+class ExpectedWikiPage:
+    """Metadata that content extraction must reproduce exactly."""
+
+    page_id: int
+    canonical_title: str
+
+
+@dataclass(frozen=True, slots=True)
+class ExtractedWikiPage:
+    """Selected plain text and immutable source provenance."""
+
+    page_id: int
+    canonical_title: str
+    revision_id: int
+    multistream_offset: int
+    multistream_end_offset: int
+    index_line_number: int
+    raw_text: str
+    wikitext_sha256: str
+    raw_text_sha256: str
+
+
+@dataclass(frozen=True, slots=True)
+class _IndexMatch:
+    offset: int
+    end_offset: int
+    line_number: int
+
+
+def extract_selected_pages(
+    dump_path: str | Path | BinaryIO,
+    index_path: str | Path | BinaryIO,
+    expected_pages: Iterable[ExpectedWikiPage],
+    *,
+    source_records: dict[int, dict[str, str]] | None = None,
+) -> tuple[ExtractedWikiPage, ...]:
+    """Extract only expected pages from bounded multistream members.
+
+    The index and XML must agree exactly with caller-supplied page and title
+    metadata. Any relevant duplicate, missing value, malformed input, or
+    metadata mismatch raises ``ValueError``. When ``source_records`` is supplied,
+    populate it by page ID with exact decoded wikitext and a required valid UTC
+    revision timestamp. Default outputs and legacy timestamp handling are unchanged.
+    """
+
+    expected = _validate_expected_pages(expected_pages)
+    if not expected:
+        return ()
+    with ExitStack() as stack:
+        dump = (
+            dump_path
+            if hasattr(dump_path, "read")
+            else stack.enter_context(Path(dump_path).open("rb"))
+        )
+        index = (
+            index_path
+            if hasattr(index_path, "read")
+            else stack.enter_context(Path(index_path).open("rb"))
+        )
+        return _extract_selected_pages(dump, index, expected, source_records)
+
+
+def _extract_selected_pages(
+    dump: BinaryIO,
+    index: BinaryIO,
+    expected: dict[int, ExpectedWikiPage],
+    source_records: dict[int, dict[str, str]] | None,
+) -> tuple[ExtractedWikiPage, ...]:
+    matches = _read_index(index, expected, os.fstat(dump.fileno()).st_size)
+    ids_by_offset: dict[int, set[int]] = {}
+    for page_id, match in matches.items():
+        ids_by_offset.setdefault(match.offset, set()).add(page_id)
+
+    extracted: dict[int, ExtractedWikiPage] = {}
+    for offset in sorted(ids_by_offset):
+        page_ids = ids_by_offset[offset]
+        match = matches[next(iter(page_ids))]
+        member_xml = _decompress_member(dump, match.offset, match.end_offset)
+        for page in _iter_pages(member_xml):
+            page_id = _read_page_id(page)
+            if page_id not in page_ids:
+                continue
+            if page_id in extracted:
+                raise ValueError(f"duplicate selected page in XML: {page_id}")
+            title, revision_id, wikitext = _read_selected_page(page)
+            metadata = expected[page_id]
+            if title != metadata.canonical_title:
+                raise ValueError(
+                    f"page {page_id} XML title mismatch: {title!r} != "
+                    f"{metadata.canonical_title!r}"
+                )
+            if source_records is not None:
+                revision = _only_child(page, "revision")
+                timestamp = _only_child_text(revision, "timestamp")
+                if re.fullmatch(
+                    r"[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}Z",
+                    timestamp,
+                ) is None:
+                    raise ValueError("malformed revision timestamp in XML")
+                try:
+                    datetime.strptime(timestamp, "%Y-%m-%dT%H:%M:%SZ")
+                except ValueError as error:
+                    raise ValueError("malformed revision timestamp in XML") from error
+                source_records[page_id] = {
+                    "wikitext": wikitext,
+                    "revision_timestamp": timestamp,
+                }
+            raw_text = _strip_code(wikitext)
+            if not isinstance(raw_text, str):
+                raise ValueError("mwparserfromhell.strip_code returned non-text")
+            index_match = matches[page_id]
+            extracted[page_id] = ExtractedWikiPage(
+                page_id=page_id,
+                canonical_title=title,
+                revision_id=revision_id,
+                multistream_offset=index_match.offset,
+                multistream_end_offset=index_match.end_offset,
+                index_line_number=index_match.line_number,
+                raw_text=raw_text,
+                wikitext_sha256=sha256(wikitext.encode("utf-8")).hexdigest(),
+                raw_text_sha256=sha256(raw_text.encode("utf-8")).hexdigest(),
+            )
+
+    missing = sorted(set(expected) - set(extracted))
+    if missing:
+        raise ValueError(f"selected pages missing from XML: {missing}")
+    return tuple(extracted[page_id] for page_id in sorted(extracted))
+
+
+def _validate_expected_pages(
+    expected_pages: Iterable[ExpectedWikiPage],
+) -> dict[int, ExpectedWikiPage]:
+    expected: dict[int, ExpectedWikiPage] = {}
+    for page in expected_pages:
+        if (
+            not isinstance(page.page_id, int)
+            or isinstance(page.page_id, bool)
+            or page.page_id <= 0
+            or not isinstance(page.canonical_title, str)
+            or not page.canonical_title
+        ):
+            raise ValueError(f"invalid expected page metadata: {page!r}")
+        if page.page_id in expected:
+            raise ValueError(f"duplicate expected page ID: {page.page_id}")
+        expected[page.page_id] = page
+    return expected
+
+
+def _read_index(
+    index: BinaryIO,
+    expected: dict[int, ExpectedWikiPage],
+    dump_size: int,
+) -> dict[int, _IndexMatch]:
+    found: dict[int, tuple[int, int]] = {}
+    next_offset_by_offset: dict[int, int] = {}
+    previous_offset: int | None = None
+    try:
+        index.seek(0)
+        with bz2.open(index, "rt", encoding="utf-8", newline="") as source:
+            for line_number, raw_line in enumerate(source, 1):
+                line = raw_line.removesuffix("\n").removesuffix("\r")
+                fields = line.split(":", 2)
+                if (
+                    len(fields) != 3
+                    or _DECIMAL.fullmatch(fields[0]) is None
+                    or _DECIMAL.fullmatch(fields[1]) is None
+                    or not fields[2]
+                ):
+                    raise ValueError(f"malformed multistream index line {line_number}")
+                offset, page_id = int(fields[0]), int(fields[1])
+                if offset >= dump_size or page_id <= 0:
+                    raise ValueError(f"invalid multistream index line {line_number}")
+                if previous_offset is not None and offset < previous_offset:
+                    raise ValueError(
+                        f"multistream offsets decrease at index line {line_number}"
+                    )
+                if previous_offset is not None and offset > previous_offset:
+                    next_offset_by_offset[previous_offset] = offset
+                previous_offset = offset
+                metadata = expected.get(page_id)
+                if metadata is None:
+                    continue
+                if page_id in found:
+                    raise ValueError(f"duplicate selected page in index: {page_id}")
+                if "<" in fields[2]:
+                    raise ValueError(
+                        f"malformed multistream index title at line {line_number}"
+                    )
+                try:
+                    index_title = ElementTree.fromstring(
+                        f"<title>{fields[2]}</title>"
+                    ).text
+                except ElementTree.ParseError as error:
+                    raise ValueError(
+                        f"malformed multistream index title at line {line_number}: "
+                        f"{error}"
+                    ) from error
+                if index_title is None:
+                    raise ValueError(
+                        f"malformed multistream index title at line {line_number}"
+                    )
+                if index_title != metadata.canonical_title:
+                    raise ValueError(
+                        f"page {page_id} index title mismatch: {index_title!r} != "
+                        f"{metadata.canonical_title!r}"
+                    )
+                found[page_id] = offset, line_number
+    except (EOFError, OSError, UnicodeError) as error:
+        raise ValueError(f"malformed multistream index: {error}") from error
+
+    missing = sorted(set(expected) - set(found))
+    if missing:
+        raise ValueError(f"selected pages missing from index: {missing}")
+    return {
+        page_id: _IndexMatch(
+            offset,
+            next_offset_by_offset.get(offset, dump_size),
+            line_number,
+        )
+        for page_id, (offset, line_number) in found.items()
+    }
+
+
+def _decompress_member(dump: BinaryIO, offset: int, end_offset: int) -> bytes:
+    if end_offset <= offset:
+        raise ValueError(f"invalid multistream member bounds: {offset}:{end_offset}")
+    dump.seek(offset)
+    remaining = end_offset - offset
+    decompressor = bz2.BZ2Decompressor()
+    output = bytearray()
+    try:
+        while remaining:
+            chunk = dump.read(min(_READ_SIZE, remaining))
+            if not chunk:
+                raise ValueError(f"truncated multistream member at offset {offset}")
+            remaining -= len(chunk)
+            output.extend(decompressor.decompress(chunk))
+            if decompressor.eof and (remaining or decompressor.unused_data):
+                raise ValueError(
+                    f"index boundary spans multiple members at offset {offset}"
+                )
+    except (EOFError, OSError) as error:
+        raise ValueError(f"malformed bzip2 member at offset {offset}") from error
+    if not decompressor.eof:
+        raise ValueError(f"truncated bzip2 member at offset {offset}")
+    return bytes(output)
+
+
+def _iter_pages(member_xml: bytes) -> Iterable[ElementTree.Element]:
+    position = 0
+    while match := _PAGE_START.search(member_xml, position):
+        end = member_xml.find(_PAGE_END, match.end())
+        if end < 0:
+            raise ValueError("malformed page XML: missing closing page tag")
+        end += len(_PAGE_END)
+        try:
+            yield ElementTree.fromstring(member_xml[match.start() : end])
+        except ElementTree.ParseError as error:
+            raise ValueError(f"malformed page XML: {error}") from error
+        position = end
+
+
+def _read_page_id(page: ElementTree.Element) -> int:
+    page_id_text = _only_child_text(page, "id")
+    if _DECIMAL.fullmatch(page_id_text) is None or int(page_id_text) <= 0:
+        raise ValueError("malformed page ID in XML")
+    return int(page_id_text)
+
+
+def _read_selected_page(page: ElementTree.Element) -> tuple[str, int, str]:
+    if any(_local_name(child.tag) == "redirect" for child in page):
+        raise ValueError("selected page is a redirect")
+    title = _only_child_text(page, "title")
+    revision = _only_child(page, "revision")
+    revision_id_text = _only_child_text(revision, "id")
+    text = _only_child(revision, "text")
+    if (
+        _DECIMAL.fullmatch(revision_id_text) is None
+        or int(revision_id_text) <= 0
+        or list(text)
+    ):
+        raise ValueError("malformed page XML fields")
+    return title, int(revision_id_text), text.text or ""
+
+
+def _only_child(element: ElementTree.Element, name: str) -> ElementTree.Element:
+    matches = [child for child in element if _local_name(child.tag) == name]
+    if len(matches) != 1:
+        raise ValueError(f"page XML must contain exactly one {name!r} child")
+    return matches[0]
+
+
+def _only_child_text(element: ElementTree.Element, name: str) -> str:
+    child = _only_child(element, name)
+    if child.text is None or list(child):
+        raise ValueError(f"page XML {name!r} must contain plain text")
+    return child.text
+
+
+def _local_name(tag: str) -> str:
+    return tag.rsplit("}", 1)[-1]
+
+
+def _strip_code(wikitext: str) -> str:
+    try:
+        import mwparserfromhell
+    except ImportError as error:
+        raise RuntimeError("mwparserfromhell is required for wikitext extraction") from error
+    if _TAG_SENTINEL in wikitext:
+        raise ValueError("wikitext collides with the HTML placeholder sentinel")
+    locally_cleaned = wikitext
+    media_replacements = []
+    selected_end = 0
+    for match in _MEDIA_LINK_OPEN.finditer(locally_cleaned):
+        if match.start() < selected_end:
+            continue
+        end = _find_balanced_end(locally_cleaned, match.start(), "[[", "]]")
+        if end is None:
+            continue
+        candidate = locally_cleaned[match.start() : end]
+        isolated = mwparserfromhell.parse(candidate)
+        if (
+            len(isolated.nodes) != 1
+            or not isinstance(isolated.nodes[0], mwparserfromhell.nodes.Wikilink)
+        ):
+            continue
+        link = isolated.nodes[0]
+        title = str(link.title).strip()
+        namespace, separator, filename = title.partition(":")
+        if (
+            not separator
+            or namespace.casefold() not in _MEDIA_NAMESPACES
+            or not filename.strip()
+        ):
+            continue
+        caption = (
+            _last_media_caption(_split_top_level_pipes(link.text))
+            if link.text is not None
+            else ""
+        )
+        media_replacements.append((match.start(), end, caption))
+        selected_end = end
+    for start, end, caption in reversed(media_replacements):
+        locally_cleaned = locally_cleaned[:start] + caption + locally_cleaned[end:]
+
+    template_replacements = []
+    selected_end = 0
+    for match in _FILE_DESCRIPTION_TEMPLATE_OPEN.finditer(locally_cleaned):
+        if match.start() < selected_end:
+            continue
+        end = _find_balanced_end(locally_cleaned, match.start(), "{{", "}}")
+        if end is None:
+            continue
+        candidate = locally_cleaned[match.start() : end]
+        isolated = mwparserfromhell.parse(candidate)
+        if (
+            len(isolated.nodes) == 1
+            and isinstance(isolated.nodes[0], mwparserfromhell.nodes.Template)
+            and str(isolated.nodes[0].name).strip().casefold() == "файл с описанием"
+        ):
+            template_replacements.append((match.start(), end))
+            selected_end = end
+    for start, end in reversed(template_replacements):
+        locally_cleaned = locally_cleaned[:start] + locally_cleaned[end:]
+
+    special_tags_cleaned = locally_cleaned
+    if _SPECIAL_TAG_OPEN.search(locally_cleaned) is not None:
+        special_tags_parsed = mwparserfromhell.parse(locally_cleaned)
+        for tag in reversed(special_tags_parsed.filter_tags(recursive=True)):
+            tag_name = str(tag.tag).strip().casefold()
+            if tag_name == "mapframe":
+                replacement = _TAG_SENTINEL * 2
+            elif tag_name in {"gallery", "imagemap"}:
+                captions = []
+                for line in str(tag.contents).splitlines():
+                    if not line.strip():
+                        continue
+                    caption = _media_declaration_caption(
+                        mwparserfromhell.parse(line)
+                    )
+                    if caption is None:
+                        continue
+                    stripped_caption = _strip_code(caption)
+                    if stripped_caption.strip():
+                        captions.append(stripped_caption)
+                    if tag_name == "imagemap":
+                        break
+                replacement = (
+                    _TAG_SENTINEL + "\n".join(captions) + _TAG_SENTINEL
+                )
+            else:
+                continue
+            special_tags_parsed.replace(tag, replacement, recursive=True)
+        special_tags_cleaned = str(special_tags_parsed)
+
+    protected = _HTML_SPAN.sub(_TAG_SENTINEL, special_tags_cleaned)
+    parsed = mwparserfromhell.parse(protected)
+    for link in reversed(parsed.filter_wikilinks(recursive=True)):
+        title = str(link.title).strip()
+        namespace, separator, _ = title.partition(":")
+        if not separator or namespace.casefold() not in _MEDIA_NAMESPACES:
+            continue
+        caption = (
+            _last_media_caption(_split_top_level_pipes(link.text))
+            if link.text is not None
+            else ""
+        )
+        parsed.replace(link, caption, recursive=True)
+    stripped = parsed.strip_code(
+        normalize=True,
+        collapse=True,
+        keep_template_params=False,
+    )
+    stripped = stripped.replace(_TAG_SENTINEL, "<TAG>")
+    characters = list(stripped)
+    for position in range(1, len(stripped) - 2):
+        if (
+            stripped[position : position + 2] == "]]"
+            and stripped[position - 1].isalpha()
+            and stripped[position + 2].isalpha()
+        ):
+            characters[position] = " "
+            characters[position + 1] = ""
+    stripped = "".join(characters)
+    stripped = _MALFORMED_IMAGE_PARAMETER_LINE.sub("", stripped)
+    return _ORPHAN_MEDIA_FLAG.sub("", stripped)
+
+
+def _find_balanced_end(
+    text: str,
+    start: int,
+    opener: str,
+    closer: str,
+) -> int | None:
+    depth = 1
+    position = start + len(opener)
+    while position <= len(text) - len(closer):
+        if text.startswith(opener, position):
+            depth += 1
+            position += len(opener)
+        elif text.startswith(closer, position):
+            depth -= 1
+            position += len(closer)
+            if depth == 0:
+                return position
+        else:
+            position += 1
+    return None
+
+
+def _media_declaration_caption(code: object) -> str | None:
+    fields = _split_top_level_pipes(code)
+    title = fields[0].strip()
+    namespace, separator, filename = title.partition(":")
+    if (
+        not separator
+        or namespace.casefold() not in _MEDIA_NAMESPACES
+        or not filename.strip()
+    ):
+        return None
+    return _last_media_caption(fields[1:])
+
+
+def _split_top_level_pipes(code: object) -> list[str]:
+    import mwparserfromhell
+
+    fields = [""]
+    for node in code.nodes:
+        if isinstance(node, mwparserfromhell.nodes.Text):
+            fragments = node.value.split("|")
+            fields[-1] += fragments[0]
+            fields.extend(fragments[1:])
+        else:
+            fields[-1] += str(node)
+    return fields
+
+
+def _last_media_caption(options: Iterable[str]) -> str:
+    caption = ""
+    for option in options:
+        normalized = option.strip()
+        if (
+            normalized
+            and normalized.casefold() not in _MEDIA_FLAG_OPTIONS
+            and _MEDIA_VALUE_OPTION.fullmatch(normalized) is None
+        ):
+            caption = option
+    return caption

preprocessing/_wikigood/wikigood_ru_csv.py

@@ -0,0 +1,453 @@
+"""Portable streaming CSV preparation for the pinned Russian Wikipedia corpora.
+
+Verification checks source binding and serialized structure, not NLP replay.
+Targets must be fresh and disjoint; failed builds are retained for inspection.
+"""
+from __future__ import annotations
+
+import argparse
+from collections import Counter
+import csv
+import gzip
+from io import StringIO
+from hashlib import sha256
+from importlib.metadata import version
+from itertools import zip_longest
+import json
+import os
+from pathlib import Path
+import platform
+import re
+import shutil
+import sqlite3
+import sys
+from urllib.parse import unquote
+from urllib.request import urlopen
+import zipfile
+
+from .wikigood_ru_nlp import create_wikigood_ru_lemmatizer, select_wikigood_ru_ngrams
+from .wikigood_ru_vw import WikiGoodRuDocument, format_wikigood_ru_vw_row
+
+SOURCE_PINS = {
+    'full': {'repository': 'TopicNet/RuWiki-Good-2026-V2', 'revision': '3c6bdb4ddc1be38b4fd63a480bdd056394a04934', 'count': 17413,
+             'articles': {'sha256': 'c51f9b6bee4c85f25ffb861060f52490a9276bae289d2aa2db7e0d10e2dda950', 'byte_size': 409970311}},
+    'selected': {'repository': 'TopicNet/RuWiki-Good-2026-V2-Selected', 'revision': 'fc1ad9b9491ab122614a95b3aa78b3cdfa5e3881', 'count': 17251,
+                 'articles': {'sha256': '9eb7efffe99fc7c9bc3f4b3eb9f0378d91f387081f97cf9abea9c1686797c1ed', 'byte_size': 413342335},
+                 'topics': {'sha256': 'c8cf602a924f18255e155cdcaa9357907461851e849113c72051c2b89484f22c', 'byte_size': 2671}},
+}
+STOPWORDS = {'sha256': '48c0e52d8b52546e827f53761fb30300c0ab94f70660d28bd65ba0a86270946b', 'byte_size': 37733}
+STOPWORDS_URL = 'https://raw.githubusercontent.com/nltk/nltk_data/550b6625bcef1f2abff2ff770a5a0d272c9c6b2a/packages/corpora/stopwords.zip'
+RUSSIAN_STOPWORDS_SHA256 = '1743191192b4a4f77fcc216499455dc00c1b8626fdd407076a8deefff80e3d59'
+RUNTIME = {'python': '3.11.15', 'packages': {'spacy': '3.8.14', 'pymorphy3': '2.0.6', 'nltk': '3.9.2'}}
+MODALITIES = ['@title', '@word', '@bigram', '@trigram', '@category']
+
+
+def _json(value):
+    return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(',', ':')) + '\n'
+
+
+def _progress(corpus, phase, processed, total, *, normalized=None):
+    detail = '' if normalized is None else f' normalized={normalized}'
+    print(f'PROGRESS corpus={corpus} phase={phase} processed={processed}/{total}{detail}',
+          file=sys.stderr, flush=True)
+
+
+def _safe(path):
+    path = Path(path).absolute()
+    if any(part.is_symlink() for part in (path, *path.parents)):
+        raise ValueError(f'symbolic links are forbidden: {path}')
+    return path
+
+
+def _record(path):
+    path = _safe(path)
+    if not path.is_file():
+        raise ValueError(f'expected regular file: {path}')
+    digest = sha256()
+    with path.open('rb') as stream:
+        for chunk in iter(lambda: stream.read(1024 * 1024), b''):
+            digest.update(chunk)
+    return {'sha256': digest.hexdigest(), 'byte_size': path.stat().st_size}
+
+
+def _datasets(dataset):
+    if dataset not in ('full', 'selected', 'both'):
+        raise ValueError('dataset must be full, selected or both')
+    return ('full', 'selected') if dataset == 'both' else (dataset,)
+
+
+def _rows(path):
+    with gzip.open(_safe(path), 'rt', encoding='utf-8', newline='') as stream:
+        for line in stream:
+            row = json.loads(line)
+            if not isinstance(row, dict):
+                raise ValueError('JSONL record must be an object')
+            yield row
+
+
+def validate_wikigood_ru_csv_sources(sources_dir: str | Path, *, dataset: str = 'both') -> dict[str, object]:
+    """Hash every required pinned source before any output creation."""
+    sources = _safe(sources_dir)
+    identities = {}
+    for name in _datasets(dataset):
+        pin = SOURCE_PINS[name]
+        kinds = ('articles', 'topics') if name == 'selected' else ('articles',)
+        _progress(name, 'sources', 0, len(kinds))
+        for kind in kinds:
+            relative = f'{name}/{kind}.jsonl.gz'
+            observed = _record(sources / relative)
+            if observed != pin[kind]:
+                raise ValueError(f'pinned source hash/size mismatch: {relative}')
+            identities[relative] = observed
+        _progress(name, 'sources', len(kinds), len(kinds))
+    return identities
+
+
+def download_wikigood_ru_csv_sources(sources_dir: str | Path, *, dataset: str = 'both') -> dict[str, object]:
+    """Download immutable source revisions and the pinned NLTK resource.
+
+    Existing valid files are reused. Partial/invalid files are never overwritten.
+    """
+    sources = _safe(sources_dir)
+    requests = []
+    for name in _datasets(dataset):
+        pin = SOURCE_PINS[name]
+        kinds = ('articles', 'topics') if name == 'selected' else ('articles',)
+        _progress(name, 'sources', 0, len(kinds))
+        for kind in kinds:
+            requests.append((sources / name / f'{kind}.jsonl.gz', pin[kind],
+                             f"https://huggingface.co/datasets/{pin['repository']}/resolve/{pin['revision']}/data/{kind}.jsonl.gz"))
+    requests.append((sources / 'nltk_data/corpora/stopwords.zip', STOPWORDS, STOPWORDS_URL))
+    for path, expected, url in requests:
+        _safe(path)
+        if path.exists():
+            if _record(path) != expected:
+                raise ValueError(f'existing source does not match pin: {path}')
+            continue
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with urlopen(url) as remote, path.open('xb') as local:
+            shutil.copyfileobj(remote, local)
+        if _record(path) != expected:
+            raise ValueError(f'download does not match pin: {path}')
+    return validate_wikigood_ru_csv_sources(sources, dataset=dataset)
+
+
+def _runtime(nltk_data):
+    observed = {'python': platform.python_version(), 'packages': {name: version(name) for name in RUNTIME['packages']}}
+    if observed != RUNTIME:
+        raise ValueError(f'quality-nlp requires pinned scientific runtime: {RUNTIME}; observed {observed}')
+    nltk_data = _safe(nltk_data)
+    archive = nltk_data / 'corpora/stopwords.zip'
+    extracted = nltk_data / 'corpora/stopwords/russian'
+    if extracted.exists():
+        russian = _safe(extracted).read_bytes()
+        if sha256(russian).hexdigest() != RUSSIAN_STOPWORDS_SHA256:
+            raise ValueError('extracted Russian stopwords resource hash mismatch')
+    if archive.exists():
+        if _record(archive) != STOPWORDS:
+            raise ValueError('NLTK stopwords archive hash mismatch')
+        with zipfile.ZipFile(archive) as stream:
+            russian = stream.read('stopwords/russian')
+    else:
+        russian = _safe(extracted).read_bytes()
+    if sha256(russian).hexdigest() != RUSSIAN_STOPWORDS_SHA256:
+        raise ValueError('Russian stopwords resource hash mismatch')
+    os.environ['NLTK_DATA'] = str(nltk_data)
+    import nltk
+    nltk.data.path[:] = [str(nltk_data)]
+    lemmatize = create_wikigood_ru_lemmatizer()
+    if not lemmatize('Проверка русского языка'):
+        raise ValueError('Russian NLP runtime probe failed')
+    return lemmatize
+
+
+def _topics(sources, names):
+    if 'selected' not in names:
+        return set()
+    topics = list(_rows(sources / 'selected/topics.jsonl.gz'))
+    if any(set(row) != {'slug', 'name_ru', 'name_en', 'definition_and_boundaries'} or any(not isinstance(value, str) or not value for value in row.values()) for row in topics):
+        raise ValueError('invalid topic catalog schema')
+    slugs = [row.get('slug') for row in topics]
+    if (not slugs or any(not isinstance(slug, str) or not re.fullmatch('[a-z][a-z0-9_-]*', slug) for slug in slugs)
+            or len(set(slugs)) != len(slugs)):
+        raise ValueError('invalid or duplicate topic slugs')
+    return set(slugs)
+
+
+def _articles(sources, name, topic_slugs):
+    previous = 0
+    count = 0
+    for row in _rows(sources / name / 'articles.jsonl.gz'):
+        page_id = row.get('page_id')
+        if type(page_id) is not int or page_id <= previous or row.get('id') != f'ruwiki/{page_id}':
+            raise ValueError('source IDs must be unique, numeric and increasing')
+        previous = page_id
+        for field in ('title', 'raw_text'):
+            if not isinstance(row.get(field), str):
+                raise ValueError(f'invalid source {field}')
+        categories = row.get('categories')
+        if not isinstance(categories, list) or any(not isinstance(value, str) or not value for value in categories):
+            raise ValueError('invalid direct categories')
+        if name == 'selected':
+            topics = row.get('topics')
+            if (not isinstance(topics, list) or not topics or any(not isinstance(topic, str) for topic in topics)
+                    or topics != sorted(set(topics)) or not set(topics) <= topic_slugs):
+                raise ValueError('invalid source topic binding')
+        count += 1
+        yield row
+    if count != SOURCE_PINS[name]['count']:
+        raise ValueError(f'source document count mismatch: {name}: {count}')
+
+
+class _Words:
+    """Replay disk-backed token sequences in source order for NLTK's two passes."""
+    def __init__(self, connection, name):
+        self.connection, self.name = connection, name
+
+    def __iter__(self):
+        for (payload,) in self.connection.execute('SELECT tokens FROM tokens JOIN members USING(page_id) WHERE corpus=? ORDER BY page_id', (self.name,)):
+            yield json.loads(payload)['word']
+
+
+def build_wikigood_ru_csv(
+    sources_dir: str | Path, *, output_dir: str | Path, scratch_dir: str | Path,
+    dataset: str = 'both', nltk_data: str | Path | None = None,
+) -> dict[str, object]:
+    """Normalize common articles once, spool tokens, and write separate corpora."""
+    sources, output, scratch = map(_safe, (sources_dir, output_dir, scratch_dir))
+    paths = (sources.resolve(), output.resolve(), scratch.resolve())
+    if any(a == b or a.is_relative_to(b) or b.is_relative_to(a) for i, a in enumerate(paths) for b in paths[i + 1:]):
+        raise ValueError('sources, output and scratch must be disjoint')
+    for target in (output, scratch):
+        if target.exists():
+            raise FileExistsError(f'target must be fresh: {target}')
+        if not target.parent.is_dir():
+            raise ValueError(f'target parent must exist: {target.parent}')
+    names = _datasets(dataset)
+    identities = validate_wikigood_ru_csv_sources(sources, dataset=dataset)
+    topic_slugs = _topics(sources, names)
+    _progress(dataset, 'nlp-runtime', 0, 1)
+    lemmatize = _runtime(nltk_data or sources / 'nltk_data')
+    _progress(dataset, 'nlp-runtime', 1, 1)
+    # A conservative disk gate precedes creation; no time/RSS claims are made.
+    minimum = max(64 * 1024**2, sum(entry['byte_size'] for entry in identities.values()) * 12)
+    for parent in {output.parent, scratch.parent}:
+        if shutil.disk_usage(parent).free < minimum:
+            raise OSError(f'insufficient free disk space; require {minimum} bytes')
+    scratch.mkdir()
+    with sqlite3.connect(scratch / 'tokens.sqlite3') as connection:
+        connection.execute('PRAGMA temp_store=MEMORY')
+        connection.execute('CREATE TABLE tokens(page_id INTEGER PRIMARY KEY, binding TEXT, tokens TEXT)')
+        connection.execute('CREATE TABLE members(corpus TEXT, page_id INTEGER, PRIMARY KEY(corpus,page_id))')
+        for name in names:
+            total = SOURCE_PINS[name]['count']
+            interval = max(1, min(100, total // 10))
+            normalized = 0
+            _progress(name, 'normalize', 0, total, normalized=normalized)
+            for processed, row in enumerate(_articles(sources, name, topic_slugs), 1):
+                binding = sha256(_json({key: row[key] for key in ('title', 'raw_text', 'categories')}).encode()).hexdigest()
+                existing = connection.execute('SELECT binding FROM tokens WHERE page_id=?', (row['page_id'],)).fetchone()
+                if existing is None:
+                    payload = _json({'title': lemmatize(row['title']), 'word': lemmatize(row['raw_text'])})
+                    connection.execute('INSERT INTO tokens VALUES(?,?,?)', (row['page_id'], binding, payload))
+                    normalized += 1
+                elif existing[0] != binding:
+                    raise ValueError('common article content differs between corpora')
+                connection.execute('INSERT INTO members VALUES(?,?)', (name, row['page_id']))
+                if processed % interval == 0 and processed < total:
+                    _progress(name, 'normalize', processed, total, normalized=normalized)
+            connection.commit()
+            _progress(name, 'normalize', total, total, normalized=normalized)
+        del lemmatize
+        output.mkdir()
+        manifest = {'schema': 'wikigood-ru-csv-1', 'datasets': list(names), 'sources': identities,
+                    'source_pins': {name: SOURCE_PINS[name] for name in names}, 'runtime': RUNTIME,
+                    'stopwords_sha256': RUSSIAN_STOPWORDS_SHA256, 'corpora': {}, 'files': {},
+                    'verification': 'source binding and serialized structure; no morphology replay'}
+        for name in names:
+            total = SOURCE_PINS[name]['count']
+            interval = max(1, min(100, total // 10))
+            _progress(name, 'ngram-selection', 0, total)
+            bigrams, trigrams = select_wikigood_ru_ngrams(_Words(connection, name))
+            _progress(name, 'ngram-selection', total, total)
+            directory = output / name
+            directory.mkdir()
+            labels = {}
+            empty_word_ids = []
+            _progress(name, 'write', 0, total)
+            with (directory / 'noow.csv').open('x', encoding='utf-8', newline='') as noow, (directory / 'bow.csv').open('x', encoding='utf-8', newline='') as bow:
+                writers = [csv.writer(stream, lineterminator='\n') for stream in (noow, bow)]
+                for writer in writers:
+                    writer.writerow(('id', 'raw_text', 'vw_text'))
+                for processed, row in enumerate(_articles(sources, name, topic_slugs), 1):
+                    tokens = json.loads(connection.execute('SELECT tokens FROM tokens WHERE page_id=?', (row['page_id'],)).fetchone()[0])
+                    if not tokens['word']:
+                        empty_word_ids.append(row['id'])
+                    document = WikiGoodRuDocument(row['page_id'], row['title'], row.get('revision_id', 0), tokens['title'], tokens['word'], row['categories'], '', '')
+                    topics = row['topics'] if name == 'selected' else None
+                    if topics is not None:
+                        labels[row['id']] = topics
+                    raw = row['title'] + '\n\n' + row['raw_text'].lstrip('\r\n')
+                    for is_bow, writer in enumerate(writers):
+                        vw = format_wikigood_ru_vw_row(row['id'], document, accepted_bigrams=bigrams, accepted_trigrams=trigrams, topics=topics, bow=bool(is_bow))
+                        writer.writerow((row['id'], raw, vw))
+                    if processed % interval == 0 and processed < total:
+                        _progress(name, 'write', processed, total)
+            _progress(name, 'write', total, total)
+            if name == 'selected':
+                (directory / 'labels.json').write_text(_json(labels), encoding='utf-8')
+            manifest['corpora'][name] = {'count': total, 'bigrams': sorted(bigrams), 'trigrams': sorted(trigrams),
+                                         'empty_word_count': len(empty_word_ids), 'empty_word_ids': empty_word_ids}
+            for path in sorted(directory.iterdir()):
+                manifest['files'][str(path.relative_to(output))] = _record(path)
+        manifest['manifest_sha256'] = sha256(_json(manifest).encode()).hexdigest()
+        (output / 'manifest.json').write_text(_json(manifest), encoding='utf-8')
+    verify_wikigood_ru_csv(sources, output_dir=output, dataset=dataset)
+    return manifest
+
+
+def _escape(value, *, ngram=False):
+    return ''.join(''.join(f'%{byte:02X}' for byte in char.encode('utf-8'))
+                   if char in ('%|:_' if ngram else '%|:') or char.isspace() or not char.isprintable() else char for char in value)
+
+
+def _parse_vw(value, document_id, names, *, bow):
+    sections = value.split(' |')
+    if sections.pop(0) != document_id or len(sections) != len(names):
+        raise ValueError('VW identity or namespace count mismatch')
+    result = {}
+    for expected, section in zip(names, sections):
+        fields = section.split(' ')
+        if fields.pop(0) != expected or any(not field for field in fields):
+            raise ValueError('VW namespace order or spacing mismatch')
+        if bow:
+            pairs = [field.rsplit(':', 1) for field in fields]
+            if any(len(pair) != 2 or not re.fullmatch('[1-9][0-9]*', pair[1]) for pair in pairs):
+                raise ValueError('invalid BOW frequency')
+            tokens = [pair[0] for pair in pairs]
+            if tokens != sorted(set(tokens)):
+                raise ValueError('BOW tokens must be sorted and unique')
+            result[expected] = Counter({token: int(count) for token, count in pairs})
+        else:
+            for token in fields:
+                decoded = unquote(token, encoding='utf-8', errors='strict')
+                if ('_'.join(_escape(unquote(piece, encoding='utf-8', errors='strict'), ngram=True) for piece in token.split('_')) if expected in ('@bigram', '@trigram') else _escape(decoded)) != token:
+                    raise ValueError('unsafe or noncanonical VW escaping')
+            result[expected] = fields
+    return result
+
+
+def verify_wikigood_ru_csv(
+    sources_dir: str | Path, *, output_dir: str | Path, dataset: str = 'both',
+) -> dict[str, object]:
+    """Independently check source/CSV/label structure without invoking NLP."""
+    sources, output = map(_safe, (sources_dir, output_dir))
+    names = _datasets(dataset)
+    identities = validate_wikigood_ru_csv_sources(sources, dataset=dataset)
+    manifest = json.loads(_safe(output / 'manifest.json').read_text(encoding='utf-8'))
+    if not isinstance(manifest, dict) or set(manifest) != {'schema', 'datasets', 'sources', 'source_pins', 'runtime', 'stopwords_sha256', 'corpora', 'files', 'verification', 'manifest_sha256'}:
+        raise ValueError('manifest schema mismatch')
+    unsigned = {key: value for key, value in manifest.items() if key != 'manifest_sha256'}
+    if manifest['manifest_sha256'] != sha256(_json(unsigned).encode()).hexdigest():
+        raise ValueError('manifest integrity mismatch')
+    if (manifest['schema'] != 'wikigood-ru-csv-1' or manifest['datasets'] != list(names) or _json(manifest['sources']) != _json(identities)
+            or _json(manifest['source_pins']) != _json({name: SOURCE_PINS[name] for name in names}) or manifest['runtime'] != RUNTIME
+            or manifest['stopwords_sha256'] != RUSSIAN_STOPWORDS_SHA256 or set(manifest['corpora']) != set(names)
+            or manifest['verification'] != 'source binding and serialized structure; no morphology replay'):
+        raise ValueError('manifest source/runtime binding mismatch')
+    expected_files = {f'{name}/{filename}' for name in names for filename in (('noow.csv', 'bow.csv', 'labels.json') if name == 'selected' else ('noow.csv', 'bow.csv'))}
+    actual_files = {str(path.relative_to(output)) for path in output.rglob('*') if path.is_file()}
+    if set(manifest['files']) != expected_files or actual_files != expected_files | {'manifest.json'}:
+        raise ValueError('output file set mismatch')
+    for relative in expected_files:
+        if _json(_record(output / relative)) != _json(manifest['files'][relative]):
+            raise ValueError(f'output hash mismatch: {relative}')
+    topic_slugs = _topics(sources, names)
+    csv.field_size_limit(sys.maxsize)
+    for name in names:
+        info = manifest['corpora'][name]
+        if not isinstance(info, dict) or set(info) != {'count', 'bigrams', 'trigrams', 'empty_word_count', 'empty_word_ids'} or type(info['count']) is not int or info['count'] != SOURCE_PINS[name]['count']:
+            raise ValueError('manifest corpus schema/count mismatch')
+        if (type(info['empty_word_count']) is not int or not isinstance(info['empty_word_ids'], list)
+                or any(not isinstance(value, str) for value in info['empty_word_ids'])):
+            raise ValueError('manifest empty-word diagnostic type mismatch')
+        empty_word_ids = []
+        vocab = {}
+        for field, size in (('bigrams', 2), ('trigrams', 3)):
+            phrases = info[field]
+            if not isinstance(phrases, list) or any(not isinstance(p, list) or len(p) != size or any(not isinstance(t, str) or not t for t in p) for p in phrases):
+                raise ValueError('invalid accepted ngram vocabulary')
+            vocab[field] = {tuple(p) for p in phrases}
+            if phrases != [list(p) for p in sorted(vocab[field])]:
+                raise ValueError('accepted vocabulary must be sorted and unique')
+        labels = json.loads((output / name / 'labels.json').read_text(encoding='utf-8')) if name == 'selected' else None
+        expected_labels = {}
+        with (output / name / 'noow.csv').open(encoding='utf-8', newline='') as noow, (output / name / 'bow.csv').open(encoding='utf-8', newline='') as bow:
+            readers = [csv.reader(stream, strict=True) for stream in (noow, bow)]
+            canonical = [sha256(), sha256()]
+            def account(index, values):
+                buffer = StringIO(newline='')
+                csv.writer(buffer, lineterminator='\n').writerow(values)
+                canonical[index].update(buffer.getvalue().encode('utf-8'))
+            if any(next(reader, None) != ['id', 'raw_text', 'vw_text'] for reader in readers):
+                raise ValueError('CSV header mismatch')
+            for index in range(2):
+                account(index, ['id', 'raw_text', 'vw_text'])
+            for row, noow_row, bow_row in zip_longest(_articles(sources, name, topic_slugs), *readers):
+                if row is None or noow_row is None or bow_row is None or len(noow_row) != 3 or len(bow_row) != 3:
+                    raise ValueError('CSV row count or field count mismatch')
+                account(0, noow_row)
+                account(1, bow_row)
+                raw = row['title'] + '\n\n' + row['raw_text'].lstrip('\r\n')
+                if noow_row[:2] != [row['id'], raw] or bow_row[:2] != noow_row[:2]:
+                    raise ValueError('CSV source identity/raw text mismatch')
+                namespaces = MODALITIES + (['@topic'] if name == 'selected' else [])
+                parsed = _parse_vw(noow_row[2], row['id'], namespaces, bow=False)
+                if not parsed['@word']:
+                    empty_word_ids.append(row['id'])
+                counted = _parse_vw(bow_row[2], row['id'], namespaces, bow=True)
+                if any(Counter(parsed[ns]) != counted[ns] for ns in namespaces):
+                    raise ValueError('NOOW/BOW counts differ')
+                if parsed['@category'] != [_escape(value) for value in row['categories']]:
+                    raise ValueError('direct category binding mismatch')
+                if name == 'selected':
+                    expected_labels[row['id']] = row['topics']
+                    if parsed['@topic'] != [_escape(topic) for topic in row['topics']]:
+                        raise ValueError('topic namespace binding mismatch')
+                words = [unquote(token, encoding='utf-8', errors='strict') for token in parsed['@word']]
+                for ns, field, size in (('@bigram', 'bigrams', 2), ('@trigram', 'trigrams', 3)):
+                    expected = ['_'.join(_escape(token, ngram=True) for token in phrase)
+                                for phrase in zip(*(words[i:] for i in range(size))) if phrase in vocab[field]]
+                    if parsed[ns] != expected:
+                        raise ValueError('ngram occurrence/order mismatch')
+            for index, filename in enumerate(('noow.csv', 'bow.csv')):
+                if canonical[index].hexdigest() != manifest['files'][f'{name}/{filename}']['sha256']:
+                    raise ValueError('CSV must use canonical UTF-8 quoting and LF framing')
+        if info['empty_word_count'] != len(empty_word_ids) or info['empty_word_ids'] != empty_word_ids:
+            raise ValueError('manifest empty-word diagnostic mismatch')
+        if labels is not None and labels != expected_labels:
+            raise ValueError('Selected labels binding mismatch')
+    return manifest
+
+
+def main(argv=None):
+    """Standalone portable entry point shared with the public wrapper."""
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--action', required=True, choices=('download', 'build', 'verify'))
+    parser.add_argument('--dataset', default='both', choices=('full', 'selected', 'both'))
+    parser.add_argument('--sources-dir', type=Path, required=True)
+    parser.add_argument('--output-dir', type=Path)
+    parser.add_argument('--scratch-dir', type=Path)
+    parser.add_argument('--nltk-data', type=Path)
+    args = parser.parse_args(argv)
+    for name in {'download': (), 'build': ('output_dir', 'scratch_dir'), 'verify': ('output_dir',)}[args.action]:
+        if getattr(args, name) is None:
+            parser.error(f'--{name.replace("_", "-")} is required')
+    if args.action == 'download':
+        download_wikigood_ru_csv_sources(args.sources_dir, dataset=args.dataset)
+    elif args.action == 'build':
+        build_wikigood_ru_csv(args.sources_dir, output_dir=args.output_dir, scratch_dir=args.scratch_dir, dataset=args.dataset, nltk_data=args.nltk_data)
+    else:
+        verify_wikigood_ru_csv(args.sources_dir, output_dir=args.output_dir, dataset=args.dataset)
+    print(f'{args.action.upper()}_OK dataset={args.dataset}', flush=True)
+    return 0

preprocessing/_wikigood/wikigood_ru_nlp.py

@@ -0,0 +1,229 @@
+"""Deterministic Russian NLP preparation for WikiGood publication artifacts."""
+
+from __future__ import annotations
+
+import re
+import unicodedata
+from typing import Callable, Iterable, Mapping, Sequence
+
+try:
+    from .wikigood_ru_content import ExtractedWikiPage
+    from .wikigood_ru_vw import WikiGoodRuDocument
+except ImportError:  # Direct module imports used by the mirrored fixture tests.
+    from wikigood_ru_content import ExtractedWikiPage
+    from wikigood_ru_vw import WikiGoodRuDocument
+
+
+_HTML_TAG = re.compile(r"<!--.*?-->|<![^<>]*>|</?[A-Za-z][^<>]*?>", re.DOTALL)
+_STRESS_MARKS = frozenset("\u0300\u0301")
+_LEXICAL_HYPHENS = frozenset("-\u2010\u2011")
+_HYPHEN_TOKEN_CANDIDATE = re.compile(r".+-.+\Z")
+_PLACEHOLDERS = ("<TAG>", "<URL>", "<MAIL>")
+MIN_NGRAM_FREQUENCY = 5
+NGRAM_CANDIDATE_LIMIT = 32_100
+NGRAM_HEAD_SKIP = 100
+NLP_ALGORITHMS = {
+    "tokenizer": "spacy.blank-ru",
+    "lemmatizer": "pymorphy3-normal-form",
+    "stopwords": "spacy-ru-union-nltk-russian",
+    "html_spans": "regex-space-bounded-placeholder-TAG",
+    "url_spans": "spacy-like-url-placeholder-URL",
+    "email_spans": "spacy-like-email-placeholder-MAIL",
+    "cyrillic_stress_marks": (
+        "remove-u0300-u0301-runs-after-cyrillic-letter-or-token-leading-"
+        "before-cyrillic-letter-pre-post-morphology"
+    ),
+    "cyrillic_lexical_hyphens": (
+        "normalize-u002d-u2010-u2011-to-ascii-spacy-token-match"
+    ),
+    "person_masking": "disabled",
+    "bigram_selector": "nltk-bigram-collocation-pmi",
+    "trigram_selector": "nltk-trigram-collocation-pmi",
+}
+
+
+def _is_cyrillic_letter(character: str) -> bool:
+    return (
+        unicodedata.category(character).startswith("L")
+        and "CYRILLIC" in unicodedata.name(character, "")
+    )
+
+
+def _normalize_cyrillic_stress(text: str, *, token_leading: bool = False) -> str:
+    characters = []
+    index = 0
+    while index < len(text):
+        if text[index] not in _STRESS_MARKS:
+            characters.append(text[index])
+            index += 1
+            continue
+        run_end = index + 1
+        while run_end < len(text) and text[run_end] in _STRESS_MARKS:
+            run_end += 1
+        follows_cyrillic = index > 0 and _is_cyrillic_letter(text[index - 1])
+        precedes_cyrillic = run_end < len(text) and _is_cyrillic_letter(
+            text[run_end]
+        )
+        if not (
+            follows_cyrillic
+            or (token_leading and index == 0 and precedes_cyrillic)
+        ):
+            characters.extend(text[index:run_end])
+        index = run_end
+    return "".join(characters)
+
+
+def _prepare_cyrillic_boundaries(text: str) -> str:
+    without_stress = _normalize_cyrillic_stress(text)
+    characters = list(without_stress)
+    for index in range(1, len(characters) - 1):
+        if (
+            characters[index] in _LEXICAL_HYPHENS
+            and _is_cyrillic_letter(characters[index - 1])
+            and _is_cyrillic_letter(characters[index + 1])
+        ):
+            characters[index] = "-"
+    return "".join(characters)
+
+
+def _match_cyrillic_hyphen_token(text: str) -> re.Match[str] | None:
+    candidate = _HYPHEN_TOKEN_CANDIDATE.fullmatch(text)
+    parts = text.split("-")
+    if candidate is not None and all(
+        part and all(_is_cyrillic_letter(character) for character in part)
+        for part in parts
+    ):
+        return candidate
+    return None
+
+
+def create_wikigood_ru_lemmatizer() -> Callable[[str], tuple[str, ...]]:
+    """Create the shared Russian tokenizer with its per-instance lemma cache."""
+
+    try:
+        import pymorphy3
+        import spacy
+        from nltk.corpus import stopwords
+        from spacy.lang.ru.stop_words import STOP_WORDS
+        from spacy.symbols import ORTH
+    except ImportError as error:
+        raise RuntimeError(
+            "spaCy, pymorphy3, NLTK, and the NLTK stopwords corpus are required "
+            "for WikiGood-RU NLP"
+        ) from error
+
+    tokenizer = spacy.blank("ru")
+    default_token_match = tokenizer.tokenizer.token_match
+    tokenizer.tokenizer.token_match = lambda text: (
+        _match_cyrillic_hyphen_token(text)
+        or (default_token_match(text) if default_token_match is not None else None)
+    )
+    for placeholder in _PLACEHOLDERS:
+        tokenizer.tokenizer.add_special_case(placeholder, [{ORTH: placeholder}])
+    morphology = pymorphy3.MorphAnalyzer()
+    russian_stopwords = frozenset(STOP_WORDS) | frozenset(
+        stopwords.words("russian")
+    )
+    lemma_cache: dict[str, str] = {}
+
+    def lemmatize(text: str) -> tuple[str, ...]:
+        prepared = _prepare_cyrillic_boundaries(text)
+        prepared = _HTML_TAG.sub(" <TAG> ", prepared)
+        lemmas = []
+        for token in tokenizer(prepared):
+            if token.text in _PLACEHOLDERS:
+                lemmas.append(token.text)
+                continue
+            if token.like_url:
+                lemmas.append("<URL>")
+                continue
+            if token.like_email:
+                lemmas.append("<MAIL>")
+                continue
+            if token.is_space or token.is_punct:
+                continue
+            normalized_token = _normalize_cyrillic_stress(
+                token.text, token_leading=True
+            )
+            lemma = lemma_cache.get(normalized_token)
+            if lemma is None:
+                lemma = _normalize_cyrillic_stress(
+                    morphology.parse(normalized_token)[0].normal_form.lower(),
+                    token_leading=True,
+                )
+                lemma_cache[normalized_token] = lemma
+            if (
+                normalized_token.lower() not in russian_stopwords
+                and lemma not in russian_stopwords
+            ):
+                lemmas.append(lemma)
+        return tuple(lemmas)
+
+    return lemmatize
+
+
+def select_wikigood_ru_ngrams(
+    word_sequences: Iterable[Sequence[str]],
+) -> tuple[frozenset[tuple[str, str]], frozenset[tuple[str, str, str]]]:
+    """Select independent PMI sets from two passes over replayable documents.
+
+    The input must support a fresh iteration for each n-gram size. Documents
+    may be read from disk on each pass; this function never collects them.
+    """
+
+    from nltk.collocations import (
+        BigramAssocMeasures,
+        BigramCollocationFinder,
+        TrigramAssocMeasures,
+        TrigramCollocationFinder,
+    )
+
+    bigram_finder = BigramCollocationFinder.from_documents(word_sequences)
+    bigram_finder.apply_freq_filter(MIN_NGRAM_FREQUENCY)
+    accepted_bigrams = frozenset(
+        bigram_finder.nbest(BigramAssocMeasures().pmi, NGRAM_CANDIDATE_LIMIT)[
+            NGRAM_HEAD_SKIP:
+        ]
+    )
+    del bigram_finder
+
+    trigram_finder = TrigramCollocationFinder.from_documents(word_sequences)
+    trigram_finder.apply_freq_filter(MIN_NGRAM_FREQUENCY)
+    accepted_trigrams = frozenset(
+        trigram_finder.nbest(TrigramAssocMeasures().pmi, NGRAM_CANDIDATE_LIMIT)[
+            NGRAM_HEAD_SKIP:
+        ]
+    )
+    return accepted_bigrams, accepted_trigrams
+
+
+def prepare_wikigood_ru_nlp(
+    pages: Iterable[ExtractedWikiPage],
+    categories_by_page_id: Mapping[int, Sequence[str]],
+) -> tuple[
+    tuple[WikiGoodRuDocument, ...],
+    frozenset[tuple[str, str]],
+    frozenset[tuple[str, str, str]],
+]:
+    """Lemmatize extracted pages and select independent PMI n-gram sets."""
+
+    lemmatize = create_wikigood_ru_lemmatizer()
+    documents = tuple(
+        WikiGoodRuDocument(
+            page_id=page.page_id,
+            canonical_title=page.canonical_title,
+            revision_id=page.revision_id,
+            title_tokens=lemmatize(page.canonical_title),
+            word_tokens=lemmatize(page.raw_text),
+            categories=tuple(categories_by_page_id[page.page_id]),
+            wikitext_sha256=page.wikitext_sha256,
+            raw_text_sha256=page.raw_text_sha256,
+        )
+        for page in sorted(pages, key=lambda item: item.page_id)
+    )
+    word_sequences = tuple(document.word_tokens for document in documents)
+
+    accepted_bigrams, accepted_trigrams = select_wikigood_ru_ngrams(
+        word_sequences
+    )
+    return documents, accepted_bigrams, accepted_trigrams

preprocessing/_wikigood/wikigood_ru_vw.py

@@ -0,0 +1,996 @@
+"""Deterministic Vowpal Wabbit artifacts for the RU-only WikiGood dataset."""
+
+from __future__ import annotations
+
+from collections import Counter
+from contextlib import ExitStack
+import ctypes
+import csv
+from dataclasses import dataclass
+import errno
+import gzip
+from io import TextIOWrapper
+import os
+from pathlib import Path
+import re
+import secrets
+import stat
+from typing import Collection, Iterable, Sequence
+
+
+SNAPSHOT = "20260801"
+QUALITY_FULL_SOURCE_SPEC_SHA256 = "7783a4597fdfde890a132895cb7ba87d63f86d973a2fe91d7b9e411653d1117d"
+MODALITIES = ("@title", "@word", "@bigram", "@trigram", "@category")
+CORE_MODEL_MODALITIES = ("@word",)
+PROVENANCE_FIELDS = (
+    "id",
+    "page_id",
+    "canonical_title",
+    "revision_id",
+    "source_url",
+    "wikitext_sha256",
+    "raw_text_sha256",
+)
+NOOW_FILENAME = f"wikigood_ru_{SNAPSHOT}_noow.txt"
+BOW_FILENAME = f"wikigood_ru_{SNAPSHOT}_bow.txt"
+PROVENANCE_FILENAME = f"wikigood_ru_{SNAPSHOT}_provenance.csv"
+OUTPUT_FILENAMES = (
+    NOOW_FILENAME,
+    f"{NOOW_FILENAME}.gz",
+    BOW_FILENAME,
+    f"{BOW_FILENAME}.gz",
+    PROVENANCE_FILENAME,
+)
+
+_SHA256 = re.compile(r"[0-9a-f]{64}\Z")
+_VW_RESERVED = frozenset("%|:")
+_GZIP_COMPRESSION_LEVEL = 9
+_RENAME_NOREPLACE = 1
+
+
+@dataclass(frozen=True, slots=True)
+class WikiGoodRuDocument:
+    """Processed document plus content hashes retained for provenance."""
+
+    page_id: int
+    canonical_title: str
+    revision_id: int
+    title_tokens: Sequence[str]
+    word_tokens: Sequence[str]
+    categories: Sequence[str]
+    wikitext_sha256: str
+    raw_text_sha256: str
+
+
+def format_wikigood_ru_vw_row(
+    document_id: str,
+    document: WikiGoodRuDocument,
+    *,
+    accepted_bigrams: Collection[tuple[str, str]],
+    accepted_trigrams: Collection[tuple[str, str, str]],
+    topics: Iterable[str] | None = None,
+    bow: bool = False,
+) -> str:
+    """Format one row without a newline, optionally appending distinct topics."""
+
+    modalities = _document_modalities(
+        document, accepted_bigrams, accepted_trigrams
+    )
+    if topics is not None:
+        modalities += (
+            ("@topic", tuple(_escape_vw(topic) for topic in dict.fromkeys(topics))),
+        )
+    formatter = _format_bow if bow else _format_noow
+    return formatter(document_id, modalities).removesuffix("\n")
+
+
+def write_wikigood_ru_artifacts(
+    documents: Iterable[WikiGoodRuDocument],
+    output_dir: str | Path,
+    *,
+    accepted_bigrams: Collection[tuple[str, str]],
+    accepted_trigrams: Collection[tuple[str, str, str]],
+) -> tuple[Path, ...]:
+    """Write new-only NOOW, BOW, gzip, and provenance artifacts.
+
+    The NLP stage remains outside this module: title and word sequences must
+    already be lemmatized, while categories are direct visible category titles.
+    Only ``@word`` is eligible for core modeling; the other modalities are
+    publication artifacts.
+    """
+
+    target = Path(output_dir)
+    ordered = tuple(sorted(documents, key=lambda document: document.page_id))
+    bigrams = _validated_ngrams(accepted_bigrams, 2)
+    trigrams = _validated_ngrams(accepted_trigrams, 3)
+    _validate_documents(ordered)
+    (
+        parent_descriptor,
+        staging_name,
+        staging_descriptor,
+        staging_identity,
+    ) = _create_owned_output_directory(target)
+    owned_identities: dict[str, tuple[int, int]] = {}
+    try:
+        _write_wikigood_ru_artifacts_at(
+            ordered,
+            staging_descriptor,
+            accepted_bigrams=bigrams,
+            accepted_trigrams=trigrams,
+            owned_identities=owned_identities,
+        )
+        os.fchmod(staging_descriptor, 0o755)
+        os.fsync(staging_descriptor)
+        _require_owned_identities(staging_descriptor, owned_identities)
+        _publish_owned_output_directory(
+            target,
+            parent_descriptor,
+            staging_name,
+            staging_descriptor,
+            staging_identity,
+        )
+    except BaseException:
+        _clean_owned_files(staging_descriptor, owned_identities)
+        _remove_owned_output_directory(
+            parent_descriptor, staging_name, staging_identity
+        )
+        _remove_owned_output_directory(
+            parent_descriptor, target.name, staging_identity
+        )
+        raise
+    finally:
+        os.close(staging_descriptor)
+        os.close(parent_descriptor)
+    return tuple(target / name for name in OUTPUT_FILENAMES)
+
+
+def _write_wikigood_ru_artifacts_at(
+    documents: Iterable[WikiGoodRuDocument],
+    directory_descriptor: int,
+    *,
+    accepted_bigrams: Collection[tuple[str, str]],
+    accepted_trigrams: Collection[tuple[str, str, str]],
+    owned_identities: dict[str, tuple[int, int]],
+) -> None:
+    """Write artifacts into a caller-owned unpublished directory."""
+
+    bigrams = _validated_ngrams(accepted_bigrams, 2)
+    trigrams = _validated_ngrams(accepted_trigrams, 3)
+    ordered = tuple(sorted(documents, key=lambda document: document.page_id))
+    _validate_documents(ordered)
+    try:
+        with ExitStack() as stack:
+            noow = stack.enter_context(
+                os.fdopen(
+                    _create_owned_file(
+                        directory_descriptor, NOOW_FILENAME, owned_identities
+                    ),
+                    "w",
+                    encoding="utf-8",
+                    newline="\n",
+                )
+            )
+            bow = stack.enter_context(
+                os.fdopen(
+                    _create_owned_file(
+                        directory_descriptor, BOW_FILENAME, owned_identities
+                    ),
+                    "w",
+                    encoding="utf-8",
+                    newline="\n",
+                )
+            )
+            provenance = stack.enter_context(
+                os.fdopen(
+                    _create_owned_file(
+                        directory_descriptor, PROVENANCE_FILENAME, owned_identities
+                    ),
+                    "w",
+                    encoding="utf-8",
+                    newline="",
+                )
+            )
+            noow_gzip_file = stack.enter_context(
+                os.fdopen(
+                    _create_owned_file(
+                        directory_descriptor,
+                        f"{NOOW_FILENAME}.gz",
+                        owned_identities,
+                    ),
+                    "wb",
+                )
+            )
+            bow_gzip_file = stack.enter_context(
+                os.fdopen(
+                    _create_owned_file(
+                        directory_descriptor,
+                        f"{BOW_FILENAME}.gz",
+                        owned_identities,
+                    ),
+                    "wb",
+                )
+            )
+            noow_gzip = stack.enter_context(
+                TextIOWrapper(
+                    gzip.GzipFile(
+                        filename="",
+                        mode="wb",
+                        fileobj=noow_gzip_file,
+                        compresslevel=_GZIP_COMPRESSION_LEVEL,
+                        mtime=0,
+                    ),
+                    encoding="utf-8",
+                    newline="\n",
+                )
+            )
+            bow_gzip = stack.enter_context(
+                TextIOWrapper(
+                    gzip.GzipFile(
+                        filename="",
+                        mode="wb",
+                        fileobj=bow_gzip_file,
+                        compresslevel=_GZIP_COMPRESSION_LEVEL,
+                        mtime=0,
+                    ),
+                    encoding="utf-8",
+                    newline="\n",
+                )
+            )
+            provenance_writer = csv.DictWriter(
+                provenance, fieldnames=PROVENANCE_FIELDS, lineterminator="\n"
+            )
+            provenance_writer.writeheader()
+            for document in ordered:
+                modalities = _document_modalities(document, bigrams, trigrams)
+                document_id = _document_id(document.page_id)
+                noow_line = _format_noow(document_id, modalities)
+                bow_line = _format_bow(document_id, modalities)
+                noow.write(noow_line)
+                noow_gzip.write(noow_line)
+                bow.write(bow_line)
+                bow_gzip.write(bow_line)
+                provenance_writer.writerow(
+                    {
+                        "id": document_id,
+                        "page_id": document.page_id,
+                        "canonical_title": document.canonical_title,
+                        "revision_id": document.revision_id,
+                        "source_url": (
+                            "https://ru.wikipedia.org/?curid=" f"{document.page_id}"
+                        ),
+                        "wikitext_sha256": document.wikitext_sha256,
+                        "raw_text_sha256": document.raw_text_sha256,
+                    }
+                )
+        for name, identity in owned_identities.items():
+            descriptor = os.open(
+                name,
+                os.O_RDONLY | os.O_NOFOLLOW,
+                dir_fd=directory_descriptor,
+            )
+            try:
+                if _descriptor_identity(descriptor) != identity:
+                    raise ValueError(f"output artifact identity mismatch: {name}")
+                os.fsync(descriptor)
+            finally:
+                os.close(descriptor)
+        _require_owned_identities(directory_descriptor, owned_identities)
+    except BaseException:
+        _clean_owned_files(directory_descriptor, owned_identities)
+        raise
+
+
+def _validated_ngrams(
+    ngrams: Collection[tuple[str, ...]], expected_size: int
+) -> frozenset[tuple[str, ...]]:
+    validated = set()
+    for ngram in ngrams:
+        if len(ngram) != expected_size:
+            raise ValueError(f"expected a {expected_size}-gram, got {ngram!r}")
+        for token in ngram:
+            _validate_token(token)
+        validated.add(tuple(ngram))
+    return frozenset(validated)
+
+
+def _validate_documents(documents: Sequence[WikiGoodRuDocument]) -> None:
+    page_ids = set()
+    for document in documents:
+        if (
+            isinstance(document.page_id, bool)
+            or not isinstance(document.page_id, int)
+            or document.page_id <= 0
+        ):
+            raise ValueError(f"invalid page ID: {document.page_id!r}")
+        if document.page_id in page_ids:
+            raise ValueError(f"duplicate document ID: {_document_id(document.page_id)}")
+        page_ids.add(document.page_id)
+        if (
+            isinstance(document.revision_id, bool)
+            or not isinstance(document.revision_id, int)
+            or document.revision_id <= 0
+        ):
+            raise ValueError(f"invalid revision ID: {document.revision_id!r}")
+        if not isinstance(document.canonical_title, str) or not document.canonical_title:
+            raise ValueError("canonical title must be a non-empty string")
+        for token in (
+            *document.title_tokens,
+            *document.word_tokens,
+            *document.categories,
+        ):
+            _validate_token(token)
+        for digest in (document.wikitext_sha256, document.raw_text_sha256):
+            if not isinstance(digest, str) or _SHA256.fullmatch(digest) is None:
+                raise ValueError(f"invalid SHA-256 digest: {digest!r}")
+
+
+def _validate_token(token: object) -> None:
+    if not isinstance(token, str) or not token:
+        raise ValueError(f"VW tokens must be non-empty strings: {token!r}")
+    try:
+        token.encode("utf-8")
+    except UnicodeEncodeError as error:
+        raise ValueError(f"VW token is not valid UTF-8 text: {token!r}") from error
+
+
+def _document_modalities(
+    document: WikiGoodRuDocument,
+    accepted_bigrams: Collection[tuple[str, ...]],
+    accepted_trigrams: Collection[tuple[str, ...]],
+) -> tuple[tuple[str, tuple[str, ...]], ...]:
+    words = tuple(document.word_tokens)
+    bigrams = tuple(
+        _escape_ngram(ngram)
+        for ngram in zip(words, words[1:])
+        if ngram in accepted_bigrams
+    )
+    trigrams = tuple(
+        _escape_ngram(ngram)
+        for ngram in zip(words, words[1:], words[2:])
+        if ngram in accepted_trigrams
+    )
+    return (
+        ("@title", tuple(_escape_vw(value) for value in document.title_tokens)),
+        ("@word", tuple(_escape_vw(value) for value in words)),
+        ("@bigram", bigrams),
+        ("@trigram", trigrams),
+        ("@category", tuple(_escape_vw(value) for value in document.categories)),
+    )
+
+
+def _format_noow(
+    document_id: str, modalities: Sequence[tuple[str, Sequence[str]]]
+) -> str:
+    fields = [_escape_vw(document_id)]
+    for name, tokens in modalities:
+        fields.append(f"|{name}")
+        fields.extend(tokens)
+    return " ".join(fields) + "\n"
+
+
+def _format_bow(
+    document_id: str, modalities: Sequence[tuple[str, Sequence[str]]]
+) -> str:
+    fields = [_escape_vw(document_id)]
+    for name, tokens in modalities:
+        fields.append(f"|{name}")
+        counts = Counter(tokens)
+        fields.extend(f"{token}:{counts[token]}" for token in sorted(counts))
+    return " ".join(fields) + "\n"
+
+
+def _document_id(page_id: int) -> str:
+    return f"wikigood-ru/{page_id}"
+
+
+def _escape_ngram(ngram: Sequence[str]) -> str:
+    return "_".join(_escape_vw(token, extra_reserved="_") for token in ngram)
+
+
+def _escape_vw(value: str, *, extra_reserved: str = "") -> str:
+    escaped = []
+    reserved = _VW_RESERVED | frozenset(extra_reserved)
+    for character in value:
+        if character in reserved or character.isspace() or not character.isprintable():
+            escaped.extend(f"%{byte:02X}" for byte in character.encode("utf-8"))
+        else:
+            escaped.append(character)
+    return "".join(escaped)
+
+
+def _create_owned_file(
+    directory_descriptor: int,
+    filename: str,
+    owned_identities: dict[str, tuple[int, int]],
+) -> int:
+    descriptor = os.open(
+        filename,
+        os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW,
+        0o644,
+        dir_fd=directory_descriptor,
+    )
+    owned_identities[filename] = _descriptor_identity(descriptor)
+    return descriptor
+
+
+def _create_owned_output_directory(
+    target: Path,
+) -> tuple[int, str, int, tuple[int, int]]:
+    parent = target.parent
+    parent_descriptor = os.open(
+        parent, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW
+    )
+    staging_name: str | None = None
+    staging_descriptor: int | None = None
+    preserve_staging = False
+    try:
+        _require_path_descriptor_identity(parent, parent_descriptor)
+        try:
+            os.stat(target.name, dir_fd=parent_descriptor, follow_symlinks=False)
+        except FileNotFoundError:
+            pass
+        else:
+            raise FileExistsError(f"output path already exists: {target}")
+
+        for _ in range(128):
+            staging_name = f".{target.name}.{secrets.token_hex(8)}.tmp"
+            try:
+                os.mkdir(staging_name, mode=0o700, dir_fd=parent_descriptor)
+            except FileExistsError:
+                staging_name = None
+                continue
+            staging_descriptor = os.open(
+                staging_name,
+                os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW,
+                dir_fd=parent_descriptor,
+            )
+            staging_identity = _descriptor_identity(staging_descriptor)
+            if _entry_has_identity(
+                parent_descriptor, staging_name, staging_identity
+            ):
+                return (
+                    parent_descriptor,
+                    staging_name,
+                    staging_descriptor,
+                    staging_identity,
+                )
+            preserve_staging = True
+            raise ValueError("owned output staging identity changed")
+        raise FileExistsError("could not allocate owned output staging directory")
+    except BaseException:
+        if staging_descriptor is not None:
+            os.close(staging_descriptor)
+        if staging_name is not None and not preserve_staging:
+            try:
+                os.rmdir(staging_name, dir_fd=parent_descriptor)
+            except OSError:
+                pass
+        os.close(parent_descriptor)
+        raise
+
+
+def _publish_owned_output_directory(
+    target: Path,
+    parent_descriptor: int,
+    staging_name: str,
+    staging_descriptor: int,
+    staging_identity: tuple[int, int],
+) -> None:
+    _require_path_descriptor_identity(target.parent, parent_descriptor)
+    if _descriptor_identity(staging_descriptor) != staging_identity or not (
+        _entry_has_identity(parent_descriptor, staging_name, staging_identity)
+    ):
+        raise ValueError("owned output staging identity changed")
+    _rename_noreplace(
+        parent_descriptor, staging_name, parent_descriptor, target.name
+    )
+    _require_path_descriptor_identity(target.parent, parent_descriptor)
+    if not _entry_has_identity(parent_descriptor, target.name, staging_identity):
+        raise ValueError("published output identity mismatch")
+    os.fsync(parent_descriptor)
+
+
+def _rename_noreplace(
+    source_directory_descriptor: int,
+    source_name: str,
+    target_directory_descriptor: int,
+    target_name: str,
+) -> None:
+    library = ctypes.CDLL(None, use_errno=True)
+    try:
+        renameat2 = library.renameat2
+    except AttributeError as error:
+        raise OSError(errno.ENOSYS, "renameat2 is unavailable") from error
+    renameat2.argtypes = (
+        ctypes.c_int,
+        ctypes.c_char_p,
+        ctypes.c_int,
+        ctypes.c_char_p,
+        ctypes.c_uint,
+    )
+    renameat2.restype = ctypes.c_int
+    if (
+        renameat2(
+            source_directory_descriptor,
+            os.fsencode(source_name),
+            target_directory_descriptor,
+            os.fsencode(target_name),
+            _RENAME_NOREPLACE,
+        )
+        != 0
+    ):
+        error_number = ctypes.get_errno()
+        if error_number == errno.EEXIST:
+            raise FileExistsError(
+                error_number,
+                f"output path already exists: {target_name}",
+                target_name,
+            )
+        raise OSError(error_number, os.strerror(error_number), target_name)
+
+
+def _require_owned_identities(
+    directory_descriptor: int,
+    owned_identities: dict[str, tuple[int, int]],
+) -> None:
+    for name, identity in owned_identities.items():
+        if not _entry_has_identity(directory_descriptor, name, identity):
+            raise ValueError(f"output artifact identity mismatch: {name}")
+
+
+def _clean_owned_files(
+    directory_descriptor: int,
+    owned_identities: dict[str, tuple[int, int]],
+) -> None:
+    for name, identity in owned_identities.items():
+        if _entry_has_identity(directory_descriptor, name, identity):
+            os.unlink(name, dir_fd=directory_descriptor)
+
+
+def _remove_owned_output_directory(
+    parent_descriptor: int,
+    staging_name: str,
+    staging_identity: tuple[int, int],
+) -> None:
+    if _entry_has_identity(parent_descriptor, staging_name, staging_identity):
+        try:
+            os.rmdir(staging_name, dir_fd=parent_descriptor)
+        except OSError:
+            pass
+
+
+def _entry_has_identity(
+    directory_descriptor: int, name: str, identity: tuple[int, int]
+) -> bool:
+    try:
+        state = os.stat(
+            name, dir_fd=directory_descriptor, follow_symlinks=False
+        )
+    except OSError:
+        return False
+    return (state.st_dev, state.st_ino) == identity
+
+
+def _require_path_descriptor_identity(path: Path, descriptor: int) -> None:
+    try:
+        state = os.stat(path, follow_symlinks=False)
+    except OSError as error:
+        raise ValueError(f"directory identity changed: {path}") from error
+    if not stat.S_ISDIR(state.st_mode) or not os.path.samestat(
+        state, os.fstat(descriptor)
+    ):
+        raise ValueError(f"directory identity changed: {path}")
+
+
+def _descriptor_identity(descriptor: int) -> tuple[int, int]:
+    state = os.fstat(descriptor)
+    return state.st_dev, state.st_ino
+
+
+# The full-quality corpus is separate from the historical VW publication contract.
+QUALITY_FULL_FILENAMES = (
+    "articles.jsonl.gz", "categories.jsonl.gz", "manifest.json", "SHA256SUMS", "README.md",
+)
+_QUALITY_POLICY = {
+    "Википедия:Добротные_статьи_по_алфавиту": "recommended",
+    "Википедия:Хорошие_статьи_по_алфавиту": "good",
+    "Википедия:Избранные_статьи_по_алфавиту": "featured",
+}
+_FORMER_QUALITY = {
+    "Википедия:Лишённые_статуса_добротной",
+    "Википедия:Лишённые_статуса_хорошей",
+    "Википедия:Устаревшие_избранные_статьи",
+}
+_QUALITY_METADATA_FIELDS = {
+    "page_id", "title", "metadata_revision_id", "wikidata_id", "quality_statuses",
+    "categories", "former_quality_categories",
+}
+_QUALITY_ARTICLE_FIELDS = _QUALITY_METADATA_FIELDS | {
+    "id", "revision_id", "revision_timestamp", "wikitext", "raw_text",
+    "wikitext_sha256", "raw_text_sha256", "page_url", "revision_url",
+}
+_QUALITY_CATEGORY_FIELDS = {
+    "title", "page_id", "is_hidden", "is_redirect", "wikidata_id", "parents",
+}
+
+
+def _quality_json(value: object) -> bytes:
+    import json
+    return (json.dumps(value, ensure_ascii=False, sort_keys=True,
+                       separators=(",", ":"), allow_nan=False) + "\n").encode("utf-8")
+
+
+def _quality_digest(path: Path) -> str:
+    import hashlib
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for chunk in iter(lambda: stream.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _quality_string_list(value: object) -> bool:
+    return (type(value) is list and all(type(item) is str and item for item in value)
+            and value == sorted(set(value)))
+
+
+def _quality_qid(value: object) -> bool:
+    return value is None or (type(value) is str and re.fullmatch(r"Q[1-9][0-9]*", value) is not None)
+
+
+def _quality_categories(records: Iterable[dict]) -> dict[str, dict]:
+    catalog = {}
+    previous = ""
+    page_ids = set()
+    for row in records:
+        if type(row) is not dict or set(row) != _QUALITY_CATEGORY_FIELDS:
+            raise ValueError("invalid category schema")
+        title = row["title"]
+        if type(title) is not str or not title or title <= previous:
+            raise ValueError("category titles must be strictly ordered")
+        previous = title
+        page_id = row["page_id"]
+        if not _quality_qid(row["wikidata_id"]) or not _quality_string_list(row["parents"]):
+            raise ValueError("invalid category QID or parents")
+        if page_id is None:
+            if any(row[key] is not None for key in ("is_hidden", "is_redirect", "wikidata_id")) or row["parents"]:
+                raise ValueError("redlink category has page metadata")
+        elif (type(page_id) is not int or page_id <= 0 or page_id in page_ids
+              or type(row["is_hidden"]) is not bool or type(row["is_redirect"]) is not bool):
+            raise ValueError("invalid category identity or flags")
+        if page_id is not None:
+            page_ids.add(page_id)
+        catalog[title] = row
+    if any(title not in catalog or catalog[title]["page_id"] is None or catalog[title]["is_redirect"]
+           for title in _QUALITY_POLICY):
+        raise ValueError("active quality category missing or redirected")
+    if not catalog or any(parent not in catalog for row in catalog.values() for parent in row["parents"]):
+        raise ValueError("empty catalog or missing parent category")
+    return catalog
+
+
+def _quality_article(row: dict, catalog: dict, previous: int) -> None:
+    import hashlib
+    from datetime import datetime
+    if type(row) is not dict or set(row) != _QUALITY_ARTICLE_FIELDS:
+        raise ValueError("invalid article schema")
+    page_id = row["page_id"]
+    if (type(page_id) is not int or page_id <= previous or row["id"] != f"ruwiki/{page_id}"
+            or type(row["title"]) is not str or not row["title"] or "_" in row["title"]):
+        raise ValueError("invalid article identity or ordering")
+    for key in ("revision_id", "metadata_revision_id"):
+        if type(row[key]) is not int or row[key] <= 0:
+            raise ValueError("invalid article revision")
+    timestamp = row["revision_timestamp"]
+    if type(timestamp) is not str or re.fullmatch(r"\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z", timestamp) is None:
+        raise ValueError("invalid revision timestamp")
+    datetime.strptime(timestamp, "%Y-%m-%dT%H:%M:%SZ")
+    if (not _quality_qid(row["wikidata_id"]) or not _quality_string_list(row["categories"])
+            or not _quality_string_list(row["quality_statuses"])
+            or not _quality_string_list(row["former_quality_categories"])):
+        raise ValueError("invalid article metadata types")
+    if any(title not in catalog for title in row["categories"]):
+        raise ValueError("article category absent from catalog")
+    expected_statuses = sorted(_QUALITY_POLICY[title] for title in row["categories"] if title in _QUALITY_POLICY)
+    if not expected_statuses or row["quality_statuses"] != expected_statuses:
+        raise ValueError("quality statuses disagree with active categories")
+    if row["former_quality_categories"] != sorted(set(row["categories"]) & _FORMER_QUALITY):
+        raise ValueError("former category metadata mismatch")
+    for field in ("wikitext", "raw_text"):
+        if type(row[field]) is not str or row[field + "_sha256"] != hashlib.sha256(row[field].encode("utf-8")).hexdigest():
+            raise ValueError("article text hash mismatch")
+    if (row["page_url"] != f"https://ru.wikipedia.org/?curid={page_id}"
+            or row["revision_url"] != f"https://ru.wikipedia.org/w/index.php?oldid={row['revision_id']}"):
+        raise ValueError("article URL mismatch")
+
+
+def _quality_provenance(provenance: dict) -> None:
+    import hashlib
+    import json
+    if type(provenance) is not dict or set(provenance) != {
+        "sources", "code", "parser", "runtime", "selected_roster", "resources",
+    }:
+        raise ValueError("invalid provenance schema")
+    spec_path = Path(__file__).resolve().parents[1] / "specs" / "wikipedia-quality-full-20261001.json"
+    spec_bytes = spec_path.read_bytes()
+    if hashlib.sha256(spec_bytes).hexdigest() != QUALITY_FULL_SOURCE_SPEC_SHA256:
+        raise ValueError("approved source specification changed")
+    spec = json.loads(spec_bytes)
+    sources = provenance["sources"]
+    if type(sources) is not dict or any(sources.get(key) != spec[key] or type(sources.get(key)) is not type(spec[key]) for key in ("schema_version", "profile", "snapshot", "total_download_bytes")):
+        raise ValueError("source profile mismatch")
+    if sources.get("source_spec_sha256") != hashlib.sha256(spec_bytes).hexdigest():
+        raise ValueError("source specification hash mismatch")
+    expected_source_keys = set(spec) | {"source_spec_sha256", "manifest_sha256"}
+    if set(sources) != expected_source_keys:
+        raise ValueError("source manifest schema mismatch")
+    unsealed = {key: value for key, value in sources.items() if key != "manifest_sha256"}
+    if sources["manifest_sha256"] != hashlib.sha256(_quality_json(unsealed).rstrip(b"\n")).hexdigest():
+        raise ValueError("source manifest seal mismatch")
+    files = sources.get("files")
+    if type(files) is not list or len(files) != len(spec["files"]):
+        raise ValueError("source inventory mismatch")
+    for actual, expected in zip(files, spec["files"]):
+        if (type(actual) is not dict or set(actual) != set(expected) | {"sha256"} or any(actual.get(key) != value or type(actual[key]) is not type(value) for key, value in expected.items())
+                or type(actual.get("sha256")) is not str or _SHA256.fullmatch(actual["sha256"]) is None):
+            raise ValueError("source identity mismatch")
+    for key, fields in (("code", {"commit", "dirty"}), ("parser", {"name", "version"}), ("runtime", {"python"})):
+        value = provenance[key]
+        if type(value) is not dict or set(value) != fields:
+            raise ValueError(f"invalid {key} schema")
+        if any(type(item) is not str or not item for name, item in value.items() if name != "dirty"):
+            raise ValueError(f"invalid {key} value")
+    if type(provenance["code"]["dirty"]) is not bool:
+        raise ValueError("invalid code dirty flag")
+    resources = provenance["resources"]
+    if type(resources) is not dict or not {"wall_seconds", "max_rss_bytes", "observed_scratch_peak_bytes"} <= resources.keys():
+        raise ValueError("missing resource observations")
+    for key in ("wall_seconds", "max_rss_bytes", "observed_scratch_peak_bytes"):
+        value = resources[key]
+        if type(value) not in (int, float) or value < 0 or not __import__("math").isfinite(value):
+            raise ValueError("invalid resource observation")
+    if type(provenance["selected_roster"]) is not list or not provenance["selected_roster"]:
+        raise ValueError("empty selected SQL roster")
+
+
+def _quality_summary(records: Iterable[dict], catalog: dict, roster: list, emit=None) -> dict:
+    previous = 0
+    category_page_ids = {row["page_id"] for row in catalog.values()}
+    status_counts = Counter({status: 0 for status in _QUALITY_POLICY.values()})
+    text_counts = {name: Counter() for name in ("wikitext_sha256", "raw_text_sha256")}
+    differences = []
+    links = 0
+    count = 0
+    for count, row in enumerate(records, 1):
+        _quality_article(row, catalog, previous)
+        previous = row["page_id"]
+        if previous in category_page_ids:
+            raise ValueError("article identity overlaps category namespace")
+        metadata = {key: row[key] for key in _QUALITY_METADATA_FIELDS}
+        if count > len(roster) or _quality_json(metadata) != _quality_json(roster[count - 1]):
+            raise ValueError("article does not match exact selected SQL roster")
+        status_counts.update(row["quality_statuses"])
+        links += len(row["categories"])
+        if row["revision_id"] != row["metadata_revision_id"]:
+            differences.append(row["page_id"])
+        for key, counter in text_counts.items():
+            counter[row[key]] += 1
+        if emit is not None:
+            emit(_quality_json(row))
+    if count != len(roster):
+        raise ValueError("incomplete selected SQL roster")
+    return {
+        "counts": {"articles": count, "categories": len(catalog),
+                   "category_redlinks": sum(row["page_id"] is None for row in catalog.values()),
+                   "category_parent_links": sum(len(row["parents"]) for row in catalog.values()),
+                   "direct_category_links": links, "quality_status_supports": dict(status_counts)},
+        "revision_differences": {"count": len(differences), "page_ids": differences},
+        "duplicates": {key: {"groups": sum(n > 1 for n in counts.values()),
+                             "extra_articles": sum(n - 1 for n in counts.values())}
+                       for key, counts in text_counts.items()},
+    }
+
+
+def _quality_readme() -> bytes:
+    return """---
+language: ru
+license: cc-by-sa-4.0
+pretty_name: Russian Wikipedia quality articles (20261001)
+configs:
+- config_name: articles
+  data_files:
+  - split: corpus
+    path: articles.jsonl.gz
+- config_name: categories
+  data_files:
+  - split: corpus
+    path: categories.jsonl.gz
+---
+# Russian Wikipedia quality articles
+
+This corpus contains the union of active recommended (добротные), good (хорошие),
+and featured (избранные) Russian Wikipedia articles from the 20261001 dump.
+Multiple active statuses are retained. Former status categories are historical
+metadata and do not exclude an article with an active status. Selection includes
+namespace-0 articles and excludes redirects and disambiguation pages.
+
+Each article has a stable ruwiki/<page_id> ID, separate title, original decoded
+wikitext, extracted raw_text, SHA-256 text hashes, optional Wikidata ID, quality
+statuses, all direct categories, XML revision ID and timestamp, SQL
+metadata_revision_id, and page/revision URLs. XML defines the content revision;
+SQL and XML revisions can differ. Repeated text across distinct IDs is retained.
+Readable extraction is not HTML rendering or full template expansion; templates,
+tables, references, formatting and other markup can be lost or simplified.
+
+Category names preserve SQL spelling (underscores); article titles use spaces.
+Join article categories and category parents to categories.jsonl.gz by title.
+The catalog includes all category pages, hidden and redirect flags, optional QIDs,
+parent links and redlinks. Redlinks have null page ID, flags and QID and no parents.
+Cycles are retained. No subject taxonomy, NLP, train/test research splits, sampling
+or deduplication is applied. The corpus partition is only a Hugging Face data
+partition and does not define research splits.
+
+Load the local package without a dataset script:
+
+```python
+from datasets import load_dataset
+articles = load_dataset("json", data_files={"corpus": "articles.jsonl.gz"})
+categories = load_dataset("json", data_files={"corpus": "categories.jsonl.gz"})
+```
+
+For a future Hugging Face publication, use the articles or categories configuration
+and its corpus partition. The manifest records exact source identities, SQL roster,
+code/parser/runtime versions, counts and measured resource observations. SHA256SUMS
+checks every other package file. Verification without an independently trusted
+manifest SHA-256 checks internal consistency only. Self-hashes cannot establish
+the authenticity of text, metadata or provenance after a package is resealed.
+Supply the manifest SHA-256 recorded separately in the trusted build log to bind
+verification to that build's manifest and its payload hashes. Keep this anchor
+outside the package; computing it from the package being verified gives no
+independent evidence. The builder separately checks SQL selection and a bounded
+XML content/provenance sample.
+
+Verify with the project CLI and the SHA-256 from the trusted build log:
+
+```sh
+python work/wintra/experiments/run_wikigood_ru_preprocessing.py --profile quality-full --action verify --output-dir /path/to/package --expected-manifest-sha256 TRUSTED_BUILD_MANIFEST_SHA256
+```
+
+Text is attributed to Russian Wikipedia contributors and distributed under
+[CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/). Each revision_url
+pins the attributed revision; page_url provides access to page history and authors.
+Observe attribution and share-alike requirements when redistributing adaptations;
+third-party material can have additional terms. Future preparation uses the project
+CLI run_wikigood_ru_preprocessing.py --profile quality-full with explicit source,
+output and scratch directories. No Hugging Face repository is created automatically.
+""".encode("utf-8")
+
+
+def write_wikigood_ru_quality_full_package(
+    articles: Iterable[dict], categories: Iterable[dict], output_dir: str | Path,
+    *, provenance: dict,
+) -> dict:
+    """Publish a fresh full-quality package; inputs are already normalized records.
+
+    Articles must be ordered by numeric page ID and categories by exact SQL title.
+    Provenance includes sources, code, parser, runtime, selected_roster and resources.
+    Return the manifest. No extraction or NLP is performed here.
+    """
+    import hashlib
+    _quality_provenance(provenance)
+    catalog = _quality_categories(categories)
+    target = Path(output_dir)
+    for path in (target, *target.parents):
+        if path.is_symlink():
+            raise ValueError("symlink package path")
+    parent_fd, staging_name, staging_fd, identity = _create_owned_output_directory(target)
+    owned = {}
+    hashes = {}
+    try:
+        for filename, rows in (("articles.jsonl.gz", articles), ("categories.jsonl.gz", catalog.values())):
+            fd = _create_owned_file(staging_fd, filename, owned)
+            with os.fdopen(fd, "wb") as raw:
+                with gzip.GzipFile(filename="", mode="wb", fileobj=raw, mtime=0, compresslevel=9) as zipped:
+                    if filename == "articles.jsonl.gz":
+                        summary = _quality_summary(rows, catalog, provenance["selected_roster"], zipped.write)
+                    else:
+                        for row in rows:
+                            zipped.write(_quality_json(row))
+                raw.flush()
+                os.fsync(raw.fileno())
+            hashes[filename] = _quality_digest(target.parent / staging_name / filename)
+        manifest = {"schema_version": 1, "profile": "quality-full", "snapshot": "20261001",
+                    "quality_policy": _QUALITY_POLICY, "provenance": provenance, **summary,
+                    "payload_sha256": dict(hashes)}
+        for filename, data in (("manifest.json", _quality_json(manifest)), ("README.md", _quality_readme())):
+            with os.fdopen(_create_owned_file(staging_fd, filename, owned), "wb") as stream:
+                stream.write(data)
+                stream.flush()
+                os.fsync(stream.fileno())
+            hashes[filename] = hashlib.sha256(data).hexdigest()
+        checksums = "".join(f"{hashes[name]}  {name}\n" for name in sorted(hashes)).encode("ascii")
+        with os.fdopen(_create_owned_file(staging_fd, "SHA256SUMS", owned), "wb") as stream:
+            stream.write(checksums)
+            stream.flush()
+            os.fsync(stream.fileno())
+        _require_owned_identities(staging_fd, owned)
+        os.fchmod(staging_fd, 0o755)
+        os.fsync(staging_fd)
+        _publish_owned_output_directory(target, parent_fd, staging_name, staging_fd, identity)
+    except BaseException:
+        _clean_owned_files(staging_fd, owned)
+        _remove_owned_output_directory(parent_fd, staging_name, identity)
+        _remove_owned_output_directory(parent_fd, target.name, identity)
+        raise
+    finally:
+        os.close(staging_fd)
+        os.close(parent_fd)
+    return manifest
+
+
+def verify_wikigood_ru_quality_full_package(
+    output_dir: str | Path, *, expected_manifest_sha256: str | None = None,
+) -> dict:
+    """Read-only structural/hash verification, without extraction, NLP or rebuild.
+
+    Without an external anchor, verification establishes internal consistency only;
+    self-hashes cannot authenticate text, metadata or provenance after resealing.
+    Supply a lowercase SHA-256 from an independently trusted build log to require
+    that exact manifest and its payload hashes before trusting manifest fields.
+    The builder separately checks SQL selection and a bounded XML content sample.
+    """
+    import hashlib
+    import json
+    if expected_manifest_sha256 is not None and (
+        type(expected_manifest_sha256) is not str
+        or _SHA256.fullmatch(expected_manifest_sha256) is None
+    ):
+        raise ValueError("expected manifest SHA-256 must be 64 lowercase hex characters")
+    target = Path(output_dir)
+    for path in (target, *target.parents):
+        if path.is_symlink():
+            raise ValueError("symlink package path")
+    if not target.is_dir() or set(path.name for path in target.iterdir()) != set(QUALITY_FULL_FILENAMES):
+        raise ValueError("package inventory mismatch")
+    for name in QUALITY_FULL_FILENAMES:
+        if not stat.S_ISREG((target / name).lstat().st_mode):
+            raise ValueError("nonregular package file")
+    checksums = "".join(f"{_quality_digest(target / name)}  {name}\n"
+                        for name in sorted(set(QUALITY_FULL_FILENAMES) - {"SHA256SUMS"}))
+    if (target / "SHA256SUMS").read_bytes() != checksums.encode("ascii"):
+        raise ValueError("package checksum mismatch")
+    manifest_bytes = (target / "manifest.json").read_bytes()
+    if (expected_manifest_sha256 is not None
+            and hashlib.sha256(manifest_bytes).hexdigest() != expected_manifest_sha256):
+        raise ValueError("manifest SHA-256 does not match trusted anchor")
+    manifest = json.loads(manifest_bytes)
+    if type(manifest) is not dict or manifest_bytes != _quality_json(manifest) or set(manifest) != {
+        "schema_version", "profile", "snapshot", "quality_policy", "provenance", "counts",
+        "revision_differences", "duplicates", "payload_sha256",
+    }:
+        raise ValueError("manifest schema or serialization mismatch")
+    if (_quality_json({key: manifest[key] for key in ("schema_version", "profile", "snapshot", "quality_policy")})
+            != _quality_json({"schema_version": 1, "profile": "quality-full", "snapshot": "20261001", "quality_policy": _QUALITY_POLICY})):
+        raise ValueError("package policy mismatch")
+    _quality_provenance(manifest["provenance"])
+    if (target / "README.md").read_bytes() != _quality_readme():
+        raise ValueError("package README mismatch")
+    catalog = _quality_categories(_quality_rows(target / "categories.jsonl.gz"))
+    summary = _quality_summary(_quality_rows(target / "articles.jsonl.gz"), catalog,
+                               manifest["provenance"]["selected_roster"])
+    if _quality_json(summary) != _quality_json({key: manifest[key] for key in summary}):
+        raise ValueError("package summary mismatch")
+    expected_hashes = {name: _quality_digest(target / name) for name in ("articles.jsonl.gz", "categories.jsonl.gz")}
+    if manifest["payload_sha256"] != expected_hashes:
+        raise ValueError("payload hash mismatch")
+    return manifest
+
+
+def _quality_rows(path: Path) -> Iterable[dict]:
+    import json
+    with gzip.open(path, "rb") as stream:
+        for line in stream:
+            row = json.loads(line)
+            if line != _quality_json(row):
+                raise ValueError("noncanonical JSONL record")
+            yield row

preprocessing/conda-linux-64.lock.txt

@@ -0,0 +1,37 @@
+# This file may be used to create an environment using:
+# $ conda create --name <env> --file <this file>
+# platform: linux-64
+# created-by: conda 26.3.2
+@EXPLICIT
+https://repo.anaconda.com/pkgs/main/linux-64/_libgcc_mutex-0.1-main.conda
+https://repo.anaconda.com/pkgs/main/linux-64/_openmp_mutex-5.1-52_gnu.conda
+https://repo.anaconda.com/pkgs/main/linux-64/ca-certificates-2026.8.13-h06a4308_0.conda
+https://repo.anaconda.com/pkgs/main/linux-64/ld_impl_linux-64-2.44-h9e0c5a2_3.conda
+https://repo.anaconda.com/pkgs/main/noarch/tzdata-2026c-he532380_0.conda
+https://repo.anaconda.com/pkgs/main/linux-64/libgcc-15.2.0-h69a1729_8.conda
+https://repo.anaconda.com/pkgs/main/linux-64/libgcc-ng-15.2.0-h166f726_8.conda
+https://repo.anaconda.com/pkgs/main/linux-64/libstdcxx-15.2.0-h39759b7_8.conda
+https://repo.anaconda.com/pkgs/main/linux-64/libzlib-1.3.2-h47b2149_0.conda
+https://repo.anaconda.com/pkgs/main/linux-64/openssl-3.5.7-h1b28b03_0.conda
+https://repo.anaconda.com/pkgs/main/linux-64/pthread-stubs-0.3-h47b2149_2.conda
+https://repo.anaconda.com/pkgs/main/linux-64/xorg-xorgproto-2025.1-h47b2149_0.conda
+https://repo.anaconda.com/pkgs/main/linux-64/xz-5.8.2-h448239c_0.conda
+https://repo.anaconda.com/pkgs/main/linux-64/bzip2-1.0.8-h5eee18b_6.conda
+https://repo.anaconda.com/pkgs/main/linux-64/libexpat-2.8.2-h7354ed3_1.conda
+https://repo.anaconda.com/pkgs/main/linux-64/libffi-3.4.8-h06d3fd0_3.conda
+https://repo.anaconda.com/pkgs/main/linux-64/libnsl-2.0.0-h5eee18b_0.conda
+https://repo.anaconda.com/pkgs/main/linux-64/libuuid-1.41.5-h5eee18b_0.conda
+https://repo.anaconda.com/pkgs/main/linux-64/ncurses-6.6-hfaaeb4e_0.conda
+https://repo.anaconda.com/pkgs/main/linux-64/xorg-libxau-1.0.12-h9b100fa_0.conda
+https://repo.anaconda.com/pkgs/main/linux-64/xorg-libxdmcp-1.1.5-h9b100fa_0.conda
+https://repo.anaconda.com/pkgs/main/linux-64/zlib-1.3.2-h47b2149_0.conda
+https://repo.anaconda.com/pkgs/main/linux-64/libxcb-1.17.0-h9b100fa_0.conda
+https://repo.anaconda.com/pkgs/main/linux-64/readline-8.3-hc2a1206_0.conda
+https://repo.anaconda.com/pkgs/main/linux-64/sqlite-3.53.2-h795bf6d_0.conda
+https://repo.anaconda.com/pkgs/main/linux-64/xorg-libx11-1.8.13-h65de747_0.conda
+https://repo.anaconda.com/pkgs/main/linux-64/tk-8.6.15-h54e0aa7_0.conda
+https://repo.anaconda.com/pkgs/main/linux-64/python-3.11.15-h17756b0_1.conda
+https://repo.anaconda.com/pkgs/main/linux-64/packaging-26.3-py311h06a4308_0.conda
+https://repo.anaconda.com/pkgs/main/linux-64/setuptools-83.0.0-py311h06a4308_0.conda
+https://repo.anaconda.com/pkgs/main/linux-64/wheel-0.47.0-py311h06a4308_0.conda
+https://repo.anaconda.com/pkgs/main/noarch/pip-26.2.1-pyhc872135_0.conda

preprocessing/pip-linux-x86_64.lock.txt

@@ -0,0 +1,54 @@
+annotated-doc==0.0.5
+annotated-types==0.8.0
+anyio==4.14.2
+blis==1.3.3
+catalogue==2.0.10
+certifi==2026.7.22
+charset-normalizer==3.5.1
+click==8.5.0
+cloudpathlib==0.25.0
+confection==1.3.3
+cymem==2.0.13
+DAWG2-Python==0.9.0
+h11==0.16.0
+httpcore==1.0.9
+httpx==0.28.1
+idna==3.19
+iterative-stratification==0.1.9
+Jinja2==3.1.6
+joblib==1.5.3
+markdown-it-py==4.2.0
+MarkupSafe==3.0.3
+mdurl==0.1.2
+murmurhash==1.0.15
+mwparserfromhell==0.7.2
+narwhals==2.25.0
+nltk==3.9.2
+numpy==2.4.6
+preshed==3.0.13
+pydantic==2.13.5
+pydantic_core==2.46.5
+Pygments==2.21.0
+pymorphy3==2.0.6
+pymorphy3-dicts-ru==2.4.417150.4580142
+regex==2026.7.19
+requests==2.34.2
+rich==15.0.0
+scikit-learn==1.9.0
+scipy==1.17.1
+shellingham==1.5.4
+smart_open==8.0.1
+spacy==3.8.14
+spacy-legacy==3.0.12
+spacy-loggers==1.0.5
+srsly==2.5.3
+thinc==8.3.13
+threadpoolctl==3.6.0
+tqdm==4.70.0
+typer==0.27.2
+typing-inspection==0.4.4
+typing_extensions==4.16.0
+urllib3==2.7.0
+wasabi==1.1.3
+weasel==1.0.0
+wrapt==2.3.0

preprocessing/prepare.py

@@ -0,0 +1,10 @@
+"""Download, build or verify the pinned Russian Wikipedia NLP CSVs.
+
+Run ``python prepare.py --help`` for the portable workflow options.
+"""
+
+from _wikigood.wikigood_ru_csv import main
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

preprocessing/requirements.txt

@@ -0,0 +1,3 @@
+spacy==3.8.14
+pymorphy3==2.0.6
+nltk==3.9.2

preprocessing/wikipedia-quality-nlp-20261001.json

@@ -0,0 +1 @@
+{"csv_fields":["id","raw_text","vw_text"],"encoding":"UTF-8","full_namespaces":["@title","@word","@bigram","@trigram","@category"],"line_terminator":"LF","ngram":{"candidate_limit":32100,"head_skip":100,"minimum_frequency":5,"ranking":"PMI","selection":"independent per corpus; no document boundaries crossed"},"normalization":"shared common articles once; preserve all source IDs in numeric order","raw_text":"title + two LF + source raw_text stripped only of leading CR/LF","runtime":{"packages":{"nltk":"3.9.2","pymorphy3":"2.0.6","spacy":"3.8.14"},"python":"3.11.15"},"schema":"wikipedia-quality-nlp-20261001-v1","selected_namespaces":["@title","@word","@bigram","@trigram","@category","@topic"],"sources":{"full":{"articles":{"byte_size":409970311,"sha256":"c51f9b6bee4c85f25ffb861060f52490a9276bae289d2aa2db7e0d10e2dda950"},"count":17413,"repository":"TopicNet/RuWiki-Good-2026-V2","revision":"3c6bdb4ddc1be38b4fd63a480bdd056394a04934"},"selected":{"articles":{"byte_size":413342335,"sha256":"9eb7efffe99fc7c9bc3f4b3eb9f0378d91f387081f97cf9abea9c1686797c1ed"},"count":17251,"repository":"TopicNet/RuWiki-Good-2026-V2-Selected","revision":"fc1ad9b9491ab122614a95b3aa78b3cdfa5e3881","topics":{"byte_size":2671,"sha256":"c8cf602a924f18255e155cdcaa9357907461851e849113c72051c2b89484f22c"}}},"stopwords":{"byte_size":37733,"russian_sha256":"1743191192b4a4f77fcc216499455dc00c1b8626fdd407076a8deefff80e3d59","sha256":"48c0e52d8b52546e827f53761fb30300c0ab94f70660d28bd65ba0a86270946b","url":"https://raw.githubusercontent.com/nltk/nltk_data/550b6625bcef1f2abff2ff770a5a0d272c9c6b2a/packages/corpora/stopwords.zip"},"verification":"source binding and structural verification without morphology replay"}