add info about reproduction, as well as reproduction code

README.md

@@ -57,6 +57,24 @@ Each UTF-8 CSV has exactly `id,raw_text,vw_text` columns and lexicographically o
 
 NOOW means occurrence order after preprocessing, not untouched or reversible prose. English preprocessing uses Python 3.11.15, NLTK 3.9.2 and NLTK-data commit `550b6625bcef1f2abff2ff770a5a0d272c9c6b2a`: WordPunctTokenizer, lowercase per original span, minimum token length 2, averaged_perceptron_tagger_eng, WordNet POS mapping J/V/N/R with noun fallback, English stopword removal and `lemma.isalpha()` filtering. Names are not masked.
 
+## Reproduce from source
+
+The [preprocessing folder](preprocessing/) contains the standalone code shared by all five prepared corpora. Its [README](preprocessing/README.md) explains how to download only that folder at a full commit revision, create the locked Linux x86-64 environment with Python 3.11.15, and record a full server build and verification. Folder access follows this repository's permissions. No parent project checkout, BigARTM or TopicNet installation is needed.
+
+Obtain approved access to the original `dongqi-me/SciNews` dataset and authenticate using standard Hugging Face credentials before downloading sources. Access to this preparation does not grant access to the original source. From the directory containing `preprocessing/`, run:
+
+```bash
+python preprocessing/prepare.py download --dataset scinews --sources-dir /path/to/sources
+python preprocessing/prepare.py build --dataset scinews \
+  --sources-dir /path/to/sources \
+  --output-dir /path/to/rebuilt/SciNews/data \
+  --scratch-dir /path/to/scratch/scinews
+python preprocessing/prepare.py verify --dataset scinews \
+  --data-dir /path/to/rebuilt/SciNews/data
+```
+
+The download provides pinned `scinews/README.md`, `train.json`, `val.json` and `test.json`, together with NLTK resources under the source directory. Build and verify run offline after setup. Choose fresh output and scratch paths. The output contains only `noow.csv`, `bow.csv`, `labels.json` and `splits.json`; verification compares them with the recorded SHA-256 values. Builds refuse to overwrite outputs. Preserve failed output and scratch files, and use fresh paths for a retry. The code's separate [MIT license](preprocessing/LICENSE) does not change the source-text rights or access terms below.
+
 ## Loading and metadata
 
 The default configuration is `noow`; `bow` contains aggregated counts. Both expose the complete population as the Hugging Face split `corpus`. Labels and the stored fit/calibration/validation memberships are auxiliary files, joined by document ID. `data/labels.json` directly maps each string ID to a list of string labels; `data/splits.json` directly maps each split name to an ordered ID list.

SHA256SUMS

@@ -1,7 +1,19 @@
 947f03cf79a99d7f9061220c575021c918ae95f64ab75c4112917be804fb51cd  .gitattributes
-6291c21604daa190fbd5f38f09bb6fff461291d8a17a7eda13882462846498ca  README.md
+735681b0b89f7ece379a3c17c12d446d072e8690e88a80da0aa626605b903d52  README.md
 dffd02d522c1cb894d4fd1eebe0e4b6098d045fac77755fc8f49341388b32750  SOURCE_README.md
 45f086796ca39994272e11a31a601ac2b8e91536f9bd812ce849be4c55042537  data/bow.csv
 b9959f976605f8b418f6565fec8228e1bfbb0e8a7c314f0d1cf9b79258e9ac7c  data/labels.json
 1583bd93c7c5ef660fb18b255984d8a0caf721f8ac21026d40536f673a73ecbe  data/noow.csv
 d2e221cca3c7297d5b84f0d18dc2a7ba448e3775e33ff96a5e4bd30b33d13400  data/splits.json
+6feaded4e28ea86e001a6751b4e3d960e8b7c31b9616ff9936b79297086e809b  preprocessing/.gitignore
+15eb97925fe33f7fe096b36f95a5b19e66041101ba35d0dd4948cc8f3e0528e0  preprocessing/LICENSE
+1c947d9d405f7031654d0ca900eba7c71b1adbb8675d1939c3dd1b9aa4be46e7  preprocessing/README.md
+85821876745568dee4cfb46b7d49843ace0390b89d761fa2fc76e21d5b65efee  preprocessing/_pipeline.py
+d6d1374d3ea144edc3fd5285ba87dac4daa9dea2857d0f165c6d0943a69a43fc  preprocessing/conda-linux-64.lock.txt
+7e301b934c9abe47e404e0935bc83129023a0ee31a9edbec2ea039d1c322ce22  preprocessing/payload-pins.json
+c34178178f5b77ca0f766a7965bac1c4d541ae510dacfb9915af4d0915e32ece  preprocessing/pip-linux-x86_64.lock.txt
+2d1368a94fe38ebe8cab804a50bde2fea71b3e43a769576a6dd6988b32c25a45  preprocessing/prepare.py
+02d7891df73d9d104efcc492489f76d3d1b9b4a00674b0b0bfd1529c8ab98c31  preprocessing/requirements-download.txt
+3ec34d3f3f4ce6fc02a12be33e49fce5c8f55adb7821c153074a26df93558b8f  preprocessing/requirements.txt
+443cffa24dd51d08039150cafcdf97bc45e7cabc5ea6bbb628000d563c09a26f  preprocessing/source-pins.json
+9e320475adc24f0757381f57521d36abd4b5d65087205c8d5c58ba3b39d1b10d  preprocessing/test_prepare.py

preprocessing/.gitignore

@@ -0,0 +1,2 @@
+__pycache__/
+*.py[cod]

preprocessing/LICENSE

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

preprocessing/README.md

@@ -0,0 +1,210 @@
+# Reproduce the prepared corpora
+
+This folder contains the standalone preprocessing code shared by SciNews,
+BBC-News, WOS-5736, WOS-11967 and WOS-46985. It downloads pinned source files,
+rebuilds the CSV and JSON files described in the dataset cards, and checks the
+result against the recorded SHA-256 values. It needs no parent project checkout,
+BigARTM, TopicNet installation or model training.
+
+The code is distributed under [MIT](LICENSE). This license covers the code only.
+Source texts and prepared data retain their own rights and access conditions;
+consult the corresponding dataset card and original source notices. In
+particular, SciNews requires approved access to the original dataset, and BBC
+redistribution rights remain unresolved.
+
+## Obtain only the code
+
+The common code lives in `preprocessing/` in the `TopicNet/SciNews` dataset
+repository. Access to this folder follows access to that repository. Authenticate
+with an authorized Hugging Face account if required; downloading the folder does
+not change repository visibility or grant access to the original SciNews source.
+
+Choose a full commit hash from the repository history that contains this folder.
+Set `CODE_REVISION` to that hash, rather than relying on a moving `main` branch.
+Use a separate download environment with the official `huggingface_hub` SDK for
+this initial download (`python -m pip install huggingface_hub==1.25.1`):
+
+```bash
+export CODE_REVISION=REPLACE_WITH_FULL_COMMIT_HASH
+python - <<'PY'
+import os
+from huggingface_hub import snapshot_download
+
+snapshot_download(
+    repo_id="TopicNet/SciNews",
+    repo_type="dataset",
+    revision=os.environ["CODE_REVISION"],
+    allow_patterns=["preprocessing/*"],
+    local_dir="corpus-code",
+)
+PY
+cd corpus-code
+```
+
+This downloads the code folder, not the prepared SciNews CSV files. Before the
+code is published, use the local copy of `SciNews/preprocessing/` instead and
+work from its parent directory. A Hugging Face commit containing new code is
+available only after that code has been committed to the dataset repository.
+
+## Create the environment
+
+The supplied locks target Linux x86-64 with Python 3.11.15. Create a dedicated
+environment with Conda, then install the locked Python packages:
+
+```bash
+conda create --prefix /path/to/envs/corpus-preprocessing --file preprocessing/conda-linux-64.lock.txt
+conda activate /path/to/envs/corpus-preprocessing
+python -m pip install -r preprocessing/pip-linux-x86_64.lock.txt
+```
+
+Place the environment outside the downloaded code folder. Keep the locks
+unchanged for byte-for-byte reproduction. Scientific dependencies
+and NLTK resources are checked by the program. NLTK 3.9.2 uses the resource
+revision recorded in the cards and source pins. The Hugging Face download SDK is
+an optional network dependency, specified in
+`preprocessing/requirements-download.txt`; install it when downloading SciNews:
+
+```bash
+python -m pip install -r preprocessing/requirements-download.txt
+```
+
+## Download sources
+
+Choose a writable source directory. The supported dataset selectors are
+`bbc-news`, `scinews`, `wos-5736`, `wos-11967` and `wos-46985`:
+
+```bash
+python preprocessing/prepare.py download --dataset bbc-news --sources-dir /path/to/sources
+python preprocessing/prepare.py download --dataset scinews --sources-dir /path/to/sources
+python preprocessing/prepare.py download --dataset wos-5736 --sources-dir /path/to/sources
+```
+
+The three WOS selectors share the same source archive, so download it once.
+Before the WOS download command, obtain the original `ReadMe.txt` notice from
+the [official version 6 release](https://data.mendeley.com/datasets/9rw3vkcfy4/6)
+and place it at `/path/to/sources/wos/ReadMe.txt`. Preserve its exact bytes:
+2,587 bytes, SHA-256
+`6da4ab1e624c4ef61c46600d727770f873ff4db3c15541fb481e7af8a715c0ec`.
+You can copy `SOURCE_README.txt` unchanged from any of the provided WOS packages
+to this path; all three packages contain the same notice with this exact hash.
+The notice requires this manual step because its stable download URL could not
+be confirmed. The program validates it, then downloads and validates the archive;
+it stops with placement instructions if the notice is absent.
+Downloads also provide the pinned NLTK resources. For SciNews, first obtain
+approval at the original `dongqi-me/SciNews` repository and authenticate through
+the standard Hugging Face login or `HF_TOKEN` environment variable. Approval for
+one repository does not imply approval for another. Keep credentials out of
+logs and copied source directories.
+
+The downloaded layout is:
+
+```text
+sources/
+  bbc-news/bbc-fulltext.zip
+  scinews/README.md
+  scinews/train.json
+  scinews/val.json
+  scinews/test.json
+  wos/WebOfScience.zip
+  wos/ReadMe.txt
+  nltk_data/
+```
+
+Only the selected corpus and shared NLTK resources are needed for each build.
+Source revisions, URLs and expected hashes are recorded in this code folder;
+substituting a newer source release changes the input and is rejected. If source
+files are transferred manually, preserve this layout and their exact bytes.
+
+## Build and verify offline
+
+After downloading sources and installing the environment, build and verify need
+no network connection. Select a fresh output path and a fresh scratch path. The
+output directory holds `noow.csv`, `bow.csv`, `labels.json` and `splits.json`,
+plus `hierarchy.json` for WOS. These correspond to the files under `data/` in
+the respective dataset repository. Scratch files are kept separately.
+
+```bash
+export HF_HUB_OFFLINE=1
+export HF_DATASETS_OFFLINE=1
+python preprocessing/prepare.py build --dataset bbc-news \
+  --sources-dir /path/to/sources \
+  --output-dir /path/to/rebuilt/BBC-News/data \
+  --scratch-dir /path/to/scratch/bbc-news
+python preprocessing/prepare.py verify --dataset bbc-news \
+  --data-dir /path/to/rebuilt/BBC-News/data
+```
+
+Use the same commands with any supported selector. Verification checks the
+recorded hashes of the prepared data files, including split memberships and WOS
+hierarchy metadata; it does not download missing inputs or rebuild files. A
+successful build alone is not a successful verification. The dataset-level
+`sha256sum -c SHA256SUMS` checks a complete downloaded repository package,
+including its card and source notice, and is separate from verifying a rebuild.
+
+Missing output and scratch parent directories are created after input and path
+validation. Both destination directories themselves must be new.
+Builds refuse to overwrite existing outputs. If a build fails, retain its output,
+scratch files and log for diagnosis. Use new output and scratch paths for a
+manual retry; do not treat a partial directory as a verified result.
+
+## Run the bundled checks
+
+From the directory containing `preprocessing/`, run the checks with Python's
+standard `unittest` runner; no additional test dependency is needed:
+
+```bash
+python -B -m unittest discover -v -s preprocessing -p test_prepare.py
+PORTABLE_NLTK_DATA=/absolute/path/to/sources/nltk_data \
+  python -B -m unittest discover -v -s preprocessing -p test_prepare.py
+```
+
+The first command skips the three checks requiring real NLTK resources. The
+second runs all six checks with the locked environment and acquired resources.
+Full rebuilds from the raw sources followed by exact hash verification have been
+confirmed for BBC-News and WOS-5736. Full SciNews, WOS-11967 and WOS-46985
+reproduction is pending server verification; fixture checks and source pins alone
+do not establish byte-for-byte reproduction of those builds.
+
+## Run the remaining full builds on a server
+
+Transfer this entire code folder and the relevant downloaded sources, including
+`nltk_data/`, to the server. Recreate the locked environment there using the
+commands above. Run from the directory containing `preprocessing/`. Choose paths
+on a filesystem with enough space for source archives, temporary files and both
+CSV representations. These full builds may take substantially longer than a
+small-corpus run; no fixed time or memory limit is assumed here.
+
+The following Bash example records build and verification logs separately and
+stops if either command fails. Replace the paths before running; all output,
+scratch and log paths must be fresh:
+
+```bash
+set -euo pipefail
+export HF_HUB_OFFLINE=1
+export HF_DATASETS_OFFLINE=1
+SOURCE_ROOT=/srv/corpus-sources
+RUN_ROOT=/srv/corpus-rebuild-001
+mkdir "$RUN_ROOT"
+mkdir "$RUN_ROOT/logs"
+
+python --version > "$RUN_ROOT/logs/python.txt" 2>&1
+python -m pip freeze > "$RUN_ROOT/logs/packages.txt"
+find preprocessing -type f ! -path '*/__pycache__/*' ! -name '*.pyc' -print0 \
+  | sort -z | xargs -0 sha256sum > "$RUN_ROOT/logs/code-sha256.txt"
+
+for DATASET in scinews wos-11967 wos-46985; do
+  python preprocessing/prepare.py build --dataset "$DATASET" \
+    --sources-dir "$SOURCE_ROOT" \
+    --output-dir "$RUN_ROOT/$DATASET/data" \
+    --scratch-dir "$RUN_ROOT/$DATASET-scratch" \
+    2>&1 | tee "$RUN_ROOT/logs/$DATASET-build.log"
+  python preprocessing/prepare.py verify --dataset "$DATASET" \
+    --data-dir "$RUN_ROOT/$DATASET/data" \
+    2>&1 | tee "$RUN_ROOT/logs/$DATASET-verify.log"
+done
+```
+
+Retain the chosen code commit hash with these logs. Count a corpus as reproduced
+only after its verification command exits successfully. If a command fails, the
+loop stops and preserves its existing files; choose a new run directory when
+retrying.

preprocessing/_pipeline.py

@@ -0,0 +1,358 @@
+"""Portable, disk-backed reproduction of the five published preparations.
+
+The CLI validates source and resource hashes before calling :func:`build`.
+Only new output/scratch directories are written; failed runs are left for inspection.
+"""
+from __future__ import annotations
+
+from collections import Counter, defaultdict
+from contextlib import ExitStack
+import csv
+import io
+import itertools
+import json
+from pathlib import Path
+import re
+import sqlite3
+import zipfile
+
+
+class EnglishPreprocessor:
+    """Use local NLTK resources and preserve the original occurrence semantics."""
+
+    def __init__(self, nltk_data_path: Path):
+        import nltk
+        from nltk.corpus.reader import WordNetCorpusReader
+        from nltk.data import ZipFilePathPointer
+        from nltk.tag import PerceptronTagger
+        from nltk.tokenize import WordPunctTokenizer
+
+        class LocalWordNetReader(WordNetCorpusReader):
+            def map_wn(self, version="wordnet"):
+                return None
+
+        if nltk.__version__ != "3.9.2":
+            raise ValueError("NLTK 3.9.2 is required")
+        root = Path(nltk_data_path)
+        self.tokenizer = WordPunctTokenizer()
+        self.tagger = PerceptronTagger(load=False)
+        self.tagger.load_from_json(loc=str(root / "taggers/averaged_perceptron_tagger_eng"))
+        self.wordnet = LocalWordNetReader(
+            ZipFilePathPointer(str(root / "corpora/wordnet.zip"), "wordnet/"), None,
+        )
+        self.stopwords = frozenset((root / "corpora/stopwords/english").read_text(
+            encoding="utf-8").splitlines())
+
+    def occurrences(self, raw_text: str) -> tuple[dict[str, object], ...]:
+        spans = tuple((start, end) for start, end in self.tokenizer.span_tokenize(raw_text)
+                      if len(raw_text[start:end].lower()) > 1)
+        tagged = self.tagger.tag([raw_text[start:end].lower() for start, end in spans])
+        output = []
+        for (start, end), (word, tag) in zip(spans, tagged, strict=True):
+            pos = {"J": "a", "V": "v", "N": "n", "R": "r"}.get(tag[:1], "n")
+            lemmas = self.wordnet._morphy(word, pos)
+            lemma = min(lemmas, key=len) if lemmas else word
+            if lemma not in self.stopwords and lemma.isalpha():
+                output.append({"lemma": lemma, "start": start, "end": end,
+                               "occurrence_index": len(output)})
+        return tuple(output)
+
+
+def _json_records(path: Path):
+    """Decode a JSON array incrementally, including strict framing checks."""
+    def object_pairs(pairs):
+        result = {}
+        for key, value in pairs:
+            if key in result:
+                raise ValueError("Duplicate JSON object key")
+            result[key] = value
+        return result
+
+    def invalid_constant(value):
+        raise ValueError(f"Invalid JSON constant: {value}")
+
+    decoder = json.JSONDecoder(object_pairs_hook=object_pairs, parse_constant=invalid_constant)
+    with path.open(encoding="utf-8", errors="strict") as stream:
+        buffer, eof = "", False
+
+        def fill():
+            nonlocal buffer, eof
+            chunk = stream.read(65536)
+            buffer += chunk
+            eof = not chunk
+
+        def whitespace():
+            nonlocal buffer
+            buffer = buffer.lstrip(" \t\r\n")
+            while not buffer and not eof:
+                fill()
+                buffer = buffer.lstrip(" \t\r\n")
+
+        whitespace()
+        if not buffer.startswith("["):
+            raise ValueError("SciNews JSON must contain an array")
+        buffer = buffer[1:]
+        whitespace()
+        if buffer.startswith("]"):
+            buffer = buffer[1:]
+        else:
+            while True:
+                while True:
+                    try:
+                        record, end = decoder.raw_decode(buffer)
+                        break
+                    except json.JSONDecodeError:
+                        if eof:
+                            raise
+                        fill()
+                buffer = buffer[end:]
+                yield record
+                whitespace()
+                if buffer.startswith("]"):
+                    buffer = buffer[1:]
+                    break
+                if not buffer.startswith(","):
+                    raise ValueError("Invalid SciNews array separator")
+                buffer = buffer[1:]
+                whitespace()
+                if buffer.startswith("]"):
+                    raise ValueError("Trailing comma in SciNews array")
+        whitespace()
+        if buffer:
+            raise ValueError("Trailing content in SciNews JSON")
+
+
+def _source_rows(dataset: str, source_path: Path):
+    """Yield id, original body/title, external labels, URL and normalized DOI."""
+    if dataset == "scinews":
+        for split in ("train", "val", "test"):
+            for index, record in enumerate(_json_records(source_path / f"{split}.json")):
+                fields = {"News_Title", "News_Body", "News_URL", "Citation", "DOI",
+                          "Paper_URL", "Paper_Body", "Topic"}
+                topics = {"Biology", "Chemistry", "Computer", "Earth", "Medicine",
+                          "Nano", "Other", "Physics", "Space"}
+                if (not isinstance(record, dict) or set(record) != fields
+                        or any(type(value) is not str for value in record.values())
+                        or record["Topic"] not in topics):
+                    raise ValueError(f"Invalid SciNews record schema: {split}:{index}")
+                doi = record["DOI"].strip().casefold()
+                doi = re.sub(r"^(?:doi:\s*|https?://(?:dx\.)?doi\.org/)", "", doi, count=1)
+                yield (f"scinews_{split}_{index:06d}", record["News_Body"],
+                       record["News_Title"], record["Topic"], "", "", record["News_URL"], doi)
+    elif dataset == "bbc-news":
+        with zipfile.ZipFile(source_path) as archive:
+            for name in archive.namelist():
+                match = re.fullmatch(r"bbc/(business|entertainment|politics|sport|tech)/([0-9]{3})\.txt", name)
+                if match is None:
+                    continue
+                label, stem = match.groups()
+                text = archive.read(name).decode("utf-8", errors="strict")
+                parts = re.split(r"\r?\n[ \t]*\r?\n", text, maxsplit=1)
+                if len(parts) != 2 or not parts[0] or "\n" in parts[0] or "\r" in parts[0]:
+                    raise ValueError(f"Invalid BBC title/body layout: {name}")
+                yield f"bbc_{label}_{stem}", parts[1], parts[0], label, "", "", "", ""
+    else:
+        subset = dataset.removeprefix("wos-")
+        with zipfile.ZipFile(source_path) as archive, ExitStack() as stack:
+            streams = [stack.enter_context(io.TextIOWrapper(
+                archive.open(f"WOS{subset}/{field}.txt"), encoding="utf-8", errors="strict", newline=""))
+                for field in ("X", "Y", "YL1", "YL2")]
+            for index, lines in enumerate(itertools.zip_longest(*streams)):
+                if any(line is None for line in lines):
+                    raise ValueError("WOS source rows are misaligned")
+                body, label, parent, child = [
+                    line[:-2] if line.endswith("\r\n") else
+                    line[:-1] if line.endswith(("\n", "\r")) else line for line in lines]
+                if any(re.fullmatch(r"0|[1-9][0-9]*", value) is None
+                       for value in (label, parent, child)):
+                    raise ValueError("Noncanonical WOS integer label")
+                yield f"wos{subset}_{index:06d}", body, "", label, parent, child, "", ""
+
+
+def _shuffle_split(labels_by_id, test_size, seed):
+    ids = tuple(sorted(labels_by_id))
+    labels = tuple(sorted({label for values in labels_by_id.values() for label in values}))
+    matrix = [[label in labels_by_id[identifier] for label in labels] for identifier in ids]
+    if len(labels) < 2:
+        from sklearn.model_selection import StratifiedShuffleSplit
+        splitter = StratifiedShuffleSplit(n_splits=1, test_size=test_size, random_state=seed)
+        train, test = next(splitter.split([[0]] * len(ids), [row[0] if row else False for row in matrix]))
+    else:
+        from iterstrat.ml_stratifiers import MultilabelStratifiedShuffleSplit
+        splitter = MultilabelStratifiedShuffleSplit(n_splits=1, test_size=test_size, random_state=seed)
+        train, test = next(splitter.split([[0]] * len(ids), matrix))
+    return [ids[index] for index in train], [ids[index] for index in test]
+
+
+def build(dataset: str, source_path: Path, nltk_data_path: Path,
+          output_dir: Path, scratch_dir: Path) -> None:
+    """Rebuild one preparation into a new directory of directly usable files.
+
+    Hash validation belongs to the CLI. This API rejects existing destinations,
+    symlink paths and destination overlap with sources, resources or shipped code.
+    Concurrent replacement of directories by another process is outside its scope.
+    """
+    from nltk.tokenize import WordPunctTokenizer
+
+    if dataset not in {"bbc-news", "scinews", "wos-5736", "wos-11967", "wos-46985"}:
+        raise ValueError(f"Unknown dataset: {dataset}")
+    paths = [Path(path).absolute() for path in (source_path, nltk_data_path, output_dir, scratch_dir)]
+    for path in paths:
+        if any(part.is_symlink() for part in (path, *path.parents)):
+            raise ValueError(f"Symlink paths are not supported: {path}")
+    source_path, nltk_data_path, output_dir, scratch_dir = [path.resolve() for path in paths]
+    destinations = (output_dir, scratch_dir)
+    for path in destinations:
+        if path.exists():
+            raise ValueError(f"Destination must be new: {path}")
+    code = Path(__file__).resolve().parent
+    protected = [source_path, nltk_data_path, code]
+    # Also protect published sibling data when this folder is used in place.
+    protected.extend(code.parent.parent / name / "data" for name in
+                     ("SciNews", "BBC-News", "WOS-5736", "WOS-11967", "WOS-46985"))
+    for left, right in itertools.combinations(destinations, 2):
+        if left == right or left in right.parents or right in left.parents:
+            raise ValueError("Output and scratch paths overlap")
+    for destination in destinations:
+        for path in protected:
+            if destination == path or destination in path.parents or path in destination.parents:
+                raise ValueError(f"Destination overlaps protected path: {path}")
+    processor = EnglishPreprocessor(nltk_data_path)
+    for path in destinations:
+        path.parent.mkdir(parents=True, exist_ok=True)
+    scratch_dir.mkdir()
+    store = sqlite3.connect(scratch_dir / "processing.sqlite3")
+    try:
+        store.execute("PRAGMA cache_size=-65536")
+        store.execute("PRAGMA temp_store=MEMORY")
+        store.executescript("""
+            CREATE TABLE rows (id TEXT PRIMARY KEY, raw TEXT NOT NULL, title TEXT NOT NULL,
+                y TEXT NOT NULL, yl1 TEXT NOT NULL, yl2 TEXT NOT NULL,
+                url TEXT NOT NULL, doi TEXT NOT NULL, raw_identity TEXT NOT NULL,
+                lemmas TEXT, title_lemmas TEXT, reason TEXT, shingle_size INTEGER);
+            CREATE INDEX raw_idx ON rows(raw_identity,id);
+            CREATE INDEX lemma_idx ON rows(lemmas,id);
+            CREATE INDEX url_idx ON rows(url,id);
+            CREATE INDEX doi_idx ON rows(doi,id);
+            CREATE INDEX near_sizes ON rows(id,shingle_size);
+            CREATE TABLE shingles (identity TEXT, id TEXT,
+                PRIMARY KEY(identity,id)) WITHOUT ROWID;
+            CREATE TEMP TABLE current_shingles (identity TEXT PRIMARY KEY) WITHOUT ROWID;
+        """)
+        print(f"{dataset}: reading original source", flush=True)
+        for row in _source_rows(dataset, source_path):
+            identifier, raw, title, label, parent, child, url, doi = row
+            store.execute("""INSERT INTO rows
+                (id,raw,title,y,yl1,yl2,url,doi,raw_identity) VALUES (?,?,?,?,?,?,?,?,?)""",
+                          (*row, " ".join(raw.casefold().split())))
+        store.commit()
+        parents = {identifier: identifier for (identifier,) in store.execute("SELECT id FROM rows")}
+
+        def root(identifier):
+            while parents[identifier] != identifier:
+                parents[identifier] = parents[parents[identifier]]
+                identifier = parents[identifier]
+            return identifier
+
+        def connect(ids):
+            roots = {root(identifier) for identifier in ids}
+            minimum = min(roots)
+            for identifier in roots:
+                parents[identifier] = minimum
+
+        for field, condition in (("raw_identity", "1"), ("url", "url != ''"), ("doi", "doi != ''")):
+            cursor = store.execute(f"SELECT {field},id,y FROM rows WHERE {condition} ORDER BY {field},id")
+            for _, members in itertools.groupby(cursor, lambda row: row[0]):
+                members = list(members)
+                ids = [row[1] for row in members]
+                if len(ids) > 1:
+                    connect(ids)
+                if field == "raw_identity":
+                    removed = ids[1:] if len({row[2] for row in members}) == 1 else ids
+                    store.executemany("UPDATE rows SET reason='raw' WHERE id=?", ((i,) for i in removed))
+        print(f"{dataset}: normalizing raw-clean documents", flush=True)
+        for count, (identifier, raw, title) in enumerate(store.execute(
+                "SELECT id,raw,title FROM rows WHERE reason IS NULL ORDER BY id"), 1):
+            lemmas = " ".join(str(item["lemma"]) for item in processor.occurrences(raw))
+            title_lemmas = " ".join(str(item["lemma"]) for item in processor.occurrences(title))
+            store.execute("UPDATE rows SET lemmas=?,title_lemmas=?,reason=? WHERE id=?",
+                          (lemmas, title_lemmas, None if lemmas else "empty", identifier))
+            if count % 1000 == 0:
+                print(f"{dataset}: normalized {count}", flush=True)
+        cursor = store.execute("SELECT lemmas,id,y FROM rows WHERE reason IS NULL ORDER BY lemmas,id")
+        for _, members in itertools.groupby(cursor, lambda row: row[0]):
+            members = list(members)
+            ids = [row[1] for row in members]
+            if len(ids) > 1:
+                connect(ids)
+            removed = ids[1:] if len({row[2] for row in members}) == 1 else ids
+            store.executemany("UPDATE rows SET reason='lemma' WHERE id=?", ((i,) for i in removed))
+        store.commit()
+        retained = [row[0] for row in store.execute("SELECT id FROM rows WHERE reason IS NULL ORDER BY id")]
+        print(f"{dataset}: grouping near duplicates among {len(retained)} retained documents", flush=True)
+        tokenizer = WordPunctTokenizer()
+        for count, identifier in enumerate(retained, 1):
+            raw = store.execute("SELECT raw FROM rows WHERE id=?", (identifier,)).fetchone()[0]
+            tokens = [token for token in tokenizer.tokenize(raw.lower()) if len(token) >= 2 and token.isalpha()]
+            shingles = {" ".join(tokens[index:index + 5]) for index in range(len(tokens) - 4)}
+            store.execute("DELETE FROM current_shingles")
+            store.executemany("INSERT INTO current_shingles VALUES (?)", ((s,) for s in shingles))
+            candidates = store.execute("""SELECT s.id,COUNT(*),r.shingle_size
+                FROM current_shingles c CROSS JOIN shingles s ON s.identity=c.identity
+                CROSS JOIN rows r INDEXED BY near_sizes ON r.id=s.id
+                GROUP BY s.id ORDER BY s.id""")
+            for previous, intersection, size in candidates:
+                union = len(shingles) + size - intersection
+                if intersection / union >= .9:
+                    connect((previous, identifier))
+            store.execute("INSERT INTO shingles SELECT identity,? FROM current_shingles", (identifier,))
+            store.execute("UPDATE rows SET shingle_size=? WHERE id=?", (len(shingles), identifier))
+            if count % 1000 == 0:
+                store.commit()
+                print(f"{dataset}: grouped {count}/{len(retained)}", flush=True)
+        store.commit()
+        families = defaultdict(list)
+        labels = dict((identifier, [label]) for identifier, label in store.execute(
+            "SELECT id,y FROM rows WHERE reason IS NULL ORDER BY id"))
+        for identifier in retained:
+            families[root(identifier)].append(identifier)
+        family_labels = {group: sorted({labels[i][0] for i in ids}) for group, ids in families.items()}
+        fit, heldout = _shuffle_split(family_labels, .4, 20260824)
+        calibration, validation = _shuffle_split({i: family_labels[i] for i in heldout}, .5, 20260825)
+        splits = {split: sorted(i for group in groups for i in families[group])
+                  for split, groups in (("fit", fit), ("calibration", calibration), ("validation", validation))}
+        output_dir.mkdir()
+        pretty = dataset in {"wos-5736", "wos-46985"}
+        for name, value in (("labels.json", labels), ("splits.json", splits)):
+            with (output_dir / name).open("x", encoding="utf-8", newline="") as stream:
+                json.dump(value, stream, ensure_ascii=False, sort_keys=True,
+                          **({"indent": 2} if pretty else {"separators": (",", ":")}))
+                stream.write("\n")
+        is_wos = dataset.startswith("wos-")
+        if is_wos:
+            hierarchy = {identifier: {"Y": y, "YL1": yl1, "YL2": yl2}
+                         for identifier, y, yl1, yl2 in store.execute(
+                             "SELECT id,y,yl1,yl2 FROM rows WHERE reason IS NULL ORDER BY id")}
+            with (output_dir / "hierarchy.json").open("x", encoding="utf-8", newline="") as stream:
+                json.dump(hierarchy, stream, ensure_ascii=False, sort_keys=True, indent=2)
+                stream.write("\n")
+        with (output_dir / "noow.csv").open("x", encoding="utf-8", newline="") as noow, \
+                (output_dir / "bow.csv").open("x", encoding="utf-8", newline="") as bow:
+            writers = [csv.writer(stream, lineterminator="\n") for stream in (noow, bow)]
+            for writer in writers:
+                writer.writerow(("id", "raw_text", "vw_text"))
+            for identifier, raw, title, lemmas, title_lemmas in store.execute(
+                    "SELECT id,raw,title,lemmas,title_lemmas FROM rows WHERE reason IS NULL ORDER BY id"):
+                namespaces = [("@word", lemmas.split())] if is_wos else [
+                    ("@title", title_lemmas.split()), ("@word", lemmas.split())]
+                fields, aggregated = [identifier], [identifier]
+                for namespace, tokens in namespaces:
+                    fields.extend(["|" + namespace, *tokens])
+                    counts = Counter(tokens)
+                    aggregated.extend(["|" + namespace, *(f"{token}:{counts[token]}" for token in sorted(counts))])
+                public_raw = raw if is_wos else title + "\n\n" + raw.lstrip("\r\n")
+                writers[0].writerow((identifier, public_raw, " ".join(fields)))
+                writers[1].writerow((identifier, public_raw, " ".join(aggregated)))
+        print(f"{dataset}: wrote {len(retained)} documents to {output_dir}", flush=True)
+    finally:
+        store.close()

preprocessing/conda-linux-64.lock.txt

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

preprocessing/payload-pins.json

@@ -0,0 +1,147 @@
+{
+  "datasets": {
+    "bbc-news": {
+      "documents": 2085,
+      "files": {
+        "bow.csv": {
+          "bytes": 7575728,
+          "sha256": "3d604bbbe7e2eb8907f162f87617ac38db413957067e558226bb132c2445100d"
+        },
+        "labels.json": {
+          "bytes": 64764,
+          "sha256": "946d3a4ad97fcbb7952d8e3cc8f8a16f5ebdfdfce904939bc7c86ddbef90676d"
+        },
+        "noow.csv": {
+          "bytes": 7897816,
+          "sha256": "96051e9d10faf1bebe1a3baeaeef5bc93e806cf0ad0fb9882e9574e5385931e4"
+        },
+        "splits.json": {
+          "bytes": 38677,
+          "sha256": "e5d4cdaf68abd6d38fb6965da40e1bfd1915ac476209f021a3218e0e8e626d6a"
+        }
+      },
+      "split_counts": {
+        "calibration": 419,
+        "fit": 1250,
+        "validation": 416
+      }
+    },
+    "scinews": {
+      "documents": 41854,
+      "files": {
+        "bow.csv": {
+          "bytes": 261941524,
+          "sha256": "45f086796ca39994272e11a31a601ac2b8e91536f9bd812ce849be4c55042537"
+        },
+        "labels.json": {
+          "bytes": 1455076,
+          "sha256": "b9959f976605f8b418f6565fec8228e1bfbb0e8a7c314f0d1cf9b79258e9ac7c"
+        },
+        "noow.csv": {
+          "bytes": 290845394,
+          "sha256": "1583bd93c7c5ef660fb18b255984d8a0caf721f8ac21026d40536f673a73ecbe"
+        },
+        "splits.json": {
+          "bytes": 950125,
+          "sha256": "d2e221cca3c7297d5b84f0d18dc2a7ba448e3775e33ff96a5e4bd30b33d13400"
+        }
+      },
+      "split_counts": {
+        "calibration": 8370,
+        "fit": 25109,
+        "validation": 8375
+      }
+    },
+    "wos-11967": {
+      "documents": 11965,
+      "files": {
+        "bow.csv": {
+          "bytes": 26653958,
+          "sha256": "4e27d8e46bad08061568222a0931b963f6ad637074b1b227de095af05757d339"
+        },
+        "hierarchy.json": {
+          "bytes": 881997,
+          "sha256": "5a4ab746cdc75b048143eb8aeac2660535bed1a23cca7d37a6e4775bb9b7d3b6"
+        },
+        "labels.json": {
+          "bytes": 295711,
+          "sha256": "138c7a5ed0ae4787afdbd306a7fd2732b392ad8db65c22e7ce312c33a178470c"
+        },
+        "noow.csv": {
+          "bytes": 28197299,
+          "sha256": "101d1c8a690ae0fe1b68491cb144ff42114280e12770f8a332647106bd12580e"
+        },
+        "splits.json": {
+          "bytes": 215411,
+          "sha256": "608c14b244f02df40b897dfc7de3411352079bed0a507f2fd8ccf70b9c5996d7"
+        }
+      },
+      "split_counts": {
+        "calibration": 2391,
+        "fit": 7182,
+        "validation": 2392
+      }
+    },
+    "wos-46985": {
+      "documents": 46972,
+      "files": {
+        "bow.csv": {
+          "bytes": 106747458,
+          "sha256": "039c213b7d7cc3dd2256418443bfc23a8a3e927eadd87ffe5ac08a34f692aebd"
+        },
+        "hierarchy.json": {
+          "bytes": 3503602,
+          "sha256": "1f714d3a953c7e3517f647f431d9a5d75f429b05574e66336166f2d5476a1f47"
+        },
+        "labels.json": {
+          "bytes": 1745914,
+          "sha256": "4ccc24e6f281cb85f6db04665a46d82072bdfb72a8485a814fd8182722b50a5d"
+        },
+        "noow.csv": {
+          "bytes": 113457365,
+          "sha256": "dba99ba99feaaf4de483969b64b5cd3bc1dca456cdcce367811517f69d251eff"
+        },
+        "splits.json": {
+          "bytes": 1080419,
+          "sha256": "4b10199d6da28e55713e324a4d9ef0264b6c6b131232d684649acf99e0132ee8"
+        }
+      },
+      "split_counts": {
+        "calibration": 9366,
+        "fit": 28181,
+        "validation": 9425
+      }
+    },
+    "wos-5736": {
+      "documents": 5735,
+      "files": {
+        "bow.csv": {
+          "bytes": 13177936,
+          "sha256": "fb9f0b1d6852c6cb23adf1a591cd836d35d3366765ad93d5dea31571b5d6f040"
+        },
+        "hierarchy.json": {
+          "bytes": 413622,
+          "sha256": "7b862eb58b8c3d2f21511cb16f4f380161609cf876bb857c617ff54fdc1352d6"
+        },
+        "labels.json": {
+          "bytes": 201427,
+          "sha256": "057ca6c26d7fb1ebaf99fca0a30aa527db494c1314616f13280b5595b7f2328b"
+        },
+        "noow.csv": {
+          "bytes": 13955503,
+          "sha256": "850bf83152a928576508396a6c7d3b77a79a271e6a32d6e27784c7a466ff6005"
+        },
+        "splits.json": {
+          "bytes": 126233,
+          "sha256": "21980ed4a909dd05e530ae0e55e093974eb321f2801d5e94f5a405a24584fb32"
+        }
+      },
+      "split_counts": {
+        "calibration": 1147,
+        "fit": 3439,
+        "validation": 1149
+      }
+    }
+  },
+  "schema_version": 1
+}

preprocessing/pip-linux-x86_64.lock.txt

@@ -0,0 +1,14 @@
+# Minimal runtime dependency closure, selected from the repository's
+# work/wintra/envs/wikigood-ru-pip-linux-x86_64.lock.txt.
+# Python 3.11.15, Linux x86_64. Version pins, not wheel-content hashes.
+click==8.5.0
+iterative-stratification==0.1.9
+joblib==1.5.3
+narwhals==2.25.0
+nltk==3.9.2
+numpy==2.4.6
+regex==2026.7.19
+scikit-learn==1.9.0
+scipy==1.17.1
+threadpoolctl==3.6.0
+tqdm==4.70.0

preprocessing/prepare.py

@@ -0,0 +1,258 @@
+#!/usr/bin/env python3
+"""Acquire pinned sources, reproduce the five datasets, or verify a payload offline."""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import hashlib
+import importlib.metadata
+import json
+import os
+from pathlib import Path
+import platform
+import shutil
+import stat
+import sys
+import tempfile
+import urllib.request
+import zipfile
+
+HERE = Path(__file__).resolve().parent
+DATASETS = ("bbc-news", "scinews", "wos-5736", "wos-11967", "wos-46985")
+RUNTIME = {
+    "nltk": "3.9.2", "numpy": "2.4.6", "scikit-learn": "1.9.0",
+    "iterative-stratification": "0.1.9", "scipy": "1.17.1", "joblib": "1.5.3",
+    "threadpoolctl": "3.6.0", "regex": "2026.7.19", "click": "8.5.0",
+    "tqdm": "4.70.0", "narwhals": "2.25.0",
+}
+
+
+def safe_path(value: str | Path) -> Path:
+    """Reject symlinks in both an existing path and its existing ancestors."""
+    path = Path(value).absolute()
+    for component in (path, *path.parents):
+        if component.is_symlink():
+            raise ValueError(f"Symlink is not allowed: {component}")
+    return Path(os.path.abspath(path))
+
+
+def check_file(path: Path, pin: dict | str) -> None:
+    path = safe_path(path)
+    if not path.is_file():
+        raise ValueError(f"Missing regular file: {path}")
+    expected = pin if isinstance(pin, str) else pin["sha256"]
+    if isinstance(pin, dict) and path.stat().st_size != pin["bytes"]:
+        raise ValueError(f"File size differs from pin: {path}")
+    with path.open("rb") as stream:
+        actual = hashlib.file_digest(stream, "sha256").hexdigest()
+    if actual != expected:
+        raise ValueError(f"SHA-256 differs from pin: {path}")
+
+
+def publish(part: Path, target: Path, pin: dict | str) -> None:
+    check_file(part, pin)
+    # A hard link publishes atomically and cannot overwrite an existing target.
+    os.link(part, target)
+    part.unlink()
+
+
+def fetch(url: str, target: Path, pin: dict) -> None:
+    target = safe_path(target)
+    if target.exists():
+        check_file(target, pin)
+        return
+    target.parent.mkdir(parents=True, exist_ok=True)
+    part = safe_path(target.with_name(target.name + ".part"))
+    # Exclusive creation preserves any interrupted or preexisting partial file.
+    with part.open("xb") as output:
+        try:
+            with urllib.request.urlopen(url, timeout=120) as response:
+                shutil.copyfileobj(response, output)
+        except Exception:
+            raise ValueError(f"Download failed for {target.name}; inspect {part}") from None
+    publish(part, target, pin)
+
+
+def verify(dataset: str, data_dir: Path) -> None:
+    data_dir = safe_path(data_dir)
+    if not data_dir.is_dir():
+        raise ValueError(f"Missing data directory: {data_dir}")
+    pins = json.loads((HERE / "payload-pins.json").read_text())["datasets"][dataset]
+    if {p.name for p in data_dir.iterdir()} != set(pins["files"]):
+        raise ValueError("Payload file inventory differs from pin")
+    for name, pin in pins["files"].items():
+        check_file(data_dir / name, pin)
+    labels = json.loads((data_dir / "labels.json").read_text())
+    splits = json.loads((data_dir / "splits.json").read_text())
+    if len(labels) != pins["documents"]:
+        raise ValueError("Document count differs from pin")
+    if {name: len(ids) for name, ids in splits.items()} != pins["split_counts"]:
+        raise ValueError("Split counts differ from pin")
+    csv.field_size_limit(sys.maxsize)
+    for name in ("bow.csv", "noow.csv"):
+        with (data_dir / name).open(newline="", encoding="utf-8") as stream:
+            rows = csv.reader(stream)
+            next(rows)
+            if sum(1 for _ in rows) != pins["documents"]:
+                raise ValueError(f"CSV row count differs from pin: {name}")
+    print(f"Verified {dataset}: {pins['documents']} documents")
+
+
+def download(dataset: str, root: Path, pins: dict) -> None:
+    root = safe_path(root)
+    root.mkdir(parents=True, exist_ok=True)
+    family = "wos" if dataset.startswith("wos-") else dataset
+    source = pins["sources"][family]
+    if family == "scinews":
+        missing = []
+        for name, pin in source["files"].items():
+            target = safe_path(root / family / name)
+            if target.exists():
+                check_file(target, pin)
+            else:
+                missing.append(name)
+        if missing:
+            if importlib.metadata.version("huggingface-hub") != "1.25.1":
+                raise ValueError("SciNews download requires huggingface-hub==1.25.1")
+            from huggingface_hub import hf_hub_download
+
+            # SDK handles authentication/redirects using the user's standard HF setup.
+            # Its local metadata and temporary files stay inside the acquisition root.
+            with tempfile.TemporaryDirectory(prefix=".scinews-download-", dir=root) as staging:
+                for name in missing:
+                    try:
+                        downloaded = hf_hub_download(
+                            repo_id=source["repo_id"], repo_type="dataset",
+                            revision=source["revision"], filename=name, local_dir=staging,
+                        )
+                    except Exception:
+                        raise ValueError(f"SciNews download failed for {name}; check standard HF access") from None
+                    target = safe_path(root / family / name)
+                    target.parent.mkdir(parents=True, exist_ok=True)
+                    part = safe_path(target.with_name(target.name + ".part"))
+                    with Path(downloaded).open("rb") as incoming, part.open("xb") as outgoing:
+                        shutil.copyfileobj(incoming, outgoing)
+                    publish(part, target, source["files"][name])
+    else:
+        for name, pin in source["files"].items():
+            target = safe_path(root / family / name)
+            if pin.get("manual"):
+                if not target.exists():
+                    raise ValueError(
+                        f"Obtain {name} from {source['release_url']} and place its exact bytes at "
+                        f"{target} ({pin['bytes']} bytes; SHA-256 {pin['sha256']}); "
+                        "then rerun download. This release notice requires manual acquisition."
+                    )
+                check_file(target, pin)
+            else:
+                fetch(pin["url"], target, pin)
+
+    for name, pin in pins["resource_archives"].items():
+        targets = pin.get("members", {"": pin.get("target")})
+        for relative in targets.values():
+            target = safe_path(root / "nltk_data" / relative)
+            if target.exists():
+                check_file(target, pins["resources"][relative])
+        if all((root / "nltk_data" / relative).exists() for relative in targets.values()):
+            continue
+        archive = root / "nltk_archives" / name
+        url = f"https://raw.githubusercontent.com/nltk/nltk_data/{pins['nltk_data_commit']}/packages/{name}"
+        fetch(url, archive, pin)
+        if "target" in pin:
+            target = safe_path(root / "nltk_data" / pin["target"])
+            target.parent.mkdir(parents=True, exist_ok=True)
+            part = safe_path(target.with_name(target.name + ".part"))
+            with archive.open("rb") as incoming, part.open("xb") as outgoing:
+                shutil.copyfileobj(incoming, outgoing)
+            publish(part, target, pin)
+        else:
+            with zipfile.ZipFile(archive) as zipped:
+                if len(zipped.namelist()) != len(set(zipped.namelist())):
+                    raise ValueError(f"Duplicate resource ZIP members: {name}")
+                for member, relative in pin["members"].items():
+                    target = safe_path(root / "nltk_data" / relative)
+                    if target.exists():
+                        continue
+                    info = zipped.getinfo(member)
+                    mode = info.external_attr >> 16
+                    if info.is_dir() or stat.S_ISLNK(mode):
+                        raise ValueError(f"Nonregular resource member: {member}")
+                    target.parent.mkdir(parents=True, exist_ok=True)
+                    part = safe_path(target.with_name(target.name + ".part"))
+                    with zipped.open(info) as incoming, part.open("xb") as outgoing:
+                        shutil.copyfileobj(incoming, outgoing)
+                    publish(part, target, pins["resources"][relative])
+    print(f"Downloaded and verified sources/resources for {dataset}")
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    subparsers = parser.add_subparsers(dest="command", required=True)
+    for command in ("download", "build", "verify"):
+        sub = subparsers.add_parser(command)
+        sub.add_argument("--dataset", choices=DATASETS, required=True)
+        if command == "verify":
+            sub.add_argument("--data-dir", type=Path, required=True)
+        else:
+            sub.add_argument("--sources-dir", type=Path, required=True)
+        if command == "build":
+            sub.add_argument("--output-dir", type=Path, required=True)
+            sub.add_argument("--scratch-dir", type=Path, required=True)
+    args = parser.parse_args(argv)
+    try:
+        if args.command == "verify":
+            verify(args.dataset, args.data_dir)
+            return
+        pins = json.loads((HERE / "source-pins.json").read_text())
+        root = safe_path(args.sources_dir)
+        if args.command == "download":
+            download(args.dataset, root, pins)
+            return
+        output = safe_path(args.output_dir)
+        scratch = safe_path(args.scratch_dir)
+        for left, right in ((root, output), (root, scratch), (output, scratch)):
+            if left == right or left in right.parents or right in left.parents:
+                raise ValueError("Sources, output and scratch paths must not overlap")
+        # Protect the package/code and pins, including output ancestors of HERE.
+        for path in (output, scratch):
+            if path == HERE or path in HERE.parents or HERE in path.parents:
+                raise ValueError("Output/scratch must be outside the preprocessing package")
+            if path.exists():
+                raise ValueError(f"Output/scratch must be new: {path}")
+        family = "wos" if args.dataset.startswith("wos-") else args.dataset
+        for name, pin in pins["sources"][family]["files"].items():
+            check_file(root / family / name, pin)
+        nltk_data = safe_path(root / "nltk_data")
+        for name, pin in pins["resources"].items():
+            check_file(nltk_data / name, pin)
+        source_path = root / family
+        if family == "bbc-news":
+            source_path /= "bbc-fulltext.zip"
+        if family == "wos":
+            source_path /= "WebOfScience.zip"
+            with zipfile.ZipFile(source_path) as archive:
+                if len(archive.namelist()) != len(set(archive.namelist())):
+                    raise ValueError("Duplicate WOS ZIP members")
+                for name, expected in pins["sources"][family]["member_sha256"].items():
+                    info = archive.getinfo(name)
+                    if info.is_dir() or stat.S_ISLNK(info.external_attr >> 16):
+                        raise ValueError(f"Nonregular WOS member: {name}")
+                    with archive.open(info) as stream:
+                        if hashlib.file_digest(stream, "sha256").hexdigest() != expected:
+                            raise ValueError(f"WOS member hash differs: {name}")
+        if platform.python_version() != "3.11.15":
+            raise ValueError("Build requires Python 3.11.15")
+        for name, expected in RUNTIME.items():
+            if importlib.metadata.version(name) != expected:
+                raise ValueError(f"Build requires {name}=={expected}")
+        from _pipeline import build
+
+        build(args.dataset, source_path, nltk_data, output, scratch)
+        verify(args.dataset, output)
+    except (OSError, ValueError, KeyError, ImportError, zipfile.BadZipFile, importlib.metadata.PackageNotFoundError) as error:
+        parser.exit(1, f"Error: {error}\n")
+
+
+if __name__ == "__main__":
+    main()

preprocessing/requirements-download.txt

@@ -0,0 +1,3 @@
+# Optional: only the SciNews acquisition command imports the Hugging Face SDK.
+# Its installed metadata requires Python >=3.10.0, compatible with Python 3.11.15.
+huggingface_hub==1.25.1

preprocessing/requirements.txt

@@ -0,0 +1,5 @@
+# Python 3.11.15; runtime dependencies only. See pip-linux-x86_64.lock.txt.
+iterative-stratification==0.1.9
+nltk==3.9.2
+numpy==2.4.6
+scikit-learn==1.9.0

preprocessing/source-pins.json

@@ -0,0 +1,96 @@
+{
+  "nltk_data_commit": "550b6625bcef1f2abff2ff770a5a0d272c9c6b2a",
+  "resource_archives": {
+    "corpora/stopwords.zip": {
+      "bytes": 37733,
+      "members": {
+        "stopwords/english": "corpora/stopwords/english"
+      },
+      "sha256": "48c0e52d8b52546e827f53761fb30300c0ab94f70660d28bd65ba0a86270946b"
+    },
+    "corpora/wordnet.zip": {
+      "bytes": 10775600,
+      "sha256": "cbda5ea6eef7f36a97a43d4a75f85e07fccbb4f23657d27b4ccbc93e2646ab59",
+      "target": "corpora/wordnet.zip"
+    },
+    "taggers/averaged_perceptron_tagger_eng.zip": {
+      "bytes": 1539115,
+      "members": {
+        "averaged_perceptron_tagger_eng/averaged_perceptron_tagger_eng.classes.json": "taggers/averaged_perceptron_tagger_eng/averaged_perceptron_tagger_eng.classes.json",
+        "averaged_perceptron_tagger_eng/averaged_perceptron_tagger_eng.tagdict.json": "taggers/averaged_perceptron_tagger_eng/averaged_perceptron_tagger_eng.tagdict.json",
+        "averaged_perceptron_tagger_eng/averaged_perceptron_tagger_eng.weights.json": "taggers/averaged_perceptron_tagger_eng/averaged_perceptron_tagger_eng.weights.json"
+      },
+      "sha256": "6025f530624335c67d6547d44757b357b4e79bae030a0383e9887a92c1718f0b"
+    }
+  },
+  "resources": {
+    "corpora/stopwords/english": "f6d005956f407dbc6ea32e5ff0c7e8e6f71488d3239b9023efdc7fc139d6375b",
+    "corpora/wordnet.zip": "cbda5ea6eef7f36a97a43d4a75f85e07fccbb4f23657d27b4ccbc93e2646ab59",
+    "taggers/averaged_perceptron_tagger_eng/averaged_perceptron_tagger_eng.classes.json": "d152ffa69d45b8357276341a3d592c6c025911d52ec0d9068d4f382560dd48b6",
+    "taggers/averaged_perceptron_tagger_eng/averaged_perceptron_tagger_eng.tagdict.json": "4c713731cb06727736962bc8cd94ad919217a040e76691059af99bc0c2c9c246",
+    "taggers/averaged_perceptron_tagger_eng/averaged_perceptron_tagger_eng.weights.json": "789e8e35f6fac656d9b7eccea29ba4e8a137cbb5b525dd31f39e4291a9e80832"
+  },
+  "schema_version": 1,
+  "sources": {
+    "bbc-news": {
+      "files": {
+        "bbc-fulltext.zip": {
+          "bytes": 2874079,
+          "sha256": "a351031a62325b3d7ff13146eeb035c22feca8290913b5183d1ff3be35109495",
+          "url": "https://derekgreene.com/datasets/bbc-fulltext.zip"
+        }
+      }
+    },
+    "scinews": {
+      "files": {
+        "README.md": {
+          "bytes": 4933,
+          "sha256": "dffd02d522c1cb894d4fd1eebe0e4b6098d045fac77755fc8f49341388b32750"
+        },
+        "test.json": {
+          "bytes": 205514917,
+          "sha256": "5fe7904c0495b85862d24637ad148773a13c4d05a90a48d9b737b0c7d80cca86"
+        },
+        "train.json": {
+          "bytes": 1655263757,
+          "sha256": "5fcd9dcddeb7bebb4c42207f228d59f5c04a189886de93110e5484d2e8f6ada7"
+        },
+        "val.json": {
+          "bytes": 210282099,
+          "sha256": "13ea59e6103258d890d88dd5231462594ce18aec2a98ae39e241af388a4886d6"
+        }
+      },
+      "repo_id": "dongqi-me/SciNews",
+      "revision": "160772e163f6f60edade970ca98c56d3f7b59e69"
+    },
+    "wos": {
+      "files": {
+        "ReadMe.txt": {
+          "bytes": 2587,
+          "manual": true,
+          "sha256": "6da4ab1e624c4ef61c46600d727770f873ff4db3c15541fb481e7af8a715c0ec"
+        },
+        "WebOfScience.zip": {
+          "bytes": 60222421,
+          "sha256": "b787d484bff88b0dcdb3fa291d06ec9d2f025dc2a67ce1045d0c688cd96ccf8a",
+          "url": "https://data.mendeley.com/public-files/datasets/9rw3vkcfy4/files/c9ea673d-5542-44c0-ab7b-f1311f7d61df/file_downloaded"
+        }
+      },
+      "member_sha256": {
+        "WOS11967/X.txt": "833085410372994270db7c89a2db68052f52881c61ec5be0b349073365da832b",
+        "WOS11967/Y.txt": "291143bab8b07b412a3f61d1c0eadda9ff9b0ca2945e8fa19869e0fb2a00fad7",
+        "WOS11967/YL1.txt": "8360c1650fa3de9d8b363b9dd3d6d445a359c1bb26ae54986750298b7d961392",
+        "WOS11967/YL2.txt": "4524586479bfb3cdf96c0e1cc517537278bddb56f15d3f6331fb5e3a52c298ee",
+        "WOS46985/X.txt": "82cc4794b57795cb548f751aeb2efb500e77b9440be705c410e7a59b42e02ce2",
+        "WOS46985/Y.txt": "627d5f638ed48707a914c7cbba9e9cc833e747b76117a559c0bbb759b7b95096",
+        "WOS46985/YL1.txt": "691872ed9eb092024956ad719b49408e095f7752cecb1d7dcd0641af61c18e6a",
+        "WOS46985/YL2.txt": "0d1e3bf61822a16d75c6caefaea4a65874a32f9791f9b0d53f488ffe5d3af152",
+        "WOS5736/X.txt": "4e5c1bcc8a7684c7f59976dae225afda5bc1c6f656f49cbef27ccb6befcced89",
+        "WOS5736/Y.txt": "99a1ff099023572d04d43f19c705e3f239b2fbe414b2292d2bc650e20b856c8f",
+        "WOS5736/YL1.txt": "fd2e1ed1bcff7918174f432a28c3db630a66bd254f2b5a0bc86dfc36c0fed21a",
+        "WOS5736/YL2.txt": "20af3bbf37b2bba329b5c43733cc68b02dd0c74f3c86635992dcb296a5f13916"
+      },
+      "release_url": "https://data.mendeley.com/datasets/9rw3vkcfy4/6"
+    }
+  }
+}

preprocessing/test_prepare.py

@@ -0,0 +1,216 @@
+"""Portable checks: python -m unittest -v test_prepare.
+
+Set PORTABLE_NLTK_DATA to the acquired nltk_data directory to include real NLP
+and fixture builds. No checkout-relative resources or downloads are assumed.
+"""
+import csv
+import hashlib
+import json
+import os
+from pathlib import Path
+import shutil
+import subprocess
+import sys
+import tempfile
+import unittest
+import zipfile
+
+import _pipeline
+
+HERE = Path(__file__).resolve().parent
+RESOURCES = os.environ.get("PORTABLE_NLTK_DATA")
+
+
+def record(body, topic="Physics", title="", url="", doi=""):
+    return dict(News_Title=title, News_Body=body, News_URL=url, Citation="",
+                DOI=doi, Paper_URL="", Paper_Body="", Topic=topic)
+
+
+def write_scinews(directory, rows):
+    directory.mkdir()
+    for split in ("train", "val", "test"):
+        (directory / (split + ".json")).write_text(
+            json.dumps(rows if split == "train" else []), encoding="utf-8")
+
+
+class SourceChecks(unittest.TestCase):
+    def test_source_framing_and_external_labels(self):
+        """Source readers preserve body/title, canonical IDs and WOS local labels."""
+        with tempfile.TemporaryDirectory() as temporary:
+            root = Path(temporary)
+            archive = root / "bbc.zip"
+            with zipfile.ZipFile(archive, "w") as zipped:
+                zipped.writestr("bbc/tech/001.txt", "Title\r\n\r\nBody\r\n")
+                zipped.writestr("bbc/README.txt", "ignored")
+            self.assertEqual(list(_pipeline._source_rows("bbc-news", archive)),
+                             [("bbc_tech_001", "Body\r\n", "Title", "tech", "", "", "", "")])
+            archive = root / "wos.zip"
+            with zipfile.ZipFile(archive, "w") as zipped:
+                for subset in ("5736", "11967", "46985"):
+                    for field, value in (("X", "Body"), ("Y", "2"), ("YL1", "1"), ("YL2", "0")):
+                        zipped.writestr("WOS" + subset + "/" + field + ".txt", value + "\r\n")
+            for subset in ("5736", "11967", "46985"):
+                self.assertEqual(list(_pipeline._source_rows("wos-" + subset, archive)),
+                                 [("wos" + subset + "_000000", "Body", "", "2", "1", "0", "", "")])
+            source = root / "scinews"
+            write_scinews(source, [record("body", url="https://news", doi="https://doi.org/AbC")])
+            row = next(_pipeline._source_rows("scinews", source))
+            self.assertEqual((row[0], row[-2:]), ("scinews_train_000000", ("https://news", "abc")))
+            duplicate_key = '[' + json.dumps(record("body"))[:-1] + ',"News_Title":"duplicate"}]'
+            for invalid in (duplicate_key, '[{},]', '[NaN]', '[] trailing'):
+                (source / "train.json").write_text(invalid)
+                with self.subTest(invalid=invalid), self.assertRaises(ValueError):
+                    list(_pipeline._source_rows("scinews", source))
+
+
+@unittest.skipUnless(RESOURCES, "set PORTABLE_NLTK_DATA for real NLTK fixture checks")
+class RealPipelineChecks(unittest.TestCase):
+    def test_occurrences_keep_original_offsets_and_order(self):
+        text = "The CATS, cats were running! A 12."
+        actual = _pipeline.EnglishPreprocessor(Path(RESOURCES)).occurrences(text)
+        self.assertEqual([item["lemma"] for item in actual], ["cat", "cat", "run"])
+        self.assertEqual([text[item["start"]:item["end"]] for item in actual],
+                         ["CATS", "cats", "running"])
+        self.assertEqual([item["occurrence_index"] for item in actual], [0, 1, 2])
+
+    def test_cleaning_family_splits_and_serialization(self):
+        """Duplicates/conflicts disappear; removed bridges and exact .9 pairs stay together."""
+        rows = [record("unique" + chr(97 + i // 26) + chr(97 + i % 26) + " astronomy observation")
+                for i in range(40)]
+        rows.extend([
+            record("cats"), record("cat"),
+            record("dogs", "Physics"), record("dog", "Chemistry"),
+            record("raw conflict", "Physics"), record(" RAW  CONFLICT ", "Chemistry"),
+            record("bridge original stellar light", title="Cats cats", url="https://a"),
+            record("bridge original stellar light", url="https://b", doi="doi:ABC"),
+            record("distinct bridge body particles", doi="https://doi.org/abc"),
+            record("alpha beta gamma delta epsilon zeta eta theta iota kappa lambda mu nu"),
+            record("alpha beta gamma delta epsilon zeta eta theta iota kappa lambda mu nu xi"),
+            record("the and or"),
+        ])
+        with tempfile.TemporaryDirectory() as temporary:
+            root = Path(temporary)
+            write_scinews(root / "source", rows)
+            output = root / "data"
+            _pipeline.build("scinews", root / "source", Path(RESOURCES), output, root / "scratch")
+            labels = json.loads((output / "labels.json").read_text())
+            removed = {41, 42, 43, 44, 45, 47, 51}
+            expected_ids = {f"scinews_train_{i:06d}" for i in range(len(rows)) if i not in removed}
+            self.assertEqual(set(labels), expected_ids)
+            splits = json.loads((output / "splits.json").read_text())
+            membership = {identifier: name for name, ids in splits.items() for identifier in ids}
+            self.assertEqual(len(membership), sum(map(len, splits.values())))
+            self.assertEqual(set(membership), expected_ids)
+            # Fixed protocol seeds split 43 families, expanding both linked pairs.
+            # Exact membership catches a missing .9 edge even if its two rows
+            # happen to land in the same split without that edge.
+            expected_splits = {
+                "fit": [0, 2, 4, 7, 8, 9, 10, 11, 12, 15, 17, 19, 20, 21,
+                        24, 26, 27, 30, 33, 36, 37, 38, 40, 46, 48, 49, 50],
+                "calibration": [3, 13, 14, 18, 22, 23, 31, 34, 39],
+                "validation": [1, 5, 6, 16, 25, 28, 29, 32, 35],
+            }
+            self.assertEqual(splits, {name: [f"scinews_train_{i:06d}" for i in ids]
+                                      for name, ids in expected_splits.items()})
+            for first, second in ((46, 48), (49, 50)):
+                self.assertEqual(membership[f"scinews_train_{first:06d}"],
+                                 membership[f"scinews_train_{second:06d}"])
+            with (output / "noow.csv").open(newline="") as stream:
+                noow = {row["id"]: row for row in csv.DictReader(stream)}
+            with (output / "bow.csv").open(newline="") as stream:
+                bow = {row["id"]: row for row in csv.DictReader(stream)}
+            identifier = "scinews_train_000046"
+            self.assertEqual(noow[identifier]["raw_text"], "Cats cats\n\nbridge original stellar light")
+            self.assertEqual(noow[identifier]["vw_text"], identifier + " |@title cat cat |@word bridge original stellar light")
+            self.assertEqual(bow[identifier]["vw_text"], identifier + " |@title cat:2 |@word bridge:1 light:1 original:1 stellar:1")
+            for path in output.iterdir():
+                self.assertTrue(path.read_bytes().endswith(b"\n"))
+
+    def test_wos_hierarchy_preserves_multiple_parents(self):
+        with tempfile.TemporaryDirectory() as temporary:
+            root = Path(temporary)
+            archive = root / "wos.zip"
+            with zipfile.ZipFile(archive, "w") as zipped:
+                fields = {"X": ["unique" + chr(97 + i // 26) + chr(97 + i % 26) + " research" for i in range(40)],
+                          "Y": [str(i % 2) for i in range(40)],
+                          "YL1": [str(i % 3) for i in range(40)],
+                          "YL2": [str(i % 2) for i in range(40)]}
+                for name, values in fields.items():
+                    zipped.writestr("WOS5736/" + name + ".txt", "\r\n".join(values) + "\r\n")
+            _pipeline.build("wos-5736", archive, Path(RESOURCES), root / "data", root / "scratch")
+            hierarchy = json.loads((root / "data/hierarchy.json").read_text())
+            self.assertEqual({row["YL1"] for row in hierarchy.values() if row["Y"] == "0"}, {"0", "1", "2"})
+            self.assertEqual(hierarchy["wos5736_000001"], {"Y": "1", "YL1": "1", "YL2": "1"})
+            with (root / "data/noow.csv").open(newline="") as stream:
+                row = next(csv.DictReader(stream))
+            self.assertEqual(row["raw_text"], fields["X"][0])
+            self.assertEqual(row["vw_text"], "wos5736_000000 |@word uniqueaa research")
+
+
+class CliChecks(unittest.TestCase):
+    def test_source_and_resource_hashes_fail_before_destinations_exist(self):
+        with tempfile.TemporaryDirectory() as temporary:
+            root = Path(temporary)
+            package = root / "package"
+            package.mkdir()
+            shutil.copyfile(HERE / "prepare.py", package / "prepare.py")
+            sources = root / "sources"
+            (sources / "bbc-news").mkdir(parents=True)
+            source = sources / "bbc-news/bbc-fulltext.zip"
+            source.write_bytes(b"fixture")
+            digest = hashlib.sha256(b"fixture").hexdigest()
+            pins = {"sources": {"bbc-news": {"files": {"bbc-fulltext.zip": {"bytes": 7, "sha256": digest}}}},
+                    "resources": {"resource": {"bytes": 7, "sha256": digest}}}
+            (package / "source-pins.json").write_text(json.dumps(pins))
+            resource = sources / "nltk_data/resource"
+            resource.parent.mkdir()
+            resource.write_bytes(b"altered")
+            for boundary in ("resource", "source"):
+                if boundary == "source":
+                    source.write_bytes(b"altered")
+                result = subprocess.run([sys.executable, "-O", str(package / "prepare.py"), "build",
+                    "--dataset", "bbc-news", "--sources-dir", str(sources),
+                    "--output-dir", str(root / "output"), "--scratch-dir", str(root / "scratch")],
+                    cwd=root, capture_output=True, text=True)
+                self.assertNotEqual(result.returncode, 0, result.stdout)
+                self.assertIn("SHA-256 differs from pin", result.stderr)
+                self.assertIn(str(resource if boundary == "resource" else source), result.stderr)
+                self.assertFalse((root / "output").exists())
+                self.assertFalse((root / "scratch").exists())
+
+    def test_verify_rejects_hash_and_inventory_drift_under_optimization(self):
+        with tempfile.TemporaryDirectory() as temporary:
+            root = Path(temporary)
+            package = root / "package"
+            package.mkdir()
+            shutil.copyfile(HERE / "prepare.py", package / "prepare.py")
+            data = root / "data"
+            data.mkdir()
+            files = {"labels.json": b'{"one":["topic"]}\n',
+                     "splits.json": b'{"fit":["one"],"calibration":[],"validation":[]}\n',
+                     "bow.csv": b'id,raw_text,vw_text\none,body,one |@word body:1\n',
+                     "noow.csv": b'id,raw_text,vw_text\none,body,one |@word body\n'}
+            for name, content in files.items():
+                (data / name).write_bytes(content)
+            pins = {"datasets": {"bbc-news": {"documents": 1,
+                "split_counts": {"fit": 1, "calibration": 0, "validation": 0},
+                "files": {name: {"bytes": len(content), "sha256": hashlib.sha256(content).hexdigest()}
+                          for name, content in files.items()}}}}
+            (package / "payload-pins.json").write_text(json.dumps(pins))
+            command = [sys.executable, "-O", str(package / "prepare.py"), "verify",
+                       "--dataset", "bbc-news", "--data-dir", str(data)]
+            result = subprocess.run(command, cwd=root, capture_output=True, text=True)
+            self.assertEqual(result.returncode, 0, result.stderr)
+            (data / "extra").write_text("unexpected")
+            result = subprocess.run(command, cwd=root, capture_output=True, text=True)
+            self.assertNotEqual(result.returncode, 0)
+            self.assertIn("inventory differs", result.stderr)
+            (data / "extra").unlink()
+            (data / "bow.csv").write_bytes(files["bow.csv"].replace(b"body", b"BODY"))
+            result = subprocess.run(command, cwd=root, capture_output=True, text=True)
+            self.assertNotEqual(result.returncode, 0)
+            self.assertIn("SHA-256 differs", result.stderr)
+
+
+if __name__ == "__main__":
+    unittest.main()