add full preproc -- from dump

README.md

@@ -24,6 +24,19 @@ wikitext, extracted readable text, direct categories, quality status and revisio
 links. The category catalog supports inspection of direct membership and parent
 relationships; it is not a curated subject taxonomy.
 
+## Files at a glance
+
+| File | Purpose | Bytes |
+| --- | --- | ---: |
+| `data/articles.jsonl.gz` | Source article records, readable text and provenance. | 409,970,311 |
+| `data/categories.jsonl.gz` | Category catalog and direct parent relationships. | 22,459,573 |
+| `data/noow.csv` | Whole-document text and ordered normalized VW features. | 1,128,356,201 |
+| `data/bow.csv` | The same documents with counted VW features. | 883,080,852 |
+
+The reusable code, environment locks and source/output pins are in
+[preprocessing/](preprocessing/). [SHA256SUMS](SHA256SUMS) covers the published
+data and preparation files; see [file verification](#file-verification).
+
 ## Coverage and selection
 
 The corpus is the union of namespace-0 articles in these direct SQL categories:
@@ -47,7 +60,7 @@ NLP CSV files. There are no exact duplicate `wikitext` or `raw_text` values in t
 procedure does not remove records because they share text. The `corpus`
 partition is a storage partition, not a research split.
 
-## Loading
+## Quick start: load the published files
 
 The `articles` configuration is the default. `articles` and `categories` use
 compressed JSON Lines and the `corpus` split, with no dataset script.
@@ -106,6 +119,31 @@ bow = load_dataset(
 )
 ```
 
+CSV is the primary prepared format. The explicit `"csv"` builder above is
+required: these files are not additional YAML configurations, because combining
+JSON and CSV builders in one repository configuration did not load reliably.
+The published CSV files have been fully read with Hugging Face Datasets.
+
+To export one VW document per line without loading the CSV into memory, run this
+from the downloaded repository. Choose an output path outside the repository:
+
+```python
+import csv
+from pathlib import Path
+
+csv.field_size_limit(2**31 - 1)
+with Path("data/noow.csv").open(encoding="utf-8", newline="") as source:
+    with Path("../RuWiki-Good-2026-V2-noow.vw").open("w", encoding="utf-8", newline="") as output:
+        for row in csv.DictReader(source):
+            output.write(row["vw_text"] + "\n")
+```
+
+The field-size setting is needed only for Python's standard `csv` reader;
+it does not configure Hugging Face Datasets. Use `bow.csv` in the same example
+for counted features. CSV records contain whole documents and may include
+embedded newlines in `raw_text`, so splitting the CSV by physical lines is unsafe.
+The repository does not store a second permanent copy as VW text files.
+
 The NLP preparation section describes the normalized namespaces and text fields.
 
 ## Article fields
@@ -193,18 +231,10 @@ the stored format:
 ## Sources and revision semantics
 
 The source is the [Russian Wikipedia 20261001 dump](https://dumps.wikimedia.org/ruwiki/20261001/).
-The exact source files are listed below with their SHA-256 digests. Dump mirrors
-may later remove this dated snapshot; the filenames and digests identify the
-inputs independently of their continued availability.
-
-| File | SHA-256 |
-| --- | --- |
-| `ruwiki-20261001-page.sql.gz` | `24250cca6122fff02896a1ced0a85b7afa4d6be00fa119c169a5eeef3fbe5830` |
-| `ruwiki-20261001-page_props.sql.gz` | `fc9d5aeaf3487d932b82d18a16bc96f0e4e4702e1149cbbdc482eb509f6deb60` |
-| `ruwiki-20261001-categorylinks.sql.gz` | `1ecb32ffaff28a120b6a8f4297d4b228b65c49beb593eae022b5811ae41512e1` |
-| `ruwiki-20261001-linktarget.sql.gz` | `bc1f24b7b8eb06298cbe70fdfb010ec023586d05bd2d3403ba2370091e1edc4a` |
-| `ruwiki-20261001-pages-articles-multistream.xml.bz2` | `c22b6441176d2bc572ed6883abc6292fe168efca211f6cdd61d8772a78492a1b` |
-| `ruwiki-20261001-pages-articles-multistream-index.txt.bz2` | `17c6a4cebb90ecb2b0f881e04aa3b49356bd6ee6add802a7201b9ca1a9b093e3` |
+The [source and output pins](preprocessing/wikipedia-quality-corpus-20261001.json) record the names, byte sizes and SHA-256 digests of all six
+inputs: page, page properties, category links and link targets SQL dumps, plus the
+multistream article XML and its index. Dump mirrors may later remove this dated
+snapshot; the pins identify the inputs independently of their availability.
 
 SQL provides selection, titles, page properties and category relationships. XML
 provides article content, `revision_id` and `revision_timestamp`. **11 articles**
@@ -228,7 +258,8 @@ 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.
+readable body alone. Standard CSV quoting preserves embedded newlines; one whole-document row can
+span many physical lines.
 
 `vw_text` uses Vowpal Wabbit namespaces in this order:
 
@@ -260,62 +291,136 @@ separately selected n-gram vocabularies. These CSVs are not a claim of evaluatio
 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:
+### Rebuild NLP CSVs from ready article snapshots
+
+Run from the parent directory containing the downloaded `RuWiki-Good-2026-V2`
+and `RuWiki-Good-2026-V2-Selected` repositories. Working files go under a separate
+`ruwiki-rebuild` directory. Choose fresh output and scratch paths on a disk with
+enough space; corpus output and scratch inside a published clone are rejected.
+Python 3.11.15 is the pinned
+runtime for both build and verify: VW escaping depends on its Unicode database.
+On Linux x86-64, use the supplied locks:
 
 ```bash
-conda create --name ruwiki-nlp --file conda-linux-64.lock.txt
+conda create --name ruwiki-nlp --file RuWiki-Good-2026-V2/preprocessing/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
+python -m pip install -r RuWiki-Good-2026-V2/preprocessing/pip-linux-x86_64.lock.txt
+python RuWiki-Good-2026-V2/preprocessing/prepare.py --help
+python RuWiki-Good-2026-V2/preprocessing/prepare.py --stage nlp --action download --dataset both --sources-dir ./ruwiki-rebuild/nlp-sources
+python RuWiki-Good-2026-V2/preprocessing/prepare.py --stage nlp --action build --dataset both --sources-dir ./ruwiki-rebuild/nlp-sources --output-dir ./ruwiki-rebuild/nlp-output --scratch-dir ./ruwiki-rebuild/nlp-scratch
+python RuWiki-Good-2026-V2/preprocessing/prepare.py --stage nlp --action verify --dataset both --sources-dir ./ruwiki-rebuild/nlp-sources --output-dir ./ruwiki-rebuild/nlp-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.
+`--stage nlp` is the default, so earlier commands without `--stage` continue to
+work. Choose `--dataset full`, `selected` or `both`. The
+[pinned NLP contract](preprocessing/wikipedia-quality-nlp-20261001.json) records
+source revisions, source payload hashes and runtime requirements. The
+[corpus contract](preprocessing/wikipedia-quality-corpus-20261001.json) additionally
+pins the expected published NLP output bytes.
+`requirements.txt` lists direct dependencies, including `mwparserfromhell==0.7.2`
+for corpus extraction. The locks retain the complete environment used for NLP;
+no downloaded spaCy language model is needed. If installing only the direct
+requirements in a separate environment, retain Python 3.11.15.
+
+Download checks existing source files against their pins, fetches missing files,
+and acquires the pinned NLTK archive at
+`./ruwiki-rebuild/nlp-sources/nltk_data/corpora/stopwords.zip`. To reuse downloaded JSONL files,
+place them at `./ruwiki-rebuild/nlp-sources/full/articles.jsonl.gz`,
+`./ruwiki-rebuild/nlp-sources/selected/articles.jsonl.gz` and
+`./ruwiki-rebuild/nlp-sources/selected/topics.jsonl.gz` before running download. This step creates
+the local NLTK resource directory; no pre-existing `nltk_data` is required.
+Use `--nltk-data` to select a different local NLTK resource directory.
+
+Hugging Face downloads use anonymous Python `urllib`. For restricted repositories,
+fetch the pinned files with authenticated tools, place them at the paths above,
+and rerun download. The script does not handle authentication tokens.
+Build runs offline, checks runtime versions and Russian stopword content, and
+writes `./ruwiki-rebuild/nlp-output/full` and `./ruwiki-rebuild/nlp-output/selected`. Keep outputs and scratch
+separate from published data and use a fresh scratch directory for a new build.
+Progress messages identify phases and document counts. Each build manifest
+records counts and ordered IDs of documents with an empty `@word` namespace;
+those articles remain in the output.
+
+Verification needs no NLP packages. It checks source identities, output hashes
+against the build manifest, schemas, source text and NOOW/BOW token-count
+agreement. The shared entry point then independently checks the generated CSVs
+and Selected labels against published byte sizes and SHA-256 pins in the corpus
+contract, reporting `PUBLISHED_NLP_OK` on success. These expectations are separate
+from the newly generated manifest. Verification does not rerun tokenization,
+lemmatization or PMI selection.
+
+A measured build of both NLP collections from the ready JSONL snapshots took
+**42 min 5.83 s**, with **10.58 GiB** peak resident memory, approximately
+**3.74 GiB** of final output and **0.53 GiB** of scratch files. These measurements
+exclude raw dump downloads and corpus reconstruction; they are an example from
+one environment, not a bound for other machines.
 
 Load a generated CSV directly:
 
 ```python
 noow = load_dataset(
-    "csv", data_files={"corpus": "output/full/noow.csv"}, split="corpus"
+    "csv", data_files={"corpus": "./ruwiki-rebuild/nlp-output/full/noow.csv"}, split="corpus"
 )
 bow = load_dataset(
-    "csv", data_files={"corpus": "output/full/bow.csv"}, split="corpus"
+    "csv", data_files={"corpus": "./ruwiki-rebuild/nlp-output/full/bow.csv"}, split="corpus"
 )
 ```
 
+## Rebuild the corpus from Wikimedia dumps
+
+The same entry point supports `--stage corpus`, with `download`, `build` and
+`verify` actions. The [corpus contract](preprocessing/wikipedia-quality-corpus-20261001.json)
+pins the six 20261001 dump files, the published article/category payloads and the
+retained Selected annotations. This public raw-dump replay has **not yet been run
+end to end**. Its download time, build time and peak disk and memory requirements
+have not been measured; the NLP measurements above do not describe this stage.
+
+The example below runs from the parent of both downloaded repository directories,
+as in the NLP commands above.
+The Selected annotation directory must already contain `labels.json` and
+`topics.jsonl.gz`. These retained mappings reproduce the published subject
+assignments; the script does not rerun AI labeling.
+
+```bash
+python RuWiki-Good-2026-V2/preprocessing/prepare.py --stage corpus --action download --dataset both --sources-dir ./ruwiki-rebuild/dump-sources
+# Resume an interrupted dump download explicitly:
+python RuWiki-Good-2026-V2/preprocessing/prepare.py --stage corpus --action download --dataset both --sources-dir ./ruwiki-rebuild/dump-sources --resume
+python RuWiki-Good-2026-V2/preprocessing/prepare.py --stage corpus --action build --dataset both --sources-dir ./ruwiki-rebuild/dump-sources --annotations-dir RuWiki-Good-2026-V2-Selected/data --output-dir ./ruwiki-rebuild/corpus-output --scratch-dir ./ruwiki-rebuild/corpus-scratch
+python RuWiki-Good-2026-V2/preprocessing/prepare.py --stage corpus --action verify --dataset both --sources-dir ./ruwiki-rebuild/dump-sources --output-dir ./ruwiki-rebuild/corpus-output
+```
+
+Download stores and checks the six pinned files beneath `--sources-dir`.
+After all files are present, build is offline. It reconstructs SQL metadata,
+selects qualifying article IDs, extracts the indexed XML revisions, and applies
+the readable-text cleanup. It writes `./ruwiki-rebuild/corpus-output/full/articles.jsonl.gz` and
+`categories.jsonl.gz`, plus `./ruwiki-rebuild/corpus-output/selected/articles.jsonl.gz` and
+`topics.jsonl.gz`. Use separate fresh output and scratch directories, leaving
+published `data/` untouched. Corpus verification compares outputs with the
+independently bundled expected published payloads, rather than trusting hashes
+newly written by the build itself.
+
+For Full only, set `--dataset full` and omit `--annotations-dir`. Selected can
+also be reconstructed from a previously accepted Full corpus without rereading
+the dumps. From the same working directory:
+
+```bash
+python RuWiki-Good-2026-V2/preprocessing/prepare.py --stage corpus --action build --dataset selected --sources-dir RuWiki-Good-2026-V2/data --full-dir RuWiki-Good-2026-V2/data --annotations-dir RuWiki-Good-2026-V2-Selected/data --output-dir ./ruwiki-rebuild/selected-output --scratch-dir ./ruwiki-rebuild/selected-scratch
+python RuWiki-Good-2026-V2/preprocessing/prepare.py --stage corpus --action verify --dataset selected --sources-dir RuWiki-Good-2026-V2/data --output-dir ./ruwiki-rebuild/selected-output
+```
+
+This Selected-only workflow has been verified byte for byte against the published
+archive of all 17,251 articles, the labels file and the topic definitions.
+
+To continue from reconstructed JSONL to NLP, the corpus output root is directly
+usable as `--sources-dir`. Download then supplies the pinned NLTK archive before
+the offline NLP build:
+
+```bash
+python RuWiki-Good-2026-V2/preprocessing/prepare.py --stage nlp --action download --dataset both --sources-dir ./ruwiki-rebuild/corpus-output
+python RuWiki-Good-2026-V2/preprocessing/prepare.py --stage nlp --action build --dataset both --sources-dir ./ruwiki-rebuild/corpus-output --output-dir ./ruwiki-rebuild/replay-nlp-output --scratch-dir ./ruwiki-rebuild/replay-nlp-scratch
+python RuWiki-Good-2026-V2/preprocessing/prepare.py --stage nlp --action verify --dataset both --sources-dir ./ruwiki-rebuild/corpus-output --output-dir ./ruwiki-rebuild/replay-nlp-output
+```
+
 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.
@@ -343,11 +448,18 @@ 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 verification
+
+From the root of the downloaded repository, verify the distributed data and
+preparation files with:
+
+```bash
+sha256sum -c SHA256SUMS
+```
 
-| 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` |
+[SHA256SUMS](SHA256SUMS) lists those files without embedding long digests in this
+card. It excludes this README and Git/service metadata. The corpus and NLP
+contracts in `preprocessing/` pin source inputs, while the corpus contract also
+pins expected published corpus and NLP payloads independently of a new build. A successful checksum check establishes
+agreement with the supplied manifest; use a trusted repository revision when
+establishing provenance.

SHA256SUMS

@@ -0,0 +1,19 @@
+c51f9b6bee4c85f25ffb861060f52490a9276bae289d2aa2db7e0d10e2dda950  data/articles.jsonl.gz
+a45edd3e9287009e353c0f3ffc4404ffadc393293dada691e2d275a0bc0d2f5d  data/bow.csv
+d07ab1e6c07da28cc162d786853a73c54e300289e21bcc6667c4072158abdf8f  data/categories.jsonl.gz
+041250c048b0441cc88d516b92e1d65c0f80db3c82b400b7ae6b9db379c2ed33  data/noow.csv
+40e9e59aaa72c85612fb13c1a31726062309c6a33c858b99d485d54986d360a3  preprocessing/LICENSE
+b12783fbca1588a57b983032b8eb1534b6d107b1ecfc0633c9f03040d24c6bdf  preprocessing/_wikigood/__init__.py
+996e564b0a96eb8427c77356f6c0f87ba5f09b6cce63629edac807da253be92c  preprocessing/_wikigood/wiki_metadata.py
+af48d12c9d7c5a7560004863790881b0483bc9e26838de4a737fe8d14f71ba56  preprocessing/_wikigood/wikigood_ru_content.py
+8ca18e1ad52b1e83cf0221c87773643033402f666ee03b1a7473b7a0c77c6a55  preprocessing/_wikigood/wikigood_ru_corpus.py
+9a8ea2f173cb81462bd66fb1342d958a48d1add97fea1651db40aa571e153081  preprocessing/_wikigood/wikigood_ru_csv.py
+d3b04973b735f805164a5ff6dd8c631e523440d1e9d52597a6a314aa888a1f32  preprocessing/_wikigood/wikigood_ru_nlp.py
+ffa062b071e7dbbd4ab1254ba752157df3da8518be7a586f685e5449c5e9c4a7  preprocessing/_wikigood/wikigood_ru_quality_metadata.py
+a1066fd916fb254e3971e505c57c1e6bbc037c74b218f19a3ecd1e83ed4077a4  preprocessing/_wikigood/wikigood_ru_vw.py
+d6d1374d3ea144edc3fd5285ba87dac4daa9dea2857d0f165c6d0943a69a43fc  preprocessing/conda-linux-64.lock.txt
+48ed6fcf0bfdcd15ed76b6f62b136890c6beb3a9e7af9615d88b1f6c457acac9  preprocessing/pip-linux-x86_64.lock.txt
+816ab241f6bef38406a35b0b05c1046f210b98fbaa2c9e88e8af3c6d92687f3c  preprocessing/prepare.py
+cc61d5ba11e0521ecfdf9ea818415aaf4b70c1522c9902b99ac271efdf61c5b1  preprocessing/requirements.txt
+baed2546050747c3bedf6eb34db1953e530f99fefe7b9b129d1612631c2ab845  preprocessing/wikipedia-quality-corpus-20261001.json
+f109106d65e960376a3acfeb0fc116c05fcc2e0965af35b1353600edf5355a47  preprocessing/wikipedia-quality-nlp-20261001.json

preprocessing/_wikigood/wiki_metadata.py

@@ -0,0 +1,1567 @@
+"""Streaming readers and indexes for Wikimedia metadata SQL dumps."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping as MappingABC, Set as SetABC
+from contextlib import contextmanager
+from dataclasses import dataclass
+from itertools import chain
+import os
+from pathlib import Path
+import re
+import sqlite3
+import stat
+import threading
+from typing import Iterable, Iterator, Mapping, TypeAlias
+from uuid import uuid4
+
+
+SqlValue: TypeAlias = str | int | float | None
+_Token: TypeAlias = tuple[str, SqlValue]
+
+_INTEGER = re.compile(r"[+-]?\d+\Z")
+_FLOAT = re.compile(
+    r"[+-]?(?:\d+\.\d*|\.\d+|\d+)(?:[eE][+-]?\d+)?\Z"
+)
+_MYSQL_ESCAPES = {
+    "0": "\0",
+    "b": "\b",
+    "n": "\n",
+    "r": "\r",
+    "t": "\t",
+    "Z": "\x1a",
+    "\\": "\\",
+    "'": "'",
+    '"': '"',
+}
+_SCHEMA_PREFIX_LIMIT = 1024 * 1024
+_SQLITE_BATCH_SIZE = 500
+_TEMP_DIRECTORY_LOCK = threading.Lock()
+
+_PAGE_COLUMNS = ((0, "page_id"), (1, "page_namespace"), (2, "page_title"))
+_PAGE_METADATA_COLUMNS = (
+    (0, "page_id"),
+    (1, "page_namespace"),
+    (2, "page_title"),
+    (4, "page_is_redirect"),
+    (9, "page_latest"),
+)
+_PAGE_PROPS_COLUMNS = ((0, "pp_page"), (1, "pp_propname"), (2, "pp_value"))
+_LINKTARGET_COLUMNS = ((0, "lt_id"), (1, "lt_namespace"), (2, "lt_title"))
+_CATEGORYLINKS_COLUMNS = (
+    (0, "cl_from"),
+    (1, "cl_sortkey"),
+    (2, "cl_timestamp"),
+    (3, "cl_sortkey_prefix"),
+    (4, "cl_type"),
+    (5, "cl_collation_id"),
+    (6, "cl_target_id"),
+)
+
+
+class _MetadataIndexError(ValueError):
+    """SQLite indexing failure carrying observed temporary database bytes."""
+
+    def __init__(self, message: str, scratch_bytes: int) -> None:
+        super().__init__(message)
+        self.scratch_bytes = scratch_bytes
+
+
+class WikiMetadataScratch:
+    """POSIX-owned namespace for file-backed SQLite metadata indexes.
+
+    D-018 runs in one dedicated SQLite-exclusive process inside a private
+    attempt directory. Namespace mutation by another same-UID process is out of
+    scope. The pathname identity checks below only make an observed accidental
+    replacement non-destructive; pathname unlink/rmdir are not an atomic
+    ownership guarantee. ``temp_store_directory`` is process-global raw SQLite
+    state, protected here only by the in-process lock and the dedicated-process
+    assumption.
+    """
+
+    def __init__(self, parent: Path, ceiling_bytes: int) -> None:
+        if not _TEMP_DIRECTORY_LOCK.acquire(blocking=False):
+            raise RuntimeError("another SQLite scratch scope is already active")
+        self._closed = False
+        self.ceiling_bytes = ceiling_bytes
+        self.main_database_bytes = 0
+        self.observed_ephemeral_transient_high_water_bytes = 0
+        self.exceeded = False
+        self._databases: dict[str, tuple[int, str]] = {}
+        self._parent_fd: int | None = None
+        self._directory_fd: int | None = None
+        self._previous_temp_directory: str | None = None
+        self._pragma_changed = False
+        try:
+            self._parent_fd = os.open(
+                parent, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW
+            )
+            while True:
+                self._name = f".wikigood-sqlite-{uuid4().hex}"
+                try:
+                    os.mkdir(self._name, mode=0o700, dir_fd=self._parent_fd)
+                except FileExistsError:
+                    continue
+                break
+            self._directory_fd = os.open(
+                self._name,
+                os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW,
+                dir_fd=self._parent_fd,
+            )
+            namespace_stat = os.stat(
+                self._name, dir_fd=self._parent_fd, follow_symlinks=False
+            )
+            if not os.path.samestat(namespace_stat, os.fstat(self._directory_fd)):
+                raise FileExistsError(
+                    "SQLite scratch namespace was replaced before validation"
+                )
+            control = sqlite3.connect(":memory:")
+            try:
+                previous = control.execute("PRAGMA temp_store_directory").fetchone()
+                self._previous_temp_directory = previous[0] if previous else None
+                control.execute(
+                    f"PRAGMA temp_store_directory = '{self._proc_directory}'"
+                )
+                self._pragma_changed = True
+            finally:
+                control.close()
+        except BaseException as error:
+            try:
+                self.close()
+            except BaseException as cleanup_error:
+                error.add_note(f"SQLite scratch cleanup failed: {cleanup_error}")
+            raise
+
+    @property
+    def _proc_directory(self) -> str:
+        assert self._directory_fd is not None
+        return f"/proc/self/fd/{self._directory_fd}"
+
+    def _remove_empty_owned_namespace(self) -> None:
+        """Remove the namespace only while its pathname still identifies it."""
+
+        if self._parent_fd is None or self._directory_fd is None:
+            return
+        with os.scandir(self._directory_fd) as entries:
+            if any(entries):
+                return
+        try:
+            namespace_stat = os.stat(
+                self._name, dir_fd=self._parent_fd, follow_symlinks=False
+            )
+        except OSError:
+            return
+        if os.path.samestat(namespace_stat, os.fstat(self._directory_fd)):
+            try:
+                os.rmdir(self._name, dir_fd=self._parent_fd)
+            except OSError:
+                pass
+
+    def create_database(self, name: str) -> str:
+        """Reserve an exclusive database name inside the owned namespace."""
+
+        if Path(name).name != name:
+            raise ValueError("SQLite database name must be a basename")
+        if name in self._databases:
+            raise FileExistsError(f"SQLite database is already active: {name}")
+        backing_name = f".{name}.{uuid4().hex}.owned"
+        descriptor = os.open(
+            backing_name,
+            os.O_RDWR | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW,
+            0o600,
+            dir_fd=self._directory_fd,
+        )
+        try:
+            os.link(
+                backing_name,
+                name,
+                src_dir_fd=self._directory_fd,
+                dst_dir_fd=self._directory_fd,
+                follow_symlinks=False,
+            )
+            descriptor_stat = os.fstat(descriptor)
+            for path in (name, backing_name):
+                path_stat = os.stat(
+                    path, dir_fd=self._directory_fd, follow_symlinks=False
+                )
+                if not os.path.samestat(path_stat, descriptor_stat):
+                    raise FileExistsError(
+                        "SQLite database name was replaced before validation"
+                    )
+        except BaseException:
+            try:
+                for path in (name, backing_name):
+                    self._unlink_database_path(path, descriptor)
+            finally:
+                os.close(descriptor)
+            raise
+        self._databases[name] = descriptor, backing_name
+        return f"{self._proc_directory}/{backing_name}"
+
+    def release_database(self, name: str) -> None:
+        """Unlink a database name from the exclusively owned namespace."""
+
+        database = self._databases.pop(name, None)
+        if database is None:
+            return
+        descriptor, backing_name = database
+        try:
+            for path in (name, backing_name):
+                self._unlink_database_path(path, descriptor)
+        finally:
+            os.close(descriptor)
+
+    def _unlink_database_path(self, path: str, descriptor: int) -> None:
+        """Unlink one database path only while it names the held object."""
+
+        try:
+            path_stat = os.stat(
+                path, dir_fd=self._directory_fd, follow_symlinks=False
+            )
+        except FileNotFoundError:
+            return
+        if os.path.samestat(path_stat, os.fstat(descriptor)):
+            os.unlink(path, dir_fd=self._directory_fd)
+
+    def observe(self) -> int:
+        """Record one observed main/transient file-size snapshot.
+
+        Main database bytes are hard-capped by SQLite ``max_page_count``.
+        The transient high-water field retains sampled observations only;
+        progress callbacks cannot exclude a between-observation overshoot.
+        """
+
+        files: dict[tuple[int, int], int] = {}
+        for entry in os.scandir(self._directory_fd):
+            entry_stat = entry.stat(follow_symlinks=False)
+            if stat.S_ISREG(entry_stat.st_mode):
+                files[(entry_stat.st_dev, entry_stat.st_ino)] = entry_stat.st_size
+
+        directory_target = os.readlink(self._proc_directory).rstrip("/") + "/"
+        for descriptor_name in os.listdir("/proc/self/fd"):
+            descriptor_path = f"/proc/self/fd/{descriptor_name}"
+            try:
+                target = os.readlink(descriptor_path)
+                descriptor_stat = os.stat(descriptor_path)
+            except OSError:
+                continue
+            if target.startswith(directory_target) and stat.S_ISREG(
+                descriptor_stat.st_mode
+            ):
+                files[(descriptor_stat.st_dev, descriptor_stat.st_ino)] = (
+                    descriptor_stat.st_size
+                )
+
+        database_identities = {
+            (database_stat.st_dev, database_stat.st_ino)
+            for database_stat in (
+                os.fstat(descriptor)
+                for descriptor, _ in self._databases.values()
+            )
+        }
+        main_bytes = sum(
+            size for identity, size in files.items() if identity in database_identities
+        )
+        transient_bytes = sum(
+            size
+            for identity, size in files.items()
+            if identity not in database_identities
+        )
+        self.main_database_bytes = max(self.main_database_bytes, main_bytes)
+        self.observed_ephemeral_transient_high_water_bytes = max(
+            self.observed_ephemeral_transient_high_water_bytes, transient_bytes
+        )
+        actual_bytes = main_bytes + transient_bytes
+        if actual_bytes > self.ceiling_bytes:
+            self.exceeded = True
+            raise _MetadataIndexError(
+                "observed SQLite scratch bytes exceeded the "
+                f"{self.ceiling_bytes}-byte disk ceiling",
+                self.main_database_bytes,
+            )
+        return actual_bytes
+
+    def progress(self) -> int:
+        """Interrupt SQLite when observed scratch bytes cross the ceiling."""
+
+        try:
+            self.observe()
+        except _MetadataIndexError:
+            return 1
+        return 0
+
+    def close(self) -> None:
+        """Close namespace handles without deleting replacement objects."""
+
+        if self._closed:
+            return
+        self._closed = True
+        errors: list[BaseException] = []
+        try:
+            if self._pragma_changed:
+                try:
+                    control = sqlite3.connect(":memory:")
+                    try:
+                        temp_directory = (self._previous_temp_directory or "").replace(
+                            "'", "''"
+                        )
+                        control.execute(
+                            f"PRAGMA temp_store_directory = '{temp_directory}'"
+                        )
+                    finally:
+                        control.close()
+                except BaseException as error:
+                    errors.append(error)
+            for name in tuple(self._databases):
+                try:
+                    self.release_database(name)
+                except BaseException as error:
+                    errors.append(error)
+            try:
+                self._remove_empty_owned_namespace()
+            except BaseException as error:
+                errors.append(error)
+        finally:
+            for descriptor in (
+                self._directory_fd,
+                self._parent_fd,
+            ):
+                if descriptor is not None:
+                    try:
+                        os.close(descriptor)
+                    except BaseException as error:
+                        errors.append(error)
+            _TEMP_DIRECTORY_LOCK.release()
+        if errors:
+            raise errors[0]
+
+
+@contextmanager
+def open_metadata_scratch(
+    parent: Path, ceiling_bytes: int
+) -> Iterator[WikiMetadataScratch]:
+    """Yield one disk-backed SQLite namespace owned by a preflight attempt."""
+
+    scratch = WikiMetadataScratch(Path(parent), ceiling_bytes)
+    try:
+        yield scratch
+    except BaseException as error:
+        try:
+            scratch.close()
+        except BaseException as cleanup_error:
+            error.add_note(f"SQLite scratch cleanup failed: {cleanup_error}")
+        raise
+    else:
+        scratch.close()
+
+
+@dataclass(frozen=True, slots=True)
+class Page:
+    """Minimal record from the Wikimedia ``page`` table.
+
+    Parameters
+    ----------
+    page_id
+        Numeric page identifier.
+    namespace
+        Numeric MediaWiki namespace.
+    title
+        Database-form page title, without a namespace prefix.
+    is_redirect
+        Whether the page row is a redirect.
+    latest_revision_id
+        Identifier from ``page_latest`` when retained by the caller.
+    """
+
+    page_id: int
+    namespace: int
+    title: str
+    is_redirect: bool = False
+    latest_revision_id: int | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class PageProp:
+    """Minimal record from the Wikimedia ``page_props`` table.
+
+    Parameters
+    ----------
+    page_id
+        Identifier of the page carrying the property.
+    name
+        Property name.
+    value
+        Property value, or ``None`` for SQL ``NULL``.
+    """
+
+    page_id: int
+    name: str
+    value: str | None
+
+
+@dataclass(frozen=True, slots=True)
+class CategoryLink:
+    """Minimal record from the Wikimedia ``categorylinks`` table.
+
+    Parameters
+    ----------
+    source_page_id
+        Identifier of the page assigned to the category.
+    link_type
+        MediaWiki category link type.
+    target_id
+        Identifier of the target in the ``linktarget`` table.
+    """
+
+    source_page_id: int
+    link_type: str
+    target_id: int
+
+
+@dataclass(frozen=True, slots=True)
+class LinkTarget:
+    """Minimal record from the Wikimedia ``linktarget`` table.
+
+    Parameters
+    ----------
+    target_id
+        Numeric link-target identifier.
+    namespace
+        Numeric MediaWiki namespace of the target.
+    title
+        Database-form target title, without a namespace prefix.
+    """
+
+    target_id: int
+    namespace: int
+    title: str
+
+
+@dataclass(frozen=True, slots=True)
+class WikiMetadataIndexes:
+    """Indexes derived from Wikimedia metadata tables.
+
+    Parameters
+    ----------
+    category_title_to_id
+        Category titles mapped to category page identifiers.
+    category_id_to_title
+        Category page identifiers mapped to titles.
+    page_id_to_qid
+        Page identifiers mapped to Wikidata item identifiers.
+    hidden_category_ids
+        Category page identifiers carrying the ``hiddencat`` property.
+    category_parents
+        Category page identifiers mapped to their parent category identifiers.
+    article_categories
+        Namespace-0 page identifiers mapped to category page identifiers.
+    category_children
+        Category titles mapped lazily to direct subcategory titles.
+    category_title_to_qid
+        Category titles mapped lazily to Wikidata item identifiers.
+    """
+
+    category_title_to_id: Mapping[str, int]
+    category_id_to_title: Mapping[int, str]
+    page_id_to_qid: Mapping[int, str]
+    hidden_category_ids: SetABC[int]
+    category_parents: Mapping[int, tuple[int, ...]]
+    article_categories: Mapping[int, tuple[int, ...]]
+    category_children: Mapping[str, tuple[str, ...]]
+    category_title_to_qid: Mapping[str, str]
+    _connection: sqlite3.Connection
+    _scratch: WikiMetadataScratch | None
+    _database_name: str | None
+
+    @property
+    def scratch_bytes(self) -> int:
+        """Return allocated bytes in the temporary SQLite metadata index."""
+
+        if self._scratch is not None:
+            self._scratch.observe()
+            return self._scratch.main_database_bytes
+        return _database_bytes(self._connection)
+
+    def close(self) -> None:
+        """Close and remove the temporary SQLite metadata index."""
+
+        try:
+            self._connection.close()
+        finally:
+            if (
+                self._scratch is not None
+                and self._database_name is not None
+            ):
+                self._scratch.release_database(self._database_name)
+
+    def category_children_for(
+        self, titles: Iterable[str]
+    ) -> dict[str, tuple[str, ...]]:
+        """Return direct category children for bounded title batches."""
+
+        rows = _execute_in_batches(
+            self._connection,
+            "SELECT DISTINCT parent.title, child.title "
+            "FROM target AS parent "
+            "JOIN category_link AS link ON link.target_id = parent.target_id "
+            "JOIN page AS child ON child.page_id = link.source_page_id "
+            "WHERE parent.namespace = 14 AND child.namespace = 14 "
+            "AND parent.title IN ({}) "
+            "ORDER BY parent.title, child.title",
+            titles,
+        )
+        return _group_rows(rows)
+
+    def category_qids_for_titles(self, titles: Iterable[str]) -> dict[str, str]:
+        """Return title-to-QID pairs for bounded category title batches."""
+
+        return dict(
+            _execute_in_batches(
+                self._connection,
+                "SELECT page.title, property.value FROM page JOIN property "
+                "ON property.page_id = page.page_id "
+                "WHERE page.namespace = 14 AND property.name = 'wikibase_item' "
+                "AND page.title IN ({}) ORDER BY page.title",
+                titles,
+            )
+        )
+
+    def category_titles_for_qids(self, qids: Iterable[str]) -> dict[str, str]:
+        """Return localized category titles whose QIDs are requested."""
+
+        return {
+            title: qid
+            for title, qid in _execute_in_batches(
+                self._connection,
+                "SELECT page.title, property.value FROM page JOIN property "
+                "ON property.page_id = page.page_id "
+                "WHERE page.namespace = 14 AND property.name = 'wikibase_item' "
+                "AND property.value IN ({}) ORDER BY page.title",
+                qids,
+            )
+        }
+
+    def article_category_titles(
+        self, page_ids: Iterable[int]
+    ) -> dict[int, tuple[str, ...]]:
+        """Return direct category titles for bounded article batches."""
+
+        rows = _execute_in_batches(
+            self._connection,
+            "SELECT DISTINCT link.source_page_id, category.title "
+            "FROM resolved_category_link AS link "
+            "JOIN page AS category ON category.page_id = link.target_page_id "
+            "WHERE link.source_namespace = 0 AND link.source_page_id IN ({}) "
+            "ORDER BY link.source_page_id, category.title",
+            page_ids,
+        )
+        return _group_rows(rows)
+
+    def article_metadata(
+        self, page_ids: Iterable[int]
+    ) -> dict[int, tuple[str, int | None, bool]]:
+        """Return canonical title, latest revision, and redirect state."""
+
+        return {
+            page_id: (
+                title.replace("_", " "),
+                latest_revision_id,
+                bool(is_redirect),
+            )
+            for page_id, title, latest_revision_id, is_redirect in _execute_in_batches(
+                self._connection,
+                "SELECT page_id, title, latest_revision_id, is_redirect FROM page "
+                "WHERE namespace = 0 AND page_id IN ({}) ORDER BY page_id",
+                page_ids,
+            )
+        }
+
+    def article_category_target_titles(
+        self, page_ids: Iterable[int]
+    ) -> dict[int, tuple[str, ...]]:
+        """Return direct category-link titles, including category redlinks."""
+
+        rows = _execute_in_batches(
+            self._connection,
+            "SELECT DISTINCT link.source_page_id, target.title "
+            "FROM category_link AS link "
+            "JOIN page AS source ON source.page_id = link.source_page_id "
+            "JOIN target ON target.target_id = link.target_id "
+            "WHERE source.namespace = 0 AND target.namespace = 14 "
+            "AND link.source_page_id IN ({}) "
+            "ORDER BY link.source_page_id, target.title",
+            page_ids,
+        )
+        return _group_rows(rows)
+
+    def hidden_category_titles(self) -> frozenset[str]:
+        """Return titles of the explicitly marked hidden categories."""
+
+        return frozenset(
+            row[0]
+            for row in self._connection.execute(
+                "SELECT page.title FROM page JOIN property "
+                "ON property.page_id = page.page_id "
+                "WHERE page.namespace = 14 AND property.name = 'hiddencat' "
+                "ORDER BY page.title"
+            )
+        )
+
+    def redirect_category_titles(self) -> frozenset[str]:
+        """Return canonical titles of category redirect pages."""
+
+        return frozenset(
+            row[0]
+            for row in self._connection.execute(
+                "SELECT title FROM page WHERE namespace = 14 AND is_redirect = 1 "
+                "ORDER BY title"
+            )
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class QualityCategoryConfig:
+    """Caller-supplied quality and delisted category definitions.
+
+    Parameters
+    ----------
+    statuses_by_title
+        Category title to output status label. This can represent any language
+        edition without embedding language-specific titles in the library.
+    excluded_titles
+        Former or delisted category titles. Membership in any one of these
+        categories always excludes an article.
+    """
+
+    statuses_by_title: Mapping[str, str]
+    excluded_titles: frozenset[str]
+
+
+@dataclass(frozen=True, slots=True)
+class QualityArticle:
+    """A selected quality article and its configured statuses.
+
+    Parameters
+    ----------
+    page_id
+        Namespace-0 page identifier.
+    statuses
+        Sorted, unique configured status labels.
+    """
+
+    page_id: int
+    statuses: tuple[str, ...]
+
+
+class _SqliteScalarMapping(MappingABC):
+    """Read-only scalar mapping backed by a temporary SQLite database."""
+
+    def __init__(
+        self, connection: sqlite3.Connection, items_sql: str, value_sql: str
+    ) -> None:
+        self._connection = connection
+        self._items_sql = items_sql
+        self._value_sql = value_sql
+
+    def __iter__(self) -> Iterator[object]:
+        return (row[0] for row in self._connection.execute(self._items_sql))
+
+    def __len__(self) -> int:
+        return self._connection.execute(
+            f"SELECT COUNT(*) FROM ({self._items_sql})"
+        ).fetchone()[0]
+
+    def __getitem__(self, key: object) -> object:
+        row = self._connection.execute(self._value_sql, (key,)).fetchone()
+        if row is None:
+            raise KeyError(key)
+        return row[0]
+
+    def items(self) -> Iterator[tuple[object, object]]:
+        """Yield key-value pairs without materializing the mapping."""
+
+        return iter(self._connection.execute(self._items_sql))
+
+
+class _SqliteTupleMapping(MappingABC):
+    """Read-only one-to-many mapping backed by a SQLite query."""
+
+    def __init__(self, connection: sqlite3.Connection, pairs_sql: str) -> None:
+        self._connection = connection
+        self._pairs_sql = pairs_sql
+
+    def __iter__(self) -> Iterator[int]:
+        query = f"SELECT DISTINCT key FROM ({self._pairs_sql}) ORDER BY key"
+        return (row[0] for row in self._connection.execute(query))
+
+    def __len__(self) -> int:
+        query = f"SELECT COUNT(DISTINCT key) FROM ({self._pairs_sql})"
+        return self._connection.execute(query).fetchone()[0]
+
+    def __getitem__(self, key: object) -> tuple[int, ...]:
+        query = (
+            f"SELECT DISTINCT value FROM ({self._pairs_sql}) "
+            "WHERE key = ? ORDER BY value"
+        )
+        values = tuple(row[0] for row in self._connection.execute(query, (key,)))
+        if not values:
+            raise KeyError(key)
+        return values
+
+    def items(self) -> Iterator[tuple[int, tuple[int, ...]]]:
+        """Yield grouped membership pairs without materializing all groups."""
+
+        rows = self._connection.execute(
+            f"SELECT DISTINCT key, value FROM ({self._pairs_sql}) ORDER BY key, value"
+        )
+        current_key: object | None = None
+        values: list[object] = []
+        for key, value in rows:
+            if current_key is not None and key != current_key:
+                yield current_key, tuple(values)
+                values = []
+            current_key = key
+            values.append(value)
+        if current_key is not None:
+            yield current_key, tuple(values)
+
+
+class _SqliteSet(SetABC):
+    """Read-only set backed by a single-column SQLite query."""
+
+    def __init__(self, connection: sqlite3.Connection, values_sql: str) -> None:
+        self._connection = connection
+        self._values_sql = values_sql
+
+    def __contains__(self, value: object) -> bool:
+        query = f"SELECT 1 FROM ({self._values_sql}) WHERE page_id = ? LIMIT 1"
+        return self._connection.execute(query, (value,)).fetchone() is not None
+
+    def __iter__(self) -> Iterator[int]:
+        return (row[0] for row in self._connection.execute(self._values_sql))
+
+    def __len__(self) -> int:
+        return self._connection.execute(
+            f"SELECT COUNT(*) FROM ({self._values_sql})"
+        ).fetchone()[0]
+
+
+def _execute_in_batches(
+    connection: sqlite3.Connection,
+    query: str,
+    values: Iterable[object],
+) -> Iterator[tuple[object, ...]]:
+    """Execute an ``IN`` query over deterministic SQLite-sized batches."""
+
+    ordered = tuple(sorted(set(values)))
+    for offset in range(0, len(ordered), _SQLITE_BATCH_SIZE):
+        batch = ordered[offset : offset + _SQLITE_BATCH_SIZE]
+        placeholders = ", ".join("?" for _ in batch)
+        yield from connection.execute(query.format(placeholders), batch)
+
+
+def _group_rows(
+    rows: Iterable[tuple[object, object]],
+) -> dict[object, tuple[object, ...]]:
+    """Group already ordered key-value rows without retaining flat rows."""
+
+    grouped: dict[object, list[object]] = {}
+    for key, value in rows:
+        grouped.setdefault(key, []).append(value)
+    return {key: tuple(values) for key, values in grouped.items()}
+
+
+def iter_insert_rows(source: Iterable[str], table: str) -> Iterator[tuple[SqlValue, ...]]:
+    """Yield rows from ``INSERT INTO`` statements for one Wikimedia table.
+
+    The parser consumes the input incrementally and implements the MySQL string
+    escapes used by Wikimedia dumps. It does not load an INSERT statement into
+    memory as a whole.
+
+    Parameters
+    ----------
+    source
+        Text chunks or lines from an uncompressed SQL dump.
+    table
+        Exact table name to select.
+
+    Yields
+    ------
+    tuple of str, int, float, or None
+        Parsed SQL row values.
+
+    Raises
+    ------
+    ValueError
+        If a selected INSERT statement has malformed row syntax.
+    """
+
+    tokens = iter(_iter_tokens(source))
+    for kind, value in tokens:
+        if kind != "WORD" or str(value).upper() != "INSERT":
+            continue
+        into = next(tokens, None)
+        table_token = next(tokens, None)
+        values = next(tokens, None)
+        if (
+            into is None
+            or into[0] != "WORD"
+            or str(into[1]).upper() != "INTO"
+            or table_token is None
+            or table_token[0] not in {"WORD", "IDENT"}
+            or values is None
+            or values[0] != "WORD"
+            or str(values[1]).upper() != "VALUES"
+        ):
+            continue
+        if table_token[1] != table:
+            continue
+        yield from _iter_statement_rows(tokens)
+
+
+def iter_pages(source: Iterable[str]) -> Iterator[Page]:
+    """Yield normalized records from a Wikimedia ``page`` SQL dump.
+
+    Parameters
+    ----------
+    source
+        Text chunks or lines from the dump.
+
+    Yields
+    ------
+    Page
+        Page identifier, namespace, and title.
+    """
+
+    for row in _iter_validated_rows(
+        source, "page", _PAGE_COLUMNS, select_by_name=True
+    ):
+        if len(row) < 3:
+            raise ValueError(
+                f"page row has {len(row)} values; expected at least 3"
+            )
+        yield Page(int(row[0]), int(row[1]), str(row[2]))
+
+
+def iter_pages_with_metadata(source: Iterable[str]) -> Iterator[Page]:
+    """Yield pages with redirect state and latest revision metadata."""
+
+    for row in _iter_validated_rows(
+        source, "page", _PAGE_METADATA_COLUMNS, select_by_name=True
+    ):
+        is_redirect = row[3]
+        latest_revision_id = row[4]
+        if is_redirect not in {0, 1}:
+            raise ValueError(f"invalid page_is_redirect value: {is_redirect!r}")
+        if (
+            isinstance(latest_revision_id, bool)
+            or not isinstance(latest_revision_id, int)
+            or latest_revision_id <= 0
+        ):
+            latest_revision_id = None
+        yield Page(
+            int(row[0]),
+            int(row[1]),
+            str(row[2]),
+            bool(is_redirect),
+            latest_revision_id,
+        )
+
+
+def iter_page_props(source: Iterable[str]) -> Iterator[PageProp]:
+    """Yield normalized records from a Wikimedia ``page_props`` SQL dump.
+
+    Parameters
+    ----------
+    source
+        Text chunks or lines from the dump.
+
+    Yields
+    ------
+    PageProp
+        Page identifier, property name, and nullable value.
+    """
+
+    for row in _iter_validated_rows(source, "page_props", _PAGE_PROPS_COLUMNS):
+        if len(row) < 3:
+            raise ValueError(
+                f"page_props row has {len(row)} values; expected at least 3"
+            )
+        value = row[2]
+        yield PageProp(int(row[0]), str(row[1]), None if value is None else str(value))
+
+
+def iter_category_links(source: Iterable[str]) -> Iterator[CategoryLink]:
+    """Yield normalized records from a Wikimedia ``categorylinks`` SQL dump.
+
+    Parameters
+    ----------
+    source
+        Text chunks or lines from the dump.
+
+    Yields
+    ------
+    CategoryLink
+        Source page identifier, target category title, and optional link type.
+    """
+
+    for row in _iter_validated_rows(
+        source, "categorylinks", _CATEGORYLINKS_COLUMNS, exact=True
+    ):
+        if len(row) != 7:
+            raise ValueError(
+                f"categorylinks row has {len(row)} values; expected exactly 7"
+            )
+        yield CategoryLink(int(row[0]), str(row[4]), int(row[6]))
+
+
+def iter_link_targets(source: Iterable[str]) -> Iterator[LinkTarget]:
+    """Yield normalized records from a Wikimedia ``linktarget`` SQL dump.
+
+    Parameters
+    ----------
+    source
+        Text chunks or lines from the dump.
+
+    Yields
+    ------
+    LinkTarget
+        Link-target identifier, namespace, and title.
+    """
+
+    for row in _iter_validated_rows(
+        source, "linktarget", _LINKTARGET_COLUMNS, exact=True
+    ):
+        if len(row) != 3:
+            raise ValueError(
+                f"linktarget row has {len(row)} values; expected exactly 3"
+            )
+        yield LinkTarget(int(row[0]), int(row[1]), str(row[2]))
+
+
+def build_metadata_indexes(
+    pages: Iterable[Page],
+    page_props: Iterable[PageProp],
+    category_links: Iterable[CategoryLink],
+    link_targets: Iterable[LinkTarget],
+    *,
+    max_database_bytes: int | None = None,
+    scratch: WikiMetadataScratch | None = None,
+    database_name: str = "metadata.sqlite3",
+) -> WikiMetadataIndexes:
+    """Build category, Wikidata, hidden-category, and membership indexes.
+
+    Category graph edges point from a category page to its parent categories.
+    Links whose target category page is absent from ``pages`` are ignored
+    because they cannot be represented by a page identifier.
+
+    Parameters
+    ----------
+    pages
+        Normalized page records.
+    page_props
+        Normalized page property records.
+    category_links
+        Normalized category link records.
+    link_targets
+        Normalized link-target records used to resolve category targets.
+    max_database_bytes
+        Optional hard ceiling for the temporary SQLite database.
+    scratch
+        Caller-owned namespace for an explicit disk-backed database. When
+        omitted, the index remains in memory for small library and test callers.
+    database_name
+        Exclusive basename inside ``scratch``.
+
+    Returns
+    -------
+    WikiMetadataIndexes
+        Deterministically ordered mappings and set-like indexes.
+    """
+
+    connection: sqlite3.Connection | None = None
+    database_created = False
+    try:
+        if scratch is not None:
+            database_target = scratch.create_database(database_name)
+            database_created = True
+            connection = sqlite3.connect(database_target)
+            connection.set_progress_handler(scratch.progress, 100_000)
+        else:
+            connection = sqlite3.connect(":memory:")
+    except BaseException:
+        try:
+            if connection is not None:
+                connection.close()
+        finally:
+            if scratch is not None and database_created:
+                scratch.release_database(database_name)
+        raise
+    assert connection is not None
+    scratch_bytes = 0
+    try:
+        connection.execute(
+            f"PRAGMA temp_store={'FILE' if scratch is not None else 'MEMORY'}"
+        )
+        if max_database_bytes is not None:
+            page_size = connection.execute("PRAGMA page_size").fetchone()[0]
+            max_pages = max_database_bytes // page_size
+            if max_pages < 1:
+                raise ValueError(
+                    "SQLite metadata index has less than one page of disk budget"
+                )
+            connection.execute(f"PRAGMA max_page_count = {max_pages}")
+        connection.executescript(
+            """
+            PRAGMA journal_mode=OFF;
+            PRAGMA synchronous=OFF;
+            CREATE TABLE page (
+                page_id INTEGER PRIMARY KEY,
+                namespace INTEGER NOT NULL,
+                title TEXT NOT NULL,
+                is_redirect INTEGER NOT NULL,
+                latest_revision_id INTEGER,
+                UNIQUE (namespace, title)
+            );
+            CREATE TABLE property (
+                page_id INTEGER NOT NULL,
+                name TEXT NOT NULL,
+                value TEXT,
+                PRIMARY KEY (page_id, name)
+            );
+            CREATE TABLE target (
+                target_id INTEGER PRIMARY KEY,
+                namespace INTEGER NOT NULL,
+                title TEXT NOT NULL
+            );
+            CREATE TABLE category_link (
+                source_page_id INTEGER NOT NULL,
+                target_id INTEGER NOT NULL,
+                link_type TEXT NOT NULL
+            );
+            """
+        )
+        scratch_bytes = _database_bytes(connection)
+        connection.executemany(
+            "INSERT INTO page VALUES (?, ?, ?, ?, ?)",
+            (
+                (
+                    page.page_id,
+                    page.namespace,
+                    page.title,
+                    int(page.is_redirect),
+                    page.latest_revision_id,
+                )
+                for page in pages
+                if page.namespace in {0, 14}
+            ),
+        )
+        connection.executemany(
+            "INSERT INTO property VALUES (?, ?, ?)",
+            (
+                (prop.page_id, prop.name, prop.value)
+                for prop in page_props
+                if prop.name in {"disambiguation", "hiddencat"}
+                or (prop.name == "wikibase_item" and prop.value is not None)
+            ),
+        )
+        connection.executemany(
+            "INSERT INTO target VALUES (?, ?, ?)",
+            (
+                (target.target_id, target.namespace, target.title)
+                for target in link_targets
+                if target.namespace == 14
+            ),
+        )
+        connection.executemany(
+            "INSERT INTO category_link VALUES (?, ?, ?)",
+            (
+                (link.source_page_id, link.target_id, link.link_type)
+                for link in category_links
+            ),
+        )
+        connection.executescript(
+            """
+            CREATE INDEX page_namespace_title ON page(namespace, title);
+            CREATE INDEX property_name_page ON property(name, page_id);
+            CREATE INDEX target_namespace_title ON target(namespace, title);
+            CREATE INDEX category_link_source ON category_link(source_page_id);
+            CREATE INDEX category_link_target ON category_link(target_id);
+            CREATE VIEW resolved_category_link AS
+            SELECT link.source_page_id, source.namespace AS source_namespace,
+                   category.page_id AS target_page_id
+            FROM category_link AS link
+            JOIN page AS source ON source.page_id = link.source_page_id
+            JOIN target ON target.target_id = link.target_id
+                       AND target.namespace = 14
+            JOIN page AS category ON category.namespace = 14
+                                 AND category.title = target.title;
+            """
+        )
+        connection.commit()
+        if scratch is not None:
+            scratch.observe()
+    except sqlite3.Error as error:
+        accounting_error: OSError | None = None
+        try:
+            connection.rollback()
+        except sqlite3.Error:
+            pass
+        if scratch is not None:
+            try:
+                scratch.observe()
+            except _MetadataIndexError:
+                pass
+            except OSError as observe_error:
+                accounting_error = observe_error
+        try:
+            scratch_bytes = max(
+                scratch_bytes,
+                scratch.main_database_bytes
+                if scratch is not None
+                else _database_bytes(connection),
+            )
+        except sqlite3.Error:
+            pass
+        cleanup_errors: list[BaseException] = []
+        try:
+            connection.close()
+        except BaseException as cleanup_error:
+            cleanup_errors.append(cleanup_error)
+        if scratch is not None:
+            try:
+                scratch.release_database(database_name)
+            except BaseException as cleanup_error:
+                cleanup_errors.append(cleanup_error)
+        if (
+            max_database_bytes is not None
+            and getattr(error, "sqlite_errorcode", None) == sqlite3.SQLITE_FULL
+        ):
+            index_error = _MetadataIndexError(
+                "SQLite metadata index exceeded its "
+                f"{max_database_bytes}-byte disk ceiling",
+                scratch_bytes,
+            )
+        elif scratch is not None and scratch.exceeded:
+            index_error = _MetadataIndexError(
+                "observed SQLite scratch bytes exceeded the "
+                f"{scratch.ceiling_bytes}-byte disk ceiling",
+                scratch_bytes,
+            )
+        else:
+            index_error = _MetadataIndexError(
+                f"SQLite metadata indexing failed: {error}", scratch_bytes
+            )
+        if accounting_error is not None:
+            index_error.add_note(
+                f"SQLite scratch accounting also failed: {accounting_error}"
+            )
+        for cleanup_error in cleanup_errors:
+            index_error.add_note(
+                f"SQLite metadata cleanup also failed: {cleanup_error}"
+            )
+        raise index_error from error
+    except BaseException as error:
+        cleanup_errors = []
+        try:
+            connection.close()
+        except BaseException as cleanup_error:
+            cleanup_errors.append(cleanup_error)
+        if scratch is not None:
+            try:
+                scratch.release_database(database_name)
+            except BaseException as cleanup_error:
+                cleanup_errors.append(cleanup_error)
+        for cleanup_error in cleanup_errors:
+            error.add_note(f"SQLite metadata cleanup also failed: {cleanup_error}")
+        raise
+
+    return WikiMetadataIndexes(
+        category_title_to_id=_SqliteScalarMapping(
+            connection,
+            "SELECT title, page_id FROM page WHERE namespace = 14 ORDER BY title",
+            "SELECT page_id FROM page WHERE namespace = 14 AND title = ?",
+        ),
+        category_id_to_title=_SqliteScalarMapping(
+            connection,
+            "SELECT page_id, title FROM page WHERE namespace = 14 ORDER BY page_id",
+            "SELECT title FROM page WHERE namespace = 14 AND page_id = ?",
+        ),
+        page_id_to_qid=_SqliteScalarMapping(
+            connection,
+            "SELECT page_id, value FROM property "
+            "WHERE name = 'wikibase_item' ORDER BY page_id",
+            "SELECT value FROM property WHERE name = 'wikibase_item' AND page_id = ?",
+        ),
+        hidden_category_ids=_SqliteSet(
+            connection,
+            "SELECT property.page_id FROM property JOIN page "
+            "ON page.page_id = property.page_id "
+            "WHERE property.name = 'hiddencat' AND page.namespace = 14 "
+            "ORDER BY property.page_id",
+        ),
+        category_parents=_SqliteTupleMapping(
+            connection,
+            "SELECT source_page_id AS key, target_page_id AS value "
+            "FROM resolved_category_link "
+            "WHERE source_namespace = 14 ORDER BY source_page_id, target_page_id",
+        ),
+        article_categories=_SqliteTupleMapping(
+            connection,
+            "SELECT source_page_id AS key, target_page_id AS value "
+            "FROM resolved_category_link "
+            "WHERE source_namespace = 0 ORDER BY source_page_id, target_page_id",
+        ),
+        category_children=_SqliteTupleMapping(
+            connection,
+            "SELECT parent.title AS key, child.title AS value "
+            "FROM resolved_category_link AS link "
+            "JOIN page AS child ON child.page_id = link.source_page_id "
+            "JOIN page AS parent ON parent.page_id = link.target_page_id "
+            "WHERE link.source_namespace = 14 ORDER BY parent.title, child.title",
+        ),
+        category_title_to_qid=_SqliteScalarMapping(
+            connection,
+            "SELECT page.title, property.value FROM page JOIN property "
+            "ON property.page_id = page.page_id "
+            "WHERE page.namespace = 14 AND property.name = 'wikibase_item' "
+            "ORDER BY page.title",
+            "SELECT property.value FROM page JOIN property "
+            "ON property.page_id = page.page_id "
+            "WHERE page.namespace = 14 AND property.name = 'wikibase_item' "
+            "AND page.title = ?",
+        ),
+        _connection=connection,
+        _scratch=scratch,
+        _database_name=database_name if scratch is not None else None,
+    )
+
+
+def _database_bytes(connection: sqlite3.Connection) -> int:
+    """Return the allocated page bytes for one SQLite database."""
+
+    return (
+        connection.execute("PRAGMA page_count").fetchone()[0]
+        * connection.execute("PRAGMA page_size").fetchone()[0]
+    )
+
+
+def select_quality_articles(
+    indexes: WikiMetadataIndexes,
+    config: QualityCategoryConfig,
+) -> tuple[QualityArticle, ...]:
+    """Select namespace-0 quality articles using direct category membership.
+
+    Parameters
+    ----------
+    indexes
+        Metadata indexes containing namespace-filtered article memberships.
+    config
+        Caller-supplied status and former/delisted category titles.
+
+    Returns
+    -------
+    tuple of QualityArticle
+        Articles sorted by page identifier. Articles in any excluded category
+        are omitted even when they also belong to a quality category.
+    """
+
+    statuses_by_id = {
+        category_id: status
+        for title, status in config.statuses_by_title.items()
+        if (category_id := indexes.category_title_to_id.get(title)) is not None
+    }
+    excluded_ids = {
+        category_id
+        for title in config.excluded_titles
+        if (category_id := indexes.category_title_to_id.get(title)) is not None
+    }
+    relevant_ids = set(statuses_by_id) | excluded_ids
+    if not relevant_ids:
+        return ()
+    placeholders = ", ".join("?" for _ in relevant_ids)
+    rows = indexes._connection.execute(
+        "SELECT link.source_page_id, link.target_page_id "
+        "FROM resolved_category_link AS link "
+        "JOIN page AS source ON source.page_id = link.source_page_id "
+        f"WHERE link.source_namespace = 0 AND source.is_redirect = 0 "
+        "AND NOT EXISTS (SELECT 1 FROM property AS property "
+        "WHERE property.page_id = source.page_id "
+        "AND property.name = 'disambiguation') "
+        f"AND link.target_page_id IN ({placeholders}) "
+        "ORDER BY source_page_id, target_page_id",
+        tuple(sorted(relevant_ids)),
+    )
+    selected: list[QualityArticle] = []
+    page_id: int | None = None
+    category_ids: set[int] = set()
+    for current_page_id, category_id in rows:
+        if page_id is not None and current_page_id != page_id:
+            _append_quality_article(
+                selected, page_id, category_ids, statuses_by_id, excluded_ids
+            )
+            category_ids = set()
+        page_id = current_page_id
+        category_ids.add(category_id)
+    if page_id is not None:
+        _append_quality_article(
+            selected, page_id, category_ids, statuses_by_id, excluded_ids
+        )
+    return tuple(selected)
+
+
+def _append_quality_article(
+    selected: list[QualityArticle],
+    page_id: int,
+    category_ids: set[int],
+    statuses_by_id: Mapping[int, str],
+    excluded_ids: set[int],
+) -> None:
+    """Append one eligible article to an ordered quality result."""
+
+    if excluded_ids.intersection(category_ids):
+        return
+    statuses = tuple(
+        sorted(
+            {statuses_by_id[item] for item in category_ids if item in statuses_by_id}
+        )
+    )
+    if statuses:
+        selected.append(QualityArticle(page_id, statuses))
+
+
+def _iter_tokens(source: Iterable[str]) -> Iterator[_Token]:
+    characters = (character for chunk in source for character in chunk)
+    pending: str | None = None
+    while True:
+        if pending is None:
+            character = next(characters, None)
+        else:
+            character, pending = pending, None
+        if character is None:
+            return
+        if character.isspace():
+            continue
+        if character in "(),;":
+            yield "SYMBOL", character
+            continue
+        if character == "`":
+            identifier: list[str] = []
+            for character in characters:
+                if character == "`":
+                    break
+                identifier.append(character)
+            else:
+                raise ValueError("Unterminated SQL identifier")
+            yield "IDENT", "".join(identifier)
+            continue
+        if character == "'":
+            string: list[str] = []
+            for character in characters:
+                if character == "\\":
+                    escaped = next(characters, None)
+                    if escaped is None:
+                        raise ValueError("Unterminated SQL string escape")
+                    string.append(_MYSQL_ESCAPES.get(escaped, escaped))
+                elif character == "'":
+                    following = next(characters, None)
+                    if following == "'":
+                        string.append("'")
+                    else:
+                        pending = following
+                        break
+                else:
+                    string.append(character)
+            else:
+                raise ValueError("Unterminated SQL string")
+            yield "VALUE", "".join(string)
+            continue
+
+        atom = [character]
+        for character in characters:
+            if character.isspace() or character in "(),;":
+                pending = character
+                break
+            atom.append(character)
+        text = "".join(atom)
+        value = _convert_atom(text)
+        yield ("WORD" if isinstance(value, str) else "VALUE"), value
+
+
+def _convert_atom(text: str) -> SqlValue:
+    if text.upper() == "NULL":
+        return None
+    if _INTEGER.fullmatch(text):
+        return int(text)
+    if _FLOAT.fullmatch(text) and ("." in text or "e" in text.lower()):
+        return float(text)
+    return text
+
+
+def _iter_validated_rows(
+    source: Iterable[str],
+    table: str,
+    expected_columns: tuple[tuple[int, str], ...],
+    *,
+    exact: bool = False,
+    select_by_name: bool = False,
+) -> Iterator[tuple[SqlValue, ...]]:
+    """Validate a dump table declaration before yielding its inserted rows."""
+
+    observed_columns: list[str] = []
+    rows = iter_insert_rows(
+        _validated_source(
+            source,
+            table,
+            expected_columns,
+            exact=exact,
+            validate_by_name=select_by_name,
+            observed_columns=observed_columns,
+        ),
+        table,
+    )
+    if not select_by_name:
+        yield from rows
+        return
+
+    positions: tuple[int, ...] | None = None
+    for row in rows:
+        if positions is None:
+            positions = tuple(
+                observed_columns.index(name) for _, name in expected_columns
+            )
+        if len(row) < len(observed_columns):
+            raise ValueError(
+                f"{table} row has {len(row)} values; expected at least "
+                f"{len(observed_columns)}"
+            )
+        if len(row) > len(observed_columns):
+            raise ValueError(
+                f"{table} row has {len(row)} values; CREATE TABLE declares "
+                f"{len(observed_columns)} columns"
+            )
+        yield tuple(row[position] for position in positions)
+
+
+def _prepare_metadata_sources(
+    page: Iterable[str],
+    page_props: Iterable[str],
+    categorylinks: Iterable[str],
+    linktarget: Iterable[str],
+) -> tuple[Iterable[str], Iterable[str], Iterable[str], Iterable[str]]:
+    """Validate all required schemas before exposing any INSERT rows."""
+
+    prepared = []
+    for source, table, columns, exact, validate_by_name in (
+        (page, "page", _PAGE_COLUMNS, False, True),
+        (page_props, "page_props", _PAGE_PROPS_COLUMNS, False, False),
+        (categorylinks, "categorylinks", _CATEGORYLINKS_COLUMNS, True, False),
+        (linktarget, "linktarget", _LINKTARGET_COLUMNS, True, False),
+    ):
+        validated = _validated_source(
+            source,
+            table,
+            columns,
+            exact=exact,
+            validate_by_name=validate_by_name,
+        )
+        prefix = next(validated)
+        prepared.append(chain((prefix,), validated))
+    return tuple(prepared)
+
+
+def _validated_source(
+    source: Iterable[str],
+    table: str,
+    expected_columns: tuple[tuple[int, str], ...],
+    *,
+    exact: bool,
+    validate_by_name: bool = False,
+    observed_columns: list[str] | None = None,
+) -> Iterator[str]:
+    """Yield a source only after its bounded schema prefix is validated."""
+
+    buffered = ""
+    create_pattern = re.compile(
+        rf"CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?`?{re.escape(table)}`?\s*\(",
+        re.IGNORECASE,
+    )
+    insert_pattern = re.compile(
+        rf"INSERT\s+INTO\s+`?{re.escape(table)}`?\b", re.IGNORECASE
+    )
+    iterator = iter(source)
+    for chunk in iterator:
+        buffered += chunk
+        create_match = create_pattern.search(buffered)
+        insert_match = insert_pattern.search(buffered)
+        if insert_match is not None and (
+            create_match is None or insert_match.start() < create_match.start()
+        ):
+            raise ValueError(f"{table} CREATE TABLE schema is missing")
+        if create_match is not None:
+            statement_end = buffered.find(";", create_match.end())
+            if statement_end >= 0:
+                statement = buffered[create_match.start() : statement_end]
+                columns = tuple(
+                    re.findall(r"(?:\(|,)\s*`([^`]+)`\s+[A-Za-z]", statement)
+                )
+                if validate_by_name:
+                    incompatible = any(
+                        columns.count(name) != 1 for _, name in expected_columns
+                    )
+                else:
+                    incompatible = any(
+                        position >= len(columns) or columns[position] != name
+                        for position, name in expected_columns
+                    )
+                if exact and len(columns) != len(expected_columns):
+                    incompatible = True
+                if incompatible:
+                    expected = ", ".join(name for _, name in expected_columns)
+                    actual = ", ".join(columns) or "<none>"
+                    raise ValueError(
+                        f"{table} CREATE TABLE schema is incompatible: "
+                        f"expected {expected}; found {actual}"
+                    )
+                if observed_columns is not None:
+                    observed_columns.extend(columns)
+                yield buffered
+                yield from iterator
+                return
+        if len(buffered) > _SCHEMA_PREFIX_LIMIT:
+            raise ValueError(
+                f"{table} CREATE TABLE schema is missing from the first "
+                f"{_SCHEMA_PREFIX_LIMIT} characters"
+            )
+    raise ValueError(f"{table} CREATE TABLE schema is missing")
+
+
+def _iter_statement_rows(tokens: Iterator[_Token]) -> Iterator[tuple[SqlValue, ...]]:
+    token = next(tokens, None)
+    while token is not None and token != ("SYMBOL", ";"):
+        if token != ("SYMBOL", "("):
+            raise ValueError("Expected '(' at the start of an INSERT row")
+        row: list[SqlValue] = []
+        expect_value = True
+        for token in tokens:
+            if expect_value:
+                if token[0] not in {"VALUE", "WORD", "IDENT"}:
+                    raise ValueError("Expected a value in an INSERT row")
+                row.append(token[1])
+                expect_value = False
+            elif token == ("SYMBOL", ","):
+                expect_value = True
+            elif token == ("SYMBOL", ")"):
+                break
+            else:
+                raise ValueError("Expected ',' or ')' in an INSERT row")
+        else:
+            raise ValueError("Unterminated INSERT row")
+        if expect_value:
+            raise ValueError("INSERT row ends after a comma")
+        yield tuple(row)
+        token = next(tokens, None)
+        if token == ("SYMBOL", ","):
+            token = next(tokens, None)
+        elif token != ("SYMBOL", ";"):
+            raise ValueError("Expected ',' or ';' after an INSERT row")

preprocessing/_wikigood/wikigood_ru_corpus.py

@@ -0,0 +1,297 @@
+"""Portable reproduction of the pinned 20261001 quality corpora.
+
+SQL selection and XML normalization are shared with the accepted Full builder.
+Selected applies only the published frozen annotations. Failed targets are kept.
+"""
+from __future__ import annotations
+
+import argparse
+import gzip
+from hashlib import sha1, sha256
+from importlib.metadata import version
+import json
+from pathlib import Path
+import shutil
+import sys
+from types import SimpleNamespace
+from urllib.request import Request, urlopen
+
+from .wikigood_ru_content import ExpectedWikiPage, extract_selected_pages
+from .wikigood_ru_quality_metadata import select_wikigood_ru_quality_metadata
+from .wikigood_ru_vw import _quality_json
+
+SPEC_PATH = Path(__file__).resolve().parents[1] / 'specs/wikipedia-quality-corpus-20261001.json'
+# Public exports place this same resource beside prepare.py.
+if not SPEC_PATH.is_file():
+    SPEC_PATH = Path(__file__).resolve().parents[1] / 'wikipedia-quality-corpus-20261001.json'
+SPEC = json.loads(SPEC_PATH.read_text(encoding='utf-8'))
+
+
+def _safe(path):
+    path = Path(path).absolute()
+    if '..' in path.parts or any(p.is_symlink() for p in (path, *path.parents)):
+        raise ValueError(f'symbolic links and parent traversal are forbidden: {path}')
+    return path
+
+
+def _check(path, pin):
+    path = _safe(path)
+    if not path.is_file() or path.stat().st_size != pin['size_bytes']:
+        raise ValueError(f'pinned file size mismatch: {path}')
+    hashes = {name: algorithm() for name, algorithm in (('sha256', sha256), ('sha1', sha1)) if name in pin}
+    with path.open('rb') as stream:
+        for block in iter(lambda: stream.read(1024 * 1024), b''):
+            for digest in hashes.values():
+                digest.update(block)
+    if any(digest.hexdigest() != pin[name] for name, digest in hashes.items()):
+        raise ValueError(f'pinned file checksum mismatch: {path}')
+
+
+def validate_corpus_sources(sources_dir):
+    """Rehash all six exact dated inputs against SHA-256 and official SHA-1."""
+    root = _safe(sources_dir)
+    for entry in SPEC['sources']:
+        _check(root / entry['filename'], entry)
+    return SPEC['sources']
+
+
+def download_corpus_sources(sources_dir, *, resume=False):
+    """Reuse validated final files; partial HTTP transfers require explicit resume."""
+    root = _safe(sources_dir)
+    if root.exists():
+        for entry in SPEC['sources']:
+            final, part = root / entry['filename'], root / (entry['filename'] + '.part')
+            _safe(part)
+            if final.exists():
+                _check(final, entry)
+                if part.exists():
+                    raise ValueError(f'both final and partial files exist: {final.name}')
+            if part.exists() and (not resume or not part.is_file() or part.stat().st_size > entry['size_bytes']):
+                raise ValueError(f'partial source requires explicit --resume and valid size: {part}')
+    root.mkdir(parents=True, exist_ok=True)
+    for entry in SPEC['sources']:
+        final, part = root / entry['filename'], root / (entry['filename'] + '.part')
+        if final.exists():
+            continue
+        offset = part.stat().st_size if part.exists() else 0
+        if offset < entry['size_bytes']:
+            headers = {'User-Agent': 'RuWiki-Good-2026-V2-reproduction/1'}
+            if offset:
+                headers['Range'] = f'bytes={offset}-'
+            print(f'corpus sources download {entry["filename"]} offset={offset}', file=sys.stderr, flush=True)
+            with urlopen(Request(entry['url'], headers=headers), timeout=60) as response:
+                expected = entry['size_bytes'] - offset
+                if response.geturl() != entry['url'] or response.status != (206 if offset else 200):
+                    raise ValueError('dated source URL or HTTP range response mismatch')
+                if int(response.headers.get('Content-Length', '-1')) != expected:
+                    raise ValueError('source HTTP length mismatch')
+                if offset and response.headers.get('Content-Range') != f'bytes {offset}-{entry["size_bytes"] - 1}/{entry["size_bytes"]}':
+                    raise ValueError('source HTTP range mismatch')
+                with part.open('ab' if offset else 'xb') as stream:
+                    while block := response.read(min(1024 * 1024, expected + 1)):
+                        if len(block) > expected:
+                            raise ValueError('source HTTP body exceeds pinned size')
+                        stream.write(block)
+                        expected -= len(block)
+            if expected:
+                raise ValueError('incomplete source HTTP body; rerun with --resume')
+        _check(part, entry)
+        part.rename(final)
+    return {'snapshot': SPEC['snapshot'], 'files': SPEC['sources']}
+
+
+def _rows(path):
+    with gzip.open(path, 'rt', encoding='utf-8') as stream:
+        for line in stream:
+            yield json.loads(line)
+
+
+def _write_rows(path, rows, *, compresslevel=9, sort_keys=True):
+    with path.open('xb') as raw:
+        with gzip.GzipFile(filename='', mode='wb', fileobj=raw, mtime=0, compresslevel=compresslevel) as stream:
+            for row in rows:
+                payload = _quality_json(row) if sort_keys else (json.dumps(row, ensure_ascii=False, separators=(',', ':')) + '\n').encode('utf-8')
+                stream.write(payload)
+
+
+def _annotations(root):
+    root = _safe(root)
+    pins = SPEC['corpora']['selected']
+    for name in ('labels.json', 'topics.jsonl.gz'):
+        _check(root / name, pins['files'][name])
+    labels = json.loads((root / 'labels.json').read_text(encoding='utf-8'))
+    topics = list(_rows(root / 'topics.jsonl.gz'))
+    slugs = [row['slug'] for row in topics]
+    if len(slugs) != pins['topic_count'] or len(set(slugs)) != len(slugs):
+        raise ValueError('annotation topic count or identity mismatch')
+    if len(labels) != pins['count'] or any(
+        not isinstance(values, list) or not values or values != sorted(set(values))
+        or set(values) - set(slugs) for values in labels.values()
+    ):
+        raise ValueError('annotation labels or topic binding mismatch')
+    return labels
+
+
+def _selected_rows(full_path, labels):
+    seen = set()
+    previous = 0
+    full_count = 0
+    for row in _rows(full_path):
+        page_id = row['page_id']
+        if type(page_id) is not int or page_id <= previous or row['id'] != f'ruwiki/{page_id}' or 'topics' in row:
+            raise ValueError('Full article IDs, ordering or schema mismatch')
+        previous = page_id
+        full_count += 1
+        if row['id'] in labels:
+            seen.add(row['id'])
+            yield {**row, 'topics': labels[row['id']]}
+    if full_count != SPEC['corpora']['full']['count'] or seen != set(labels):
+        raise ValueError('Full count or Selected annotation IDs mismatch')
+
+
+def _full_records(sources, scratch):
+    entries = {entry['filename']: entry for entry in SPEC['sources']}
+    names = ('page', 'page_props', 'categorylinks', 'linktarget')
+    snapshot = SimpleNamespace(
+        **{name: sources / f'ruwiki-20261001-{name}.sql.gz' for name in names},
+        snapshot_id='ru-20261001',
+        checksums={name: entries[f'ruwiki-20261001-{name}.sql.gz']['sha256'] for name in names},
+    )
+    print('corpus build metadata', file=sys.stderr, flush=True)
+    metadata = select_wikigood_ru_quality_metadata(snapshot, scratch_parent=scratch, scratch_ceiling_bytes=32 * 1024**3)
+    roster = metadata['articles']
+    if len(roster) != SPEC['corpora']['full']['count']:
+        raise ValueError('Full SQL roster count mismatch')
+    captured = {}
+    print('corpus build XML extraction', file=sys.stderr, flush=True)
+    pages = extract_selected_pages(
+        sources / 'ruwiki-20261001-pages-articles-multistream.xml.bz2',
+        sources / 'ruwiki-20261001-pages-articles-multistream-index.txt.bz2',
+        [ExpectedWikiPage(row['page_id'], row['title']) for row in roster], source_records=captured,
+    )
+    by_id = {page.page_id: page for page in pages}
+    if len(pages) != len(roster) or set(by_id) != set(captured) or set(by_id) != {row['page_id'] for row in roster}:
+        raise ValueError('XML extraction roster mismatch')
+    def records():
+        for row in roster:
+            page = by_id[row['page_id']]
+            yield {**row, **captured[page.page_id], 'id': f'ruwiki/{page.page_id}',
+                   'revision_id': page.revision_id, 'raw_text': page.raw_text,
+                   'wikitext_sha256': page.wikitext_sha256, 'raw_text_sha256': page.raw_text_sha256,
+                   'page_url': f'https://ru.wikipedia.org/?curid={page.page_id}',
+                   'revision_url': f'https://ru.wikipedia.org/w/index.php?oldid={page.revision_id}'}
+    return records(), metadata['categories']
+
+
+def verify_corpus(output_dir, *, dataset='both'):
+    """Compare payloads to independent published pins; no self-generated seal is trusted."""
+    root = _safe(output_dir)
+    names = ('full', 'selected') if dataset == 'both' else (dataset,)
+    for name in names:
+        for filename, pin in SPEC['corpora'][name]['files'].items():
+            _check(root / name / filename, pin)
+    if 'selected' in names:
+        labels = _annotations(root / 'selected')
+        observed = {}
+        previous = 0
+        for row in _rows(root / 'selected/articles.jsonl.gz'):
+            if row['page_id'] <= previous or row['id'] != f'ruwiki/{row["page_id"]}':
+                raise ValueError('Selected article ordering or ID mismatch')
+            previous = row['page_id']
+            observed[row['id']] = row['topics']
+        if observed != labels:
+            raise ValueError('Selected articles and frozen labels differ')
+    return {'snapshot': SPEC['snapshot'], 'corpora': {name: SPEC['corpora'][name] for name in names}}
+
+
+def build_corpus(sources_dir, *, output_dir, scratch_dir, dataset='both', annotations_dir=None, full_dir=None):
+    """Create fresh output/full and output/selected, ready for the existing NLP CLI."""
+    sources, output, scratch = map(_safe, (sources_dir, output_dir, scratch_dir))
+    inputs = [sources]
+    if annotations_dir is not None:
+        inputs.append(_safe(annotations_dir))
+    if full_dir is not None:
+        inputs.append(_safe(full_dir))
+        if dataset != 'selected':
+            raise ValueError('--full-dir requires --dataset selected')
+    for path in (output, scratch):
+        if path.exists():
+            raise ValueError(f'fresh target required: {path}')
+        if any((parent / 'preprocessing/prepare.py').is_file() or (parent / 'data/articles.jsonl.gz').is_file() for parent in (path, *path.parents)):
+            raise ValueError('output and scratch must be outside published dataset clones')
+    paths = [output, scratch, *inputs]
+    for i, path in enumerate(paths[:2]):
+        if any(path == other or path.is_relative_to(other) or other.is_relative_to(path) for other in paths[i + 1:]):
+            raise ValueError('source, output and scratch paths must be disjoint')
+    selected = dataset in ('selected', 'both')
+    if selected and annotations_dir is None:
+        raise ValueError('--annotations-dir is required for Selected')
+    labels = _annotations(annotations_dir) if selected else None
+    if full_dir is None:
+        if sys.version_info[:3] != (3, 11, 15):
+            raise ValueError('raw corpus extraction requires Python==3.11.15')
+        if version('mwparserfromhell') != '0.7.2':
+            raise ValueError('corpus extraction requires mwparserfromhell==0.7.2')
+        import mwparserfromhell
+        if mwparserfromhell.parse("''fixture''").strip_code() != 'fixture':
+            raise ValueError('mwparserfromhell runtime probe failed')
+        validate_corpus_sources(sources)
+    else:
+        _check(Path(full_dir) / 'articles.jsonl.gz', SPEC['corpora']['full']['files']['articles.jsonl.gz'])
+    output.mkdir(parents=True)
+    scratch.mkdir(parents=True)
+    if full_dir is None:
+        records, categories = _full_records(sources, scratch)
+        full_output = output / 'full' if dataset in ('both', 'full') else scratch / 'full'
+        full_output.mkdir()
+        _write_rows(full_output / 'articles.jsonl.gz', records)
+        _write_rows(full_output / 'categories.jsonl.gz', categories)
+        for filename, pin in SPEC['corpora']['full']['files'].items():
+            _check(full_output / filename, pin)
+    else:
+        full_output = Path(full_dir)
+    if selected:
+        target = output / 'selected'
+        target.mkdir()
+        _write_rows(target / 'articles.jsonl.gz', _selected_rows(full_output / 'articles.jsonl.gz', labels),
+                    compresslevel=6, sort_keys=False)
+        for filename in ('labels.json', 'topics.jsonl.gz'):
+            shutil.copyfile(Path(annotations_dir) / filename, target / filename)
+    result = verify_corpus(output, dataset=dataset)
+    (output / 'corpus-manifest.json').write_bytes(_quality_json(result))
+    return result
+
+
+def verify_published_nlp(output_dir, *, dataset='both'):
+    """Check final CSVs and labels against published hashes without loading NLP."""
+    root = _safe(output_dir)
+    for name in (('full', 'selected') if dataset == 'both' else (dataset,)):
+        for filename, pin in SPEC['nlp'][name].items():
+            _check(root / name / filename, pin)
+
+
+def main(argv=None):
+    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', required=True, type=Path)
+    parser.add_argument('--output-dir', type=Path)
+    parser.add_argument('--scratch-dir', type=Path)
+    parser.add_argument('--annotations-dir', type=Path)
+    parser.add_argument('--full-dir', type=Path, help='Pinned Full data directory for Selected-only replay without dumps')
+    parser.add_argument('--resume', action='store_true')
+    args = parser.parse_args(argv)
+    for field in {'download': (), 'build': ('output_dir', 'scratch_dir'), 'verify': ('output_dir',)}[args.action]:
+        if getattr(args, field) is None:
+            parser.error(f'--{field.replace("_", "-")} is required')
+    if args.resume and args.action != 'download':
+        parser.error('--resume is only valid with --action download')
+    if args.action == 'download':
+        download_corpus_sources(args.sources_dir, resume=args.resume)
+    elif args.action == 'build':
+        build_corpus(args.sources_dir, output_dir=args.output_dir, scratch_dir=args.scratch_dir,
+                     dataset=args.dataset, annotations_dir=args.annotations_dir, full_dir=args.full_dir)
+    else:
+        verify_corpus(args.output_dir, dataset=args.dataset)
+    print(f'{args.action.upper()}_OK stage=corpus dataset={args.dataset}', flush=True)
+    return 0

preprocessing/_wikigood/wikigood_ru_quality_metadata.py

@@ -0,0 +1,220 @@
+"""Portable full-quality metadata selection using the existing SQL kernels."""
+from __future__ import annotations
+from collections import Counter
+from contextlib import ExitStack, contextmanager
+from hashlib import sha256
+import gzip
+from os import PathLike, fspath
+from pathlib import Path
+import re
+from typing import Iterator, TextIO
+from .wiki_metadata import (
+    QualityCategoryConfig, _execute_in_batches, _prepare_metadata_sources,
+    build_metadata_indexes, iter_category_links, iter_link_targets, iter_page_props,
+    iter_pages_with_metadata, open_metadata_scratch, select_quality_articles,
+)
+_SOURCE_NAMES = ("page", "page_props", "categorylinks", "linktarget")
+_SHA256 = re.compile(r"[0-9a-f]{64}\Z")
+FORMER_QUALITY_CATEGORIES = frozenset({
+    "Википедия:Лишённые_статуса_добротной",
+    "Википедия:Лишённые_статуса_хорошей",
+    "Википедия:Устаревшие_избранные_статьи",
+})
+
+@contextmanager
+def _open_text(source) -> Iterator[TextIO]:
+    if isinstance(source, (str, PathLike)):
+        path = fspath(source)
+        opener = gzip.open if path.endswith(".gz") else open
+        # SQL varbinary fields may contain non-UTF-8 bytes; keep them reversible.
+        with opener(
+            path, mode="rt", encoding="utf-8", errors="surrogateescape"
+        ) as stream:
+            yield stream
+        return
+    if not hasattr(source, "read"):
+        raise TypeError("metadata source must be a path or open text stream")
+    yield source
+
+
+def _source_sha256(source) -> str:
+    digest = sha256()
+    if isinstance(source, (str, PathLike)):
+        with open(source, "rb") as stream:
+            for chunk in iter(lambda: stream.read(1024 * 1024), b""):
+                digest.update(chunk)
+        return digest.hexdigest()
+
+    if not all(hasattr(source, method) for method in ("read", "seek", "tell")):
+        raise TypeError("metadata source must be a path or seekable stream")
+    try:
+        position = source.tell()
+        source.seek(0)
+    except (OSError, ValueError) as error:
+        raise ValueError("metadata stream must be seekable for checksum verification") from error
+    try:
+        while chunk := source.read(1024 * 1024):
+            digest.update(chunk.encode("utf-8") if isinstance(chunk, str) else chunk)
+    finally:
+        source.seek(position)
+    return digest.hexdigest()
+
+
+QUALITY_SNAPSHOT_ID = "ru-20261001"
+QUALITY_STATUSES = {
+    "Википедия:Добротные_статьи_по_алфавиту": "recommended",
+    "Википедия:Хорошие_статьи_по_алфавиту": "good",
+    "Википедия:Избранные_статьи_по_алфавиту": "featured",
+}
+
+
+def select_wikigood_ru_quality_metadata(
+    snapshot,
+    *,
+    scratch_parent: Path,
+    scratch_ceiling_bytes: int,
+) -> dict[str, object]:
+    """Return all active quality articles and the complete category graph.
+
+    Article titles use XML spelling (spaces); category titles retain exact SQL
+    spelling, including underscores. Category links include redlinks. Former
+    quality memberships are historical metadata and never veto active status.
+    """
+
+    if snapshot.snapshot_id != QUALITY_SNAPSHOT_ID:
+        raise ValueError(f"snapshot_id must be {QUALITY_SNAPSHOT_ID!r}")
+    if set(snapshot.checksums) != set(_SOURCE_NAMES) or any(
+        not isinstance(snapshot.checksums[name], str)
+        or _SHA256.fullmatch(snapshot.checksums[name]) is None
+        for name in _SOURCE_NAMES
+    ):
+        raise ValueError("snapshot checksums must be the exact lowercase SHA-256 set")
+    if (
+        isinstance(scratch_ceiling_bytes, bool)
+        or not isinstance(scratch_ceiling_bytes, int)
+        or scratch_ceiling_bytes <= 0
+    ):
+        raise ValueError("scratch_ceiling_bytes must be a positive integer")
+    for name in _SOURCE_NAMES:
+        if _source_sha256(getattr(snapshot, name)) != snapshot.checksums[name]:
+            raise ValueError(f"metadata checksum mismatch: {name}")
+
+    indexes = None
+    with open_metadata_scratch(Path(scratch_parent), scratch_ceiling_bytes) as scratch:
+        try:
+            with ExitStack() as stack:
+                sources = [
+                    stack.enter_context(_open_text(getattr(snapshot, name)))
+                    for name in _SOURCE_NAMES
+                ]
+                page, props, links, targets = _prepare_metadata_sources(*sources)
+                indexes = build_metadata_indexes(
+                    iter_pages_with_metadata(page),
+                    iter_page_props(props),
+                    iter_category_links(links),
+                    iter_link_targets(targets),
+                    max_database_bytes=scratch_ceiling_bytes,
+                    scratch=scratch,
+                    database_name="metadata-quality-ru.sqlite3",
+                )
+            missing = sorted(set(QUALITY_STATUSES) - set(indexes.category_title_to_id))
+            if missing:
+                raise ValueError(
+                    "configured quality category pages are missing: " + ", ".join(missing)
+                )
+            if set(QUALITY_STATUSES) & indexes.redirect_category_titles():
+                raise ValueError("configured quality category pages are redirects")
+            quality = select_quality_articles(
+                indexes, QualityCategoryConfig(QUALITY_STATUSES, frozenset())
+            )
+            if not quality:
+                raise ValueError("no non-redirect quality articles remain")
+            page_ids = tuple(article.page_id for article in quality)
+            metadata = indexes.article_metadata(page_ids)
+            direct = indexes.article_category_target_titles(page_ids)
+            qids = dict(_execute_in_batches(
+                indexes._connection,
+                "SELECT page_id, value FROM property WHERE name = 'wikibase_item' "
+                "AND page_id IN ({}) ORDER BY page_id",
+                page_ids,
+            ))
+            articles = []
+            for article in quality:
+                title, revision_id, redirect = metadata[article.page_id]
+                if not title or revision_id is None or revision_id <= 0 or redirect:
+                    raise ValueError(
+                        f"selected article metadata is inconsistent: {article.page_id}"
+                    )
+                memberships = list(direct.get(article.page_id, ()))
+                articles.append({
+                    "page_id": article.page_id,
+                    "title": title,
+                    "metadata_revision_id": revision_id,
+                    "wikidata_id": qids.get(article.page_id),
+                    "quality_statuses": list(article.statuses),
+                    "categories": memberships,
+                    "former_quality_categories": sorted(
+                        set(memberships) & FORMER_QUALITY_CATEGORIES
+                    ),
+                })
+
+            # Materialize the requested catalog, never the complete SQL tables.
+            connection = indexes._connection
+            catalog = {
+                title: {
+                    "title": title,
+                    "page_id": page_id,
+                    "is_hidden": None if page_id is None else bool(hidden),
+                    "is_redirect": None if page_id is None else bool(redirect),
+                    "wikidata_id": qid,
+                    "parents": [],
+                }
+                for title, page_id, redirect, hidden, qid in connection.execute(
+                    "SELECT titles.title, page.page_id, page.is_redirect, "
+                    "hidden.page_id IS NOT NULL, qid.value FROM ("
+                    "SELECT title FROM page WHERE namespace = 14 UNION "
+                    "SELECT target.title FROM target JOIN category_link AS link "
+                    "ON link.target_id = target.target_id WHERE target.namespace = 14"
+                    ") AS titles LEFT JOIN page ON page.namespace = 14 "
+                    "AND page.title = titles.title LEFT JOIN property AS hidden "
+                    "ON hidden.page_id = page.page_id AND hidden.name = 'hiddencat' "
+                    "LEFT JOIN property AS qid ON qid.page_id = page.page_id "
+                    "AND qid.name = 'wikibase_item' ORDER BY titles.title"
+                )
+            }
+            parent_links = 0
+            for title, parent in connection.execute(
+                "SELECT DISTINCT page.title, target.title FROM page "
+                "JOIN category_link AS link ON link.source_page_id = page.page_id "
+                "JOIN target ON target.target_id = link.target_id "
+                "WHERE page.namespace = 14 AND target.namespace = 14 "
+                "ORDER BY page.title, target.title"
+            ):
+                catalog[title]["parents"].append(parent)
+                parent_links += 1
+            scratch.observe()
+            return {
+                "resources": {
+                    "main_database_bytes": scratch.main_database_bytes,
+                    "observed_ephemeral_transient_high_water_bytes": (
+                        scratch.observed_ephemeral_transient_high_water_bytes
+                    ),
+                },
+                "articles": articles,
+                "categories": list(catalog.values()),
+                "counts": {
+                    "articles": len(articles),
+                    "categories": len(catalog),
+                    "category_redlinks": sum(
+                        c["page_id"] is None for c in catalog.values()
+                    ),
+                    "category_parent_links": parent_links,
+                    "direct_category_links": sum(len(a["categories"]) for a in articles),
+                    "quality_status_supports": dict(sorted(Counter(
+                        status for article in quality for status in article.statuses
+                    ).items())),
+                },
+            }
+        finally:
+            if indexes is not None:
+                indexes.close()

preprocessing/prepare.py

@@ -1,10 +1,30 @@
-"""Download, build or verify the pinned Russian Wikipedia NLP CSVs.
+"""Download, build or verify pinned Wikipedia corpus JSONL or NLP CSVs."""
+import argparse
+import sys
 
-Run ``python prepare.py --help`` for the portable workflow options.
-"""
 
-from _wikigood.wikigood_ru_csv import main
+def main(argv=None):
+    arguments = list(sys.argv[1:] if argv is None else argv)
+    parser = argparse.ArgumentParser(add_help=False)
+    parser.add_argument('--stage', choices=('corpus', 'nlp'), default='nlp')
+    stage, remaining = parser.parse_known_args(arguments)
+    if stage.stage == 'corpus':
+        from _wikigood.wikigood_ru_corpus import main as dispatch
+    else:
+        from _wikigood.wikigood_ru_csv import main as dispatch
+    result = dispatch(remaining)
+    if stage.stage == 'nlp':
+        options = argparse.ArgumentParser(add_help=False)
+        options.add_argument('--action')
+        options.add_argument('--output-dir')
+        options.add_argument('--dataset', default='both')
+        args, _ = options.parse_known_args(remaining)
+        if args.action in ('build', 'verify'):
+            from _wikigood.wikigood_ru_corpus import verify_published_nlp
+            verify_published_nlp(args.output_dir, dataset=args.dataset)
+            print(f'PUBLISHED_NLP_OK dataset={args.dataset}', flush=True)
+    return result
 
 
-if __name__ == "__main__":
+if __name__ == '__main__':
     raise SystemExit(main())

preprocessing/requirements.txt

@@ -1,3 +1,4 @@
 spacy==3.8.14
 pymorphy3==2.0.6
 nltk==3.9.2
+mwparserfromhell==0.7.2

preprocessing/wikipedia-quality-corpus-20261001.json

@@ -0,0 +1 @@
+{"corpora":{"full":{"count":17413,"files":{"articles.jsonl.gz":{"sha256":"c51f9b6bee4c85f25ffb861060f52490a9276bae289d2aa2db7e0d10e2dda950","size_bytes":409970311},"categories.jsonl.gz":{"sha256":"d07ab1e6c07da28cc162d786853a73c54e300289e21bcc6667c4072158abdf8f","size_bytes":22459573}}},"selected":{"count":17251,"files":{"articles.jsonl.gz":{"sha256":"9eb7efffe99fc7c9bc3f4b3eb9f0378d91f387081f97cf9abea9c1686797c1ed","size_bytes":413342335},"labels.json":{"sha256":"e7ceacd69d76601df24bb42e6d0177f46142d0b8ac1bf6e8c22ad4d5a0b0ca70","size_bytes":649823},"topics.jsonl.gz":{"sha256":"c8cf602a924f18255e155cdcaa9357907461851e849113c72051c2b89484f22c","size_bytes":2671}},"topic_count":28}},"nlp":{"full":{"bow.csv":{"sha256":"a45edd3e9287009e353c0f3ffc4404ffadc393293dada691e2d275a0bc0d2f5d","size_bytes":883080852},"noow.csv":{"sha256":"041250c048b0441cc88d516b92e1d65c0f80db3c82b400b7ae6b9db379c2ed33","size_bytes":1128356201}},"selected":{"bow.csv":{"sha256":"bff3a82c29ab3b866fe86135ff99b3897deb98dc4e5ed6db4ea7b24bd4011bae","size_bytes":875143956},"labels.json":{"sha256":"e7ceacd69d76601df24bb42e6d0177f46142d0b8ac1bf6e8c22ad4d5a0b0ca70","size_bytes":649823},"noow.csv":{"sha256":"2c71aa6b5a327ebe924f5f0160eaf6f923a86da1a3a7fe8c68aa67f8858f8b6b","size_bytes":1118455706}}},"schema_version":1,"snapshot":"20261001","sources":[{"filename":"ruwiki-20261001-page.sql.gz","sha1":"448e8faf79cbcdd2bb7c8f76c1e2d275b2288226","sha256":"24250cca6122fff02896a1ced0a85b7afa4d6be00fa119c169a5eeef3fbe5830","size_bytes":314950229,"url":"https://dumps.wikimedia.org/ruwiki/20261001/ruwiki-20261001-page.sql.gz"},{"filename":"ruwiki-20261001-page_props.sql.gz","sha1":"f08c0700597847bb5d82a9130e67ad75c4c184ab","sha256":"fc9d5aeaf3487d932b82d18a16bc96f0e4e4702e1149cbbdc482eb509f6deb60","size_bytes":64031076,"url":"https://dumps.wikimedia.org/ruwiki/20261001/ruwiki-20261001-page_props.sql.gz"},{"filename":"ruwiki-20261001-categorylinks.sql.gz","sha1":"c4200e9e6a0179cf0624b76cccfd46b0ba57c715","sha256":"1ecb32ffaff28a120b6a8f4297d4b228b65c49beb593eae022b5811ae41512e1","size_bytes":343720059,"url":"https://dumps.wikimedia.org/ruwiki/20261001/ruwiki-20261001-categorylinks.sql.gz"},{"filename":"ruwiki-20261001-linktarget.sql.gz","sha1":"576c82d839bbc4db57435ec864315be657d22ee6","sha256":"bc1f24b7b8eb06298cbe70fdfb010ec023586d05bd2d3403ba2370091e1edc4a","size_bytes":243099022,"url":"https://dumps.wikimedia.org/ruwiki/20261001/ruwiki-20261001-linktarget.sql.gz"},{"filename":"ruwiki-20261001-pages-articles-multistream.xml.bz2","sha1":"edfd1751cf2444b7fdb4f0cad0ee1bdb661cd65a","sha256":"c22b6441176d2bc572ed6883abc6292fe168efca211f6cdd61d8772a78492a1b","size_bytes":6212830831,"url":"https://dumps.wikimedia.org/ruwiki/20261001/ruwiki-20261001-pages-articles-multistream.xml.bz2"},{"filename":"ruwiki-20261001-pages-articles-multistream-index.txt.bz2","sha1":"379bcb73bc29f496975608b33a4a054dcd932f77","sha256":"17c6a4cebb90ecb2b0f881e04aa3b49356bd6ee6add802a7201b9ca1a9b093e3","size_bytes":66367857,"url":"https://dumps.wikimedia.org/ruwiki/20261001/ruwiki-20261001-pages-articles-multistream-index.txt.bz2"}]}