wikinews: label each page CC BY 2.5 or 4.0 by its last revision (v0.2.6, v2#57)

artifacts/source_findings.md

@@ -1889,3 +1889,41 @@ NERGAL pass (#60).
 **Lesson:** a label-anchored phone regex with no number-shape guard turns amounts and part
 numbers into "phones"; check redactions for false positives, not only misses. Keep the raw
 download recipe runnable: a rescrub of already-redacted text cannot undo a false positive.
+
+## wikinews — Polish Wikinews (rebuild from the official dump, 2.5/4.0 labels)
+
+**Investigated** — 2026-10-06 (October 2026 rights audit, `artifacts/rights_audit_2026-10/reports/wikis_ugc.md`,
+`reports/citations.md` L17-26; slayerlabs/polish-dynaword-v2#57).
+
+**Verdict** — `kept`, relabelled; rebuilt from the official dump so the label follows the
+page's last revision. Documents, characters and tokens are unchanged from v0.2.5
+(24,386 / 32,524,646 / 12,141,355); the text multiset is identical. Labels per record:
+`CC-BY-2.5` 17,581 documents (8,956,397 tokens, 73.8%), `CC-BY-4.0` 6,805 (3,184,958, 26.2%);
+v0.2.5 labelled every row `CC-BY-2.5`. Row ids are now `wikinews_<page id>`; `author` is the
+page URL and `created` the last-revision date (v0.2.5: empty `author`, and the same range
+string "2005-01-01, 2025-12-31" as `created` on every row). The parquet `added` column is
+2026-07-19 (v0.2.5: 2026-06-15).
+
+**Enumeration** — `plwikinews-20260601-pages-articles.xml.bz2` (sha1 `bfad5f33…` matched to
+the dump's `sha1sums.txt`), parsed by `src/fetch_wikimedia.py`: 65,253 pages → 47,845 in
+namespace 0 → 23,366 redirects and 87 pages under 200 characters skipped → 24,392 written →
+6 non-Polish dropped by `build_dynaword.py` → 24,386. Text conversion is the v0.2.5 one
+(plain `strip_code`): `<ref>` bodies, `Kategoria:` links and `thumb|` file options stay in
+the text; nothing was changed in this PR. One sidecar line per row
+(`wikinews.attribution.jsonl`).
+
+**License evidence** — verified, read 2026-10-06: pl.wikinews terms of use (oldid 342796:
+CC BY 2.5 until 2024-12-16, CC BY 4.0 since), Gerrit 1101867 (merged 2024-12-16 08:07 UTC),
+Phabricator T381421, the 2.5 legal code (§4(a): no later-version clause), pl.wikinews
+`rightsinfo` (BY 4.0). The 08:32:24 UTC sync time is from the audit and was not re-read.
+Cutoff is 2024-12-16 00:00 UTC for the whole day: 6 documents were last edited that day, 2 of
+them before 08:32:24 UTC and so strictly under 2.5. Inferred: because CC BY 2.5 has no
+later-version clause, the `CC-BY-4.0` label for post-switch pages rests on the site's terms
+page alone. This is a question for the lawyer, separate from E1 (wiki 3.0/4.0 labelling,
+v2#56), whose answer is still pending. The terms page also says articles created before
+2005-09-25 are public domain; 0 released documents were last edited before that date, so the
+clause does not change a label here. Evidence in `data/wikinews/wikinews.license-evidence.json`.
+
+**Blockers** — none to merge. Open: lawyer on the 2.5 → 4.0 label and on E1; the 2 boundary
+documents; copyright pastes in news text (the audit's 100-document press-copying sample was
+not run); the markup residue above.

data/wikinews/wikinews.attribution.jsonl

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

data/wikinews/wikinews.build.json

@@ -0,0 +1,53 @@
+{
+  "attribution_rows": 24386,
+  "attribution_sha256": "0d5a6f9bd4714a5cc5ab9c4e3343254849e7bccf0195d609235ea07919ed5c1f",
+  "cutoff": "2024-12-16T00:00:00+00:00",
+  "discovered_at": "2026-10-06T00:00:15.478622+00:00",
+  "dump_base": "https://dumps.wikimedia.org/plwikinews/20260601",
+  "dump_date": "20260601",
+  "file": {
+    "name": "plwikinews-20260601-pages-articles.xml.bz2",
+    "sha1": "bfad5f33667756de4ded97756d370d7fdec39bcb",
+    "size": 21980828,
+    "url": "https://dumps.wikimedia.org/plwikinews/20260601/plwikinews-20260601-pages-articles.xml.bz2"
+  },
+  "labels": {
+    "after": "CC-BY-4.0",
+    "before": "CC-BY-2.5"
+  },
+  "prepare": {
+    "counts": {
+      "CC-BY-2.5": 17587,
+      "CC-BY-4.0": 6805,
+      "ns0": 47845,
+      "ns0_redirect": 23366,
+      "ns0_short": 87,
+      "pages": 65253,
+      "written": 24392
+    },
+    "exact_duplicate_pageids": []
+  },
+  "rightsinfo": {
+    "text": "Creative Commons Attribution 4.0",
+    "url": "https://creativecommons.org/licenses/by/4.0/",
+    "url_queried": "https://pl.wikinews.org/w/api.php?action=query&meta=siteinfo&siprop=rightsinfo"
+  },
+  "sha1sums_url": "https://dumps.wikimedia.org/plwikinews/20260601/plwikinews-20260601-sha1sums.txt",
+  "switch": {
+    "gerrit": "https://gerrit.wikimedia.org/r/changes/operations%2Fmediawiki-config~1101867",
+    "gerrit_status": "MERGED",
+    "gerrit_submitted": "2024-12-16 08:07:33.000000000",
+    "merged_utc": "2024-12-16 08:07",
+    "phabricator": "https://phabricator.wikimedia.org/T381421",
+    "synced_by_utc": "2024-12-16 08:32:24"
+  },
+  "terms": [
+    {
+      "effective": "udostępnia swoją treść na licencji Creative Commons Uznanie autorstwa 4.0 od 16 grudnia 2024 roku",
+      "sha256": "8b461acb8e0608eb906e59d9669bc003759d7840d82fc934f83d160a72895de3",
+      "statement": "a wcześniej na licencji. [http://creativecommons.org/licenses/by/2.5/deed.pl Creative Commons Uznanie autorstwa 2.5]",
+      "title": "pl.wikinews terms of use (CC BY 2.5 until 2024-12-16, CC BY 4.0 since)",
+      "url": "https://pl.wikinews.org/w/index.php?title=Wikinews:Warunki_u%C5%BCycia&oldid=342796&action=raw"
+    }
+  ]
+}

data/wikinews/wikinews.license-evidence.json

@@ -0,0 +1,74 @@
+{
+  "checked_at": "2026-10-06",
+  "cutoff": {
+    "after": "CC-BY-4.0",
+    "at": "2024-12-16T00:00:00+00:00",
+    "before": "CC-BY-2.5",
+    "boundary_day": {
+      "day": "2024-12-16",
+      "docs_last_edited_that_day": 6,
+      "known_switch_time_utc": "2024-12-16 08:32:24",
+      "of_which_before_that_time": 2
+    }
+  },
+  "legal": [
+    {
+      "absent": "later version",
+      "section": "4(a)",
+      "sha256": "6f53ec1584dd401724c1cae0fc1139249508ce24cf0891cc70fd6468f4d4b689",
+      "statement": "You may not sublicense the Work",
+      "url": "https://creativecommons.org/licenses/by/2.5/legalcode"
+    }
+  ],
+  "license": "CC-BY-2.5 or CC-BY-4.0 per record, by the page's last revision",
+  "release_scope": {
+    "created_range": [
+      "2011-12-24",
+      "2026-05-25"
+    ],
+    "labels": {
+      "CC-BY-2.5": 17581,
+      "CC-BY-4.0": 6805
+    },
+    "last_edited_before_era_end": {
+      "date": "2005-09-25",
+      "docs": 0,
+      "tokens": 0
+    },
+    "tokens": {
+      "CC-BY-2.5": 8956397,
+      "CC-BY-4.0": 3184958
+    }
+  },
+  "review_scope": "licence of contributors' text on pl.wikinews.org and its version per page; not independent legal advice",
+  "site_licence": {
+    "observed_at": "2026-10-06T00:00:15.478622+00:00",
+    "rightsinfo": {
+      "text": "Creative Commons Attribution 4.0",
+      "url": "https://creativecommons.org/licenses/by/4.0/",
+      "url_queried": "https://pl.wikinews.org/w/api.php?action=query&meta=siteinfo&siprop=rightsinfo"
+    }
+  },
+  "spdx": [
+    "https://spdx.org/licenses/CC-BY-2.5.html",
+    "https://spdx.org/licenses/CC-BY-4.0.html"
+  ],
+  "status": "documented-open-cc-by",
+  "switch": {
+    "gerrit": "https://gerrit.wikimedia.org/r/changes/operations%2Fmediawiki-config~1101867",
+    "gerrit_status": "MERGED",
+    "gerrit_submitted": "2024-12-16 08:07:33.000000000",
+    "merged_utc": "2024-12-16 08:07",
+    "phabricator": "https://phabricator.wikimedia.org/T381421",
+    "synced_by_utc": "2024-12-16 08:32:24"
+  },
+  "terms": [
+    {
+      "effective": "udostępnia swoją treść na licencji Creative Commons Uznanie autorstwa 4.0 od 16 grudnia 2024 roku",
+      "sha256": "8b461acb8e0608eb906e59d9669bc003759d7840d82fc934f83d160a72895de3",
+      "statement": "a wcześniej na licencji. [http://creativecommons.org/licenses/by/2.5/deed.pl Creative Commons Uznanie autorstwa 2.5]",
+      "title": "pl.wikinews terms of use (CC BY 2.5 until 2024-12-16, CC BY 4.0 since)",
+      "url": "https://pl.wikinews.org/w/index.php?title=Wikinews:Warunki_u%C5%BCycia&oldid=342796&action=raw"
+    }
+  ]
+}

data/wikinews/wikinews.md

@@ -3,41 +3,95 @@
 Polish Wikinews
 
 ## Dataset description
-- **Source (upstream):** https://pl.wikinews.org/
+- **Source (upstream):** https://dumps.wikimedia.org/plwikinews/20260601/
 - **Domain:** news
 - **Language:** Polish (pl)
-- **License:** `CC-BY-2.5`
-- **Created (range):** 2005-01-01, 2025-12-31
-- **Added:** 2026-07-02
+- **License:** `CC-BY-2.5` or `CC-BY-4.0` per record (by last-revision date)
+- **Created (range):** 2011-12-24, 2026-05-25 (date of the page's last revision in the dump)
+- **Added:** 2026-07-02; rebuilt 2026-10-06 (UTC) from the official Wikimedia dump
 
 ## Licensing — traceable basis
-Wikinews content is released under CC-BY 2.5; attribution to contributors preserved.
+Contributors' text on pl.wikinews.org is licensed CC BY: [pl.wikinews terms of use (CC BY 2.5 until 2024-12-16, CC BY 4.0 since)](https://pl.wikinews.org/w/index.php?title=Wikinews:Warunki_u%C5%BCycia&oldid=342796&action=raw) (read 2026-10-06 UTC). The site licence
+(`rightsinfo`) reads "Creative Commons Attribution 4.0". Each row is labelled by its page's last revision in the dump:
+
+| last revision (UTC) | `license` | documents | tokens | share of tokens |
+|---|---|---:|---:|---:|
+| before 2024-12-16 | `CC-BY-2.5` | 17,581 | 8,956,397 | 73.8% |
+| 2024-12-16 or later | `CC-BY-4.0` | 6,805 | 3,184,958 | 26.2% |
+
+pl.wikinews has its own terms page, which names CC BY 2.5 until 2024-12-16 and CC BY 4.0 from that
+day. A page last edited on or after the cutoff can still hold
+2.5 text from earlier edits, and the [CC BY 2.5](https://creativecommons.org/licenses/by/2.5/legalcode) legal code (§4(a)) has no clause that lets an
+adaptation be licensed under a later version (BY-SA 3.0 §4(b)(ii) has one). The 4.0 label for such
+pages rests on the site's terms page alone; whether that is enough is for the lawyer.
+The terms page gives the day, not the time. The cutoff is midnight UTC, so the 6 pages last edited
+on 2024-12-16 are labelled 4.0. The configuration change was merged 2024-12-16 08:07 UTC and deployed
+by 2024-12-16 08:32:24 UTC ([Gerrit change](https://gerrit.wikimedia.org/r/changes/operations%2Fmediawiki-config~1101867), [T381421](https://phabricator.wikimedia.org/T381421);
+the deployment time was read by the rights audit, not re-read), so 2 of those 6 were last edited before it.
+The rule is `license_for_revision` in `src/rights.py`, tested at the cutoff second, across time
+zones, and on a missing timestamp, which stops the build. v0.2.0-v0.2.5 labelled every row `CC-BY-2.5`.
+
+The terms page puts articles created before 2005-09-25 in the public domain. The dump has only the date of the last
+revision, so how many released articles were created then is not known; 0 (0 tokens) were last edited before it.
+All rows carry a CC BY label; nothing is dropped or relabelled for this.
+
+Evidence: `wikinews.license-evidence.json`.
+
+## Attribution
+Each row's `author` is `Wikinews contributors, <page URL>`, e.g.
+`Wikinews contributors, https://pl.wikinews.org/wiki/2005-03-18:_Barroso_w_Polsce`. The page history names the contributors; the terms page asks for a link to the source article, which the URL gives.
+`wikinews.attribution.jsonl` has one line per row: `id`, `pageid`, `revid` (the revision
+in the dump), `title`, `url`, `last_revision_at`, `license`. The row `id` is
+`wikinews_<page id>` and `created` is the date of `last_revision_at`.
+
+The text is modified: wiki markup is converted to plain text (see Provenance).
 
 ## Provenance
-Fetched directly from the official Wikimedia dump (plwikinews-latest-pages-articles) by src/fetch_wikimedia.py; mainspace only, wikitext stripped via mwparserfromhell.
+Parsed from the official Wikimedia dump `plwikinews-20260601-pages-articles` by
+`src/fetch_wikimedia.py`; the file (21,980,828 bytes, sha1 `bfad5f33667756de4ded97756d370d7fdec39bcb`) was matched against the
+dump's `dumpstatus.json` and `sha1sums.txt` (`wikinews.build.json`). v0.2.0-v0.2.5 used the same dump
+date; the text set is the same (the rebuild adds the last-revision time).
+
+Articles (namespace 0) only. Redirects, empty pages and pages shorter than 200 characters are skipped.
+Wikitext is converted with mwparserfromhell `strip_code(normalize=True, collapse=True)`, as in v0.2.5.
+Templates and comments are dropped. `<ref>` bodies, category links (`Kategoria:...`) and file-link
+options (`thumb|...`) are not removed and stay in the text; the wikipedia fetcher's `strip_article`
+removes them, this one does not, because that would change the text set. Of two pages with the same
+text (sha1 of the stripped text), the lower page id is kept.
+
+65,253 pages scanned → 47,845 in namespace 0 → 23,366 redirects, 0 empty pages, 0 parser failures, 87 shorter than 200 characters skipped, no exact duplicates → 24,392 read by the build → 24,386 released.
 
 ## Statistics
 | documents | characters | tokens (tiktoken proxy) |
 |---:|---:|---:|
 | 24,386 | 32,524,646 | 12,141,355 |
 
+The same text set as v0.2.5: documents, characters and tokens are unchanged; only labels, ids, authors and dates differ.
 
 ## Per-document license metadata
 | license | documents |
 |---|---:|
-| `CC-BY-2.5` | 24,386 |
+| `CC-BY-2.5` | 17,581 |
+| `CC-BY-4.0` | 6,805 |
 
-Author metadata present for **0** documents. Empty values mean the upstream record did not expose a machine-readable author field.
-
-Statistics were recomputed directly from the released parquet file.
+Author metadata present for **24,386** documents.
 
 ## Filters applied (build_dynaword.py)
-Minimal, per Dynaword guidelines (heavy filtering left to downstream use):
-- drop documents < 200 chars: **0**
-- drop non-Polish (diacritic ratio): **0**
+- drop documents < 200 chars: **0** (the fetcher already dropped 87)
+- drop non-Polish (diacritic ratio): **6**
 - exact cross-source dedup (sha1): **0**
 - OCR alpha-ratio < 0.70 (OCR sources only): **0**
-- read 24,386 → kept 24,386
+- read 24,392 → kept 24,386
 
 Token counts are a fast tiktoken (cl100k) proxy (~1% off Llama-3); the canonical
 Llama-3 count is computed at release.
+
+## Not checked
+- pastes from copyrighted sources, including articles copied from press agencies or other publishers (no sample was run)
+- the 2.5 → 4.0 label of pages edited after the cutoff (a reading of the site's terms page, not a lawyer's opinion;
+  the lawyer's answer to E1, the wiki 3.0/4.0 labelling, is still pending, and whether it extends to 2.5 → 4.0 is not settled),
+  and the time of day of the switch
+- how many released articles were created before 2005-09-25, the public-domain date in the terms page
+- text imported from elsewhere under another licence or with extra attribution requirements
+- quotations inside articles (Art. 29 of the Polish copyright act)
+- personal data (the NERGAL scrub runs before release)

data/wikinews/wikinews.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:c3b731f35eda7760ea3461896218cff6d445a9dfb841a023a56e64d62abdc868
-size 14367012
+oid sha256:54feba0a09e8c81aac33619f4ad2e80cdc42cf16f6bb9718bf9edc349a12fbb6
+size 15298826

data/wikinews/wikinews.stats.json

@@ -1,16 +1,17 @@
 {
-  "read": 24386,
+  "read": 24392,
   "kept": 24386,
   "drop_short": 0,
-  "drop_lang": 0,
+  "drop_lang": 6,
   "drop_dup": 0,
   "drop_ocr": 0,
   "chars": 32524646,
   "tokens": 12141355,
   "licenses": {
-    "CC-BY-2.5": 24386
+    "CC-BY-4.0": 6805,
+    "CC-BY-2.5": 17581
   },
-  "authors_with_value": 0,
-  "license": "CC-BY-2.5",
-  "stats_recomputed_from_parquet": true
-}
+  "authors_with_value": 24386,
+  "secs": 1.4,
+  "license": "CC BY (2.5 or 4.0 per record, by last-revision date)"
+}

src/fetch_wikimedia.py

@@ -1,103 +1,484 @@
 #!/usr/bin/env python3
-"""Fetch Polish Wikimedia sibling projects (Wikinews/Wikivoyage/Wikibooks)
-from the official dumps into SpeakLeash-style .jsonl.zst, so build_dynaword.py
-consumes them unchanged. All are CC-BY-SA (same basis as Wikipedia/Wikisource).
+"""Polish Wikinews, Wikivoyage and Wikibooks from the official dumps, licence per record.
 
-Mainspace (ns=0) only; redirects and empty pages dropped. Wikitext -> plaintext
-via mwparserfromhell.
+v0.2.0-v0.2.5 labelled every row with one licence (Wikinews CC-BY-2.5, the others
+CC-BY-SA-3.0). Each row now carries the label of its page's last revision
+(`license_for_revision` in src/rights.py): v0.2.6 rights audit, slayerlabs/polish-dynaword-v2#57.
+The dump date is pinned to the one the v0.2.5 text came from (the rebuild changes labels,
+ids, authors and dates, not the text); the dump file is checked against the sha1 in
+dumpstatus.json and in the dump's sha1sums.txt.
 
-Usage:
-  python3 src/fetch_wikimedia.py --out ~/Local/Ventures/Slayer/data/speakleash \
-      --wikis plwikinews plwikivoyage plwikibooks
+    B=<build dir, never committed>
+    python3 src/fetch_wikimedia.py acquire     --out $B --sources wikinews wikivoyage wikibooks
+    python3 src/fetch_wikimedia.py prepare     --out $B ...   # $B/plwiki{news,voyage,books}.jsonl.zst
+    python3 src/build_dynaword.py --sources wikinews wikivoyage wikibooks --speakleash-dir $B --out .
+    python3 src/fetch_wikimedia.py attribution --out $B ...   # data/<source> sidecars + evidence
+    python3 src/fetch_wikimedia.py datasheet   --out $B ...   # data/<source>/<source>.md
 """
 from __future__ import annotations
-import argparse, bz2, json, subprocess, time
+
+import argparse
+import bz2
+from collections import Counter
+from datetime import timedelta
+import gzip
+import hashlib
+import html
+import json
 from pathlib import Path
-from urllib.request import urlopen, Request
-from xml.etree.ElementTree import iterparse
-import mwparserfromhell
-
-DUMP = "https://dumps.wikimedia.org/{w}/latest/{w}-latest-pages-articles.xml.bz2"
-UA = {"User-Agent": "polish-dynaword/0.1 (+research; openly-licensed corpus)"}
-MIN_CHARS = 200
-# wiki -> (file stem used by build_dynaword, human URL)
-SITE = {
-    "plwikinews":   ("https://pl.wikinews.org/wiki/", "news"),
-    "plwikivoyage": ("https://pl.wikivoyage.org/wiki/", "travel"),
-    "plwikibooks":  ("https://pl.wikibooks.org/wiki/", "howto"),
+import re
+import subprocess
+import sys
+from urllib.parse import quote
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from build_plwiki_talk_pl import (  # noqa: E402  shared dump helpers
+    UA, digest, load, now, request, request_json, save, sha1_file,
+)
+from fetch_wikipedia import pages, text_key  # noqa: E402
+from rights import BY_SA_4_CUTOFF, WIKINEWS_BY_4_CUTOFF, license_for_revision  # noqa: E402
+
+DUMP_DATE = "20260601"  # the dump the v0.2.5 text was cut from (checked: same text set)
+MIN_CHARS = 200  # same gate as build_dynaword.py
+
+# WMF Terms of Use in force from 2023-06-07 (CC BY-SA 4.0), and the 2014 revision (CC BY-SA 3.0).
+WMF_TOU_NEW = {
+    "title": "Wikimedia Terms of Use in force since 7 June 2023 (CC BY-SA 4.0)",
+    "url": "https://foundation.wikimedia.org/w/index.php?title=Policy:Terms_of_Use&oldid=554823&action=raw",
+    "sha256": "c96ef93b439ff9b8242dc3233f41ede57c0984ef9153fafa51aa5f8cf0678832",
+    "effective": "These Terms of Use went into effect on June 7, 2023",
+    "statement": "Creative Commons Attribution-ShareAlike 4.0 International License",
+}
+WMF_TOU_OLD = {
+    "title": "Wikimedia Terms of Use of 2014-2023 (CC BY-SA 3.0)",
+    "url": "https://foundation.wikimedia.org/w/index.php?title=Policy:Terms_of_Use&oldid=98524&action=raw",
+    "sha256": "46617e3576a507b8f83a0cf7b28b60e43817ad93cc5d747a558b503e7d1cc6de",
+    "effective": "These Terms of Use went into effect on June 16, 2014",
+    "statement": "Creative Commons Attribution-ShareAlike 3.0 Unported License",
+}
+# pl.wikinews has its own terms page: CC BY, 2.5 until 2024-12-16, 4.0 since.
+WIKINEWS_TERMS = {
+    "title": "pl.wikinews terms of use (CC BY 2.5 until 2024-12-16, CC BY 4.0 since)",
+    "url": "https://pl.wikinews.org/w/index.php?title=Wikinews:Warunki_u%C5%BCycia&oldid=342796&action=raw",
+    "sha256": "8b461acb8e0608eb906e59d9669bc003759d7840d82fc934f83d160a72895de3",
+    "effective": "udostępnia swoją treść na licencji Creative Commons Uznanie autorstwa 4.0 od 16 grudnia 2024 roku",
+    "statement": "a wcześniej na licencji. [http://creativecommons.org/licenses/by/2.5/deed.pl Creative Commons Uznanie autorstwa 2.5]",
+}
+WIKINEWS_SWITCH = {  # the config change that made 4.0 the site licence (Phabricator T381421)
+    "gerrit": "https://gerrit.wikimedia.org/r/changes/operations%2Fmediawiki-config~1101867",
+    "phabricator": "https://phabricator.wikimedia.org/T381421",
+    "merged_utc": "2024-12-16 08:07",
+    "synced_by_utc": "2024-12-16 08:32:24",  # SAL scap sync-world finish; read by the rights audit, not re-read
 }
 
+GFDL_ERA_END = "2009-06-15"  # the Wikimedia sites began dual licensing under CC BY-SA 3.0 and the GFDL
+# What the label rule rests on: each licence's own clause on adaptations (read from the legal code).
+LEGAL_BY_SA_3 = {"url": "https://creativecommons.org/licenses/by-sa/3.0/legalcode", "section": "4(b)(ii)",
+                 "statement": "a later version of this License with the same License Elements as this License"}
+LEGAL_BY_SA_4 = {"url": "https://creativecommons.org/licenses/by-sa/4.0/legalcode", "section": "3(b)(1)",
+                 "statement": "this version or later, or a BY-SA Compatible License"}
+LEGAL_BY_2_5 = {"url": "https://creativecommons.org/licenses/by/2.5/legalcode", "section": "4(a)",
+                "statement": "You may not sublicense the Work", "absent": "later version"}  # no later-version clause
+
+SITES = {
+    "wikinews": {
+        "wiki": "plwikinews", "host": "pl.wikinews.org", "pretty": "Polish Wikinews",
+        "author": "Wikinews contributors", "family": "CC BY",
+        "cutoff": WIKINEWS_BY_4_CUTOFF, "before": "CC-BY-2.5", "after": "CC-BY-4.0",
+        "site_rights": "creativecommons.org/licenses/by/4.0/", "terms": [WIKINEWS_TERMS], "legal": [LEGAL_BY_2_5],
+        "clock": WIKINEWS_SWITCH["synced_by_utc"], "era_end": "2005-09-25", "domain": "news", "added": "2026-07-02",
+        "v025": (24386, 32524646, 12141355),
+    },
+    "wikivoyage": {
+        "wiki": "plwikivoyage", "host": "pl.wikivoyage.org", "pretty": "Polish Wikivoyage",
+        "author": "Wikivoyage contributors", "family": "CC BY-SA",
+        "cutoff": BY_SA_4_CUTOFF, "before": "CC-BY-SA-3.0", "after": "CC-BY-SA-4.0",
+        "site_rights": "creativecommons.org/licenses/by-sa/4.0/", "terms": [WMF_TOU_NEW, WMF_TOU_OLD], "legal": [LEGAL_BY_SA_3, LEGAL_BY_SA_4],
+        "era_end": GFDL_ERA_END, "domain": "travel", "added": "2026-07-02", "v025": (13645, 45184300, 17128200),
+    },
+    "wikibooks": {
+        "wiki": "plwikibooks", "host": "pl.wikibooks.org", "pretty": "Polish Wikibooks",
+        "author": "Wikibooks contributors", "family": "CC BY-SA",
+        "cutoff": BY_SA_4_CUTOFF, "before": "CC-BY-SA-3.0", "after": "CC-BY-SA-4.0",
+        "site_rights": "creativecommons.org/licenses/by-sa/4.0/", "terms": [WMF_TOU_NEW, WMF_TOU_OLD], "legal": [LEGAL_BY_SA_3, LEGAL_BY_SA_4],
+        "era_end": GFDL_ERA_END, "domain": "instructional", "added": "2026-07-02", "v025": (9112, 38892589, 15571295),
+    },
+}
+
+
+def label(key: str, timestamp: str) -> str:
+    s = SITES[key]
+    return license_for_revision(timestamp, s["cutoff"], s["before"], s["after"])
+
+
+def page_url(key: str, title: str) -> str:
+    return f"https://{SITES[key]['host']}/wiki/" + quote((title or "").replace(" ", "_"), safe="/:")
+
 
-def _local(tag):  # strip {namespace}
-    return tag.rsplit("}", 1)[-1]
-
-
-def download(w, cache):
-    dst = cache / f"{w}.xml.bz2"
-    if dst.exists() and dst.stat().st_size > 0:
-        print(f"  cached {dst.name}"); return dst
-    url = DUMP.format(w=w)
-    print(f"  downloading {url}", flush=True)
-    with urlopen(Request(url, headers=UA), timeout=120) as r, dst.open("wb") as f:
-        while chunk := r.read(1 << 20):
-            f.write(chunk)
-    return dst
-
-
-def pages(bz2_path):
-    """Yield (title, wikitext) for mainspace, non-redirect pages."""
-    with bz2.open(bz2_path, "rb") as fh:
-        title = ns = text = None; redirect = False
-        for ev, el in iterparse(fh, events=("end",)):
-            t = _local(el.tag)
-            if t == "title": title = el.text
-            elif t == "ns": ns = el.text
-            elif t == "redirect": redirect = True
-            elif t == "text": text = el.text
-            elif t == "page":
-                if ns == "0" and not redirect and text:
-                    yield title, text
-                title = ns = text = None; redirect = False
-                el.clear()
-
-
-def strip(wikitext):
+def dump_base(key: str) -> str:
+    return f"https://dumps.wikimedia.org/{SITES[key]['wiki']}/{DUMP_DATE}"
+
+
+def legal_pin(pin: dict) -> dict:
+    """Fetch a legal-code page, check the clause the label rests on, record the page hash."""
+    body = request(pin["url"]).content
+    text = re.sub(r"\s+", " ", html.unescape(re.sub(r"<[^>]+>", " ", body.decode("utf-8", "replace"))))
+    if pin["statement"] not in text or (pin.get("absent") and pin["absent"] in text):
+        raise ValueError(f"legal code changed: {pin['url']}")
+    return {**pin, "sha256": hashlib.sha256(body).hexdigest()}
+
+
+def strip(wikitext: str) -> str | None:
+    """Wikitext -> plain text, exactly as the v0.2.5 builder did. None when the parser fails."""
+    import mwparserfromhell
     try:
         return mwparserfromhell.parse(wikitext).strip_code(normalize=True, collapse=True).strip()
-    except Exception:
-        return ""
+    except Exception:  # noqa: BLE001  parser failure drops the page, counted
+        return None
 
 
-def main():
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--out", default="~/Local/Ventures/Slayer/data/speakleash")
-    ap.add_argument("--wikis", nargs="+", default=list(SITE))
-    args = ap.parse_args()
-    out_dir = Path(args.out).expanduser(); out_dir.mkdir(parents=True, exist_ok=True)
-    cache = out_dir / "_wikimedia_dumps"; cache.mkdir(exist_ok=True)
-
-    for w in args.wikis:
-        base_url, domain = SITE[w]
-        print(f"[{w}] ({domain})", flush=True)
-        src = download(w, cache)
-        jsonl = out_dir / f"{w}.jsonl"
-        kept = 0; t0 = time.time()
-        with jsonl.open("w", encoding="utf-8") as fo:
-            for title, wt in pages(src):
-                text = strip(wt)
-                if len(text) < MIN_CHARS:
+def acquire(out: Path, key: str) -> None:
+    site, wiki, base = SITES[key], SITES[key]["wiki"], dump_base(key)
+    status = request_json(f"{base}/dumpstatus.json")["jobs"]["articlesdump"]
+    if status.get("status") != "done":
+        raise ValueError(f"{wiki} articlesdump not done: {status.get('status')}")
+    name = f"{wiki}-{DUMP_DATE}-pages-articles.xml.bz2"
+    meta = status["files"][name]
+    sums = {n: sha for sha, n in (ln.split() for ln in request(f"{base}/{wiki}-{DUMP_DATE}-sha1sums.txt").text.splitlines() if ln.strip())}
+    if sums.get(name) != meta["sha1"]:
+        raise ValueError(f"sha1sums.txt disagrees with dumpstatus.json for {name}")
+    rights = request_json(f"https://{site['host']}/w/api.php?action=query&meta=siteinfo&siprop=rightsinfo&format=json")["query"]["rightsinfo"]
+    if site["site_rights"] not in rights.get("url", ""):
+        raise ValueError(f"{wiki} rightsinfo changed: {rights}")
+    terms = []
+    for t in site["terms"]:
+        body = request(t["url"]).content
+        if hashlib.sha256(body).hexdigest() != t["sha256"] or t["effective"].encode() not in body:
+            raise ValueError(f"pinned terms page changed: {t['url']}")
+        terms.append(t)
+    legal = [legal_pin(p) for p in site["legal"]]
+    switch = None
+    if key == "wikinews":  # Gerrit prefixes its JSON with ")]}'"
+        change = json.loads(request(WIKINEWS_SWITCH["gerrit"]).text.split("\n", 1)[1])
+        task = request(WIKINEWS_SWITCH["phabricator"]).text
+        if change["status"] != "MERGED" or not change["submitted"].startswith("2024-12-16") or "T381421" not in task:
+            raise ValueError(f"Wikinews licence switch evidence changed: {change['status']} {change['submitted']}")
+        switch = {**WIKINEWS_SWITCH, "gerrit_status": change["status"], "gerrit_submitted": change["submitted"]}
+    raw = out / "raw_dump"
+    raw.mkdir(parents=True, exist_ok=True)
+    dst = raw / name
+    if not dst.exists() or dst.stat().st_size != meta["size"]:
+        subprocess.run(["curl", "-fsSL", "--retry", "8", "-C", "-", "-A", UA["User-Agent"],
+                        "-o", str(dst), f"{base}/{name}"], check=True)
+    if sha1_file(dst) != meta["sha1"]:
+        raise ValueError(f"sha1 mismatch: {name}")
+    save(out / f"{key}.selection.json", {
+        "observed_at": now(), "dump_date": DUMP_DATE, "dump_base": base, "sha1sums_url": f"{base}/{wiki}-{DUMP_DATE}-sha1sums.txt",
+        "file": {"name": name, "url": f"{base}/{name}", "size": meta["size"], "sha1": meta["sha1"]},
+        "rightsinfo": {**rights, "url_queried": f"https://{site['host']}/w/api.php?action=query&meta=siteinfo&siprop=rightsinfo"},
+        "terms": terms, "legal": legal, "switch": switch,
+        "cutoff": site["cutoff"].isoformat(), "before": site["before"], "after": site["after"],
+    })
+    print(f"{key}: {name} sha1 OK")
+
+
+def prepare(out: Path, key: str) -> None:
+    """Label each page, drop exact duplicates keeping the lowest page id, write the build input."""
+    site = SITES[key]
+    src = out / "raw_dump" / load(out / f"{key}.selection.json")["file"]["name"]
+    seen, counts, duplicates, last_id = set(), Counter(), [], 0
+    zst = subprocess.Popen(["zstd", "-q", "-f", "-3", "-o", str(out / f"{site['wiki']}.jsonl.zst")], stdin=subprocess.PIPE)
+    try:
+        with bz2.open(src, "rb") as fh, gzip.open(out / f"{key}.manifest.jsonl.gz", "wt", encoding="utf-8") as manifest:
+            for pageid, revid, ns, title, timestamp, redirect, wikitext in pages(fh):
+                counts["pages"] += 1
+                if int(pageid) <= last_id:  # "lowest page id wins" below relies on dump order
+                    raise ValueError(f"dump not in page-id order at {pageid}")
+                last_id = int(pageid)
+                if ns != "0":
                     continue
-                fo.write(json.dumps({
-                    "text": text,
-                    "meta": {"url": base_url + (title or "").replace(" ", "_"),
-                             "title": title, "wiki": w, "domain": domain},
-                }, ensure_ascii=False) + "\n")
-                kept += 1
-                if kept % 2000 == 0:
-                    print(f"  {kept:,} kept | {kept/(time.time()-t0):.0f}/s", flush=True)
-        subprocess.run(["zstd", "-19", "-f", "--rm", str(jsonl),
-                        "-o", str(out_dir / f"{w}.jsonl.zst")], check=True)
-        print(f"  {w}: {kept:,} docs in {round(time.time()-t0)}s -> {w}.jsonl.zst", flush=True)
+                counts["ns0"] += 1
+                if redirect:
+                    counts["ns0_redirect"] += 1
+                elif not wikitext.strip():
+                    counts["ns0_empty"] += 1
+                elif (text := strip(wikitext)) is None:
+                    counts["ns0_strip_error"] += 1
+                elif len(text) < MIN_CHARS:
+                    counts["ns0_short"] += 1
+                elif text_key(text) in seen:
+                    counts["exact_duplicate"] += 1
+                    duplicates.append(pageid)
+                else:
+                    seen.add(text_key(text))
+                    lic = label(key, timestamp)
+                    counts["written"] += 1
+                    counts[lic] += 1
+                    row_id, url = f"{key}_{pageid}", page_url(key, title)
+                    zst.stdin.write((json.dumps({
+                        "id": row_id, "text": text, "created": timestamp[:10],
+                        "license": lic, "author": f"{site['author']}, {url}",
+                    }, ensure_ascii=False) + "\n").encode("utf-8"))
+                    manifest.write(json.dumps({
+                        "id": row_id, "pageid": int(pageid), "revid": int(revid), "title": title, "url": url,
+                        "last_revision_at": timestamp, "license": lic,
+                    }, ensure_ascii=False) + "\n")
+    finally:  # a failed gate must not leave zstd waiting on stdin
+        zst.stdin.close()
+        status = zst.wait()
+    if status:
+        raise RuntimeError("zstd failed")
+    save(out / f"{key}.prepare.json", {"counts": dict(counts), "exact_duplicate_pageids": duplicates})
+    print(key, dict(counts))
+
+
+def attribution(out: Path, data_dir: Path, key: str) -> None:
+    """Sidecars for the rows build_dynaword kept: per-page attribution, build record, licence evidence."""
+    import pyarrow.parquet as pq
+    site = SITES[key]
+    table = pq.read_table(data_dir / f"{key}.parquet", columns=["id", "created", "license", "token_count"]).to_pydict()
+    tokens_of = dict(zip(table["id"], table["token_count"]))
+    rows = []
+    with gzip.open(out / f"{key}.manifest.jsonl.gz", "rt", encoding="utf-8") as fh:
+        for line in fh:
+            if (rec := json.loads(line))["id"] in tokens_of:
+                rows.append((line, rec))
+    if len(rows) != len(tokens_of):
+        raise ValueError(f"attribution rows {len(rows)} != parquet rows {len(tokens_of)}")
+    sidecar = data_dir / f"{key}.attribution.jsonl"
+    sidecar.write_text("".join(line for line, _ in rows), encoding="utf-8")
+    sel, prep = load(out / f"{key}.selection.json"), load(out / f"{key}.prepare.json")
+    tokens, docs = Counter(), Counter()
+    for lic, tok in zip(table["license"], table["token_count"]):
+        docs[lic] += 1
+        tokens[lic] += tok
+    day = site["cutoff"].date().isoformat()  # edits on the switch day are labelled `after`
+    on_day = [rec["last_revision_at"] for _, rec in rows if rec["last_revision_at"].startswith(day)]
+    boundary = {"day": day, "docs_last_edited_that_day": len(on_day)}
+    if clock := site.get("clock"):  # known deployment time of the switch, when there is one
+        boundary.update({"known_switch_time_utc": clock,
+                         "of_which_before_that_time": sum(t.replace("T", " ").rstrip("Z") < clock for t in on_day)})
+    scope = {"labels": dict(docs), "tokens": dict(tokens), "created_range": [min(table["created"]), max(table["created"])]}
+    old = [rec["id"] for _, rec in rows if rec["last_revision_at"] < site["era_end"]]  # recorded, not acted on
+    scope["last_edited_before_era_end"] = {"date": site["era_end"], "docs": len(old), "tokens": sum(tokens_of[i] for i in old)}
+    save(data_dir / f"{key}.build.json", {
+        "dump_date": sel["dump_date"], "dump_base": sel["dump_base"], "sha1sums_url": sel["sha1sums_url"],
+        "file": sel["file"], "rightsinfo": sel["rightsinfo"], "terms": sel["terms"], "switch": sel["switch"],
+        "cutoff": sel["cutoff"], "labels": {"before": sel["before"], "after": sel["after"]},
+        "discovered_at": sel["observed_at"], "prepare": prep,
+        "attribution_rows": len(rows), "attribution_sha256": digest(sidecar.read_bytes()),
+    })
+    save(data_dir / f"{key}.license-evidence.json", {
+        "license": f"{sel['before']} or {sel['after']} per record, by the page's last revision",
+        "spdx": [f"https://spdx.org/licenses/{sel['before']}.html", f"https://spdx.org/licenses/{sel['after']}.html"],
+        "status": "documented-open-cc-by-sa" if "SA" in sel["after"] else "documented-open-cc-by",
+        "review_scope": f"licence of contributors' text on {site['host']} and its version per page; not independent legal advice",
+        "checked_at": sel["observed_at"][:10],
+        "cutoff": {"at": sel["cutoff"], "before": sel["before"], "after": sel["after"], "boundary_day": boundary},
+        "terms": sel["terms"], "legal": sel["legal"], "switch": sel["switch"],
+        "site_licence": {"observed_at": sel["observed_at"], "rightsinfo": sel["rightsinfo"]},
+        "release_scope": scope,
+    })
+    print(f"{key}: attribution rows {len(rows)}, labels {dict(docs)}")
+
+
+def share(part: int, whole: int) -> str:
+    return f"{100 * part / whole:.1f}%"
+
+
+def licensing_text(key: str, ev: dict) -> str:
+    """The reading of the licences behind the labels, with the cutoff-day count."""
+    site, cut = SITES[key], ev["cutoff"]
+    day, n = cut["boundary_day"]["day"], cut["boundary_day"]["docs_last_edited_that_day"]
+    next_day = (site["cutoff"] + timedelta(days=1)).date().isoformat()
+    before, after = cut["before"], cut["after"]
+    if "SA" in after:
+        return (
+            f"A page last edited on or after the cutoff can still hold 3.0 text from earlier edits;\n"
+            f"[CC BY-SA 3.0](https://creativecommons.org/licenses/by-sa/3.0/legalcode) §4(b)(ii) lets such an adaptation be licensed under \"a later\n"
+            f"version of this License with the same License Elements\", so it is labelled 4.0. The Terms\n"
+            f"of Use give the day of the switch, not the time. The cutoff is midnight UTC, so the\n"
+            f"{n} pages last edited on {day} itself are labelled 4.0. If the switch came later\n"
+            f"that day, those last edited before it are 3.0 text under a 4.0 label; a {next_day} cutoff\n"
+            f"(the citation pass's fallback) would instead put that day's 4.0 edits under a 3.0 label,\n"
+            f"which [4.0](https://creativecommons.org/licenses/by-sa/4.0/legalcode) §3(b)(1) (\"this version or later\") does not allow. Neither choice is\n"
+            f"exact without the time of the switch. The rule is `license_for_revision` in `src/rights.py`,\n"
+            f"tested at the cutoff second, across time zones, and on a missing timestamp, which stops the\n"
+            f"build. v0.2.0-v0.2.5 labelled every row `{before}`."
+        )
+    sw, k = ev["switch"], cut["boundary_day"]["of_which_before_that_time"]
+    return (
+        f"pl.wikinews has its own terms page, which names CC BY 2.5 until {day} and CC BY 4.0 from that\n"
+        f"day. A page last edited on or after the cutoff can still hold\n"
+        f"2.5 text from earlier edits, and the [CC BY 2.5](https://creativecommons.org/licenses/by/2.5/legalcode) legal code (§4(a)) has no clause that lets an\n"
+        f"adaptation be licensed under a later version (BY-SA 3.0 §4(b)(ii) has one). The 4.0 label for such\n"
+        f"pages rests on the site's terms page alone; whether that is enough is for the lawyer.\n"
+        f"The terms page gives the day, not the time. The cutoff is midnight UTC, so the {n} pages last edited\n"
+        f"on {day} are labelled 4.0. The configuration change was merged {sw['merged_utc']} UTC and deployed\n"
+        f"by {sw['synced_by_utc']} UTC ([Gerrit change]({sw['gerrit']}), [{sw['phabricator'].rsplit('/', 1)[1]}]({sw['phabricator']});\n"
+        f"the deployment time was read by the rights audit, not re-read), so {k} of those {n} were last edited before it.\n"
+        f"The rule is `license_for_revision` in `src/rights.py`, tested at the cutoff second, across time\n"
+        f"zones, and on a missing timestamp, which stops the build. v0.2.0-v0.2.5 labelled every row `{before}`."
+    )
+
+
+def datasheet(out: Path, data_dir: Path, key: str) -> None:
+    """data/<key>/<key>.md from the stats, build record and licence evidence (custom_datasheet in sources.py)."""
+    site = SITES[key]
+    st, build, ev = (load(data_dir / f"{key}.{n}.json") for n in ("stats", "build", "license-evidence"))
+    scope, prep, file = ev["release_scope"], build["prepare"]["counts"], build["file"]
+    before, after = ev["cutoff"]["before"], ev["cutoff"]["after"]
+    kept, tok = st["kept"], st["tokens"]
+    table = "\n".join(
+        f"| {when} | `{lab}` | {scope['labels'].get(lab, 0):,} | {scope['tokens'].get(lab, 0):,} | {share(scope['tokens'].get(lab, 0), tok)} |"
+        for when, lab in ((f"before {ev['cutoff']['boundary_day']['day']}", before), (f"{ev['cutoff']['boundary_day']['day']} or later", after)))
+    labels = "\n".join(f"| `{lab}` | {scope['labels'].get(lab, 0):,} |" for lab in (before, after))
+    v_docs, v_chars, v_tokens = site["v025"]
+    same = (kept, st["chars"], tok) == (v_docs, v_chars, v_tokens)
+    v025 = ("The same text set as v0.2.5: documents, characters and tokens are unchanged; only labels, ids, authors and dates differ."
+            if same else f"v0.2.5 had {v_docs:,} documents, {v_chars:,} characters and {v_tokens:,} tokens.")
+    old = scope["last_edited_before_era_end"]
+    if "SA" in after:
+        era = (f"{old['docs']:,} documents ({old['tokens']:,} tokens, {share(old['tokens'], tok)}) were last edited before {old['date']}, when the Wikimedia sites\n"
+               f"began dual licensing under CC BY-SA 3.0 and the GFDL. Text first contributed before the 2009 move was\n"
+               f"under the GFDL only. They are labelled `{before}`, so only the CC BY-SA grant is relied on; the count is recorded, not acted on.")
+    else:
+        era = (f"The terms page puts articles created before {old['date']} in the public domain. The dump has only the date of the last\n"
+               f"revision, so how many released articles were created then is not known; {old['docs']:,} ({old['tokens']:,} tokens) were last edited before it.\n"
+               f"All rows carry a CC BY label; nothing is dropped or relabelled for this.")
+    review = ""
+    if (path := data_dir / f"{key}.gfdl-review.json").exists():
+        r = load(path)
+        review = f"\n\n{r['summary']} Per-document notes: `{path.name}`."
+    skipped = [f"{prep.get('ns0_redirect', 0):,} redirects", f"{prep.get('ns0_empty', 0):,} empty pages",
+               f"{prep.get('ns0_strip_error', 0):,} parser failures", f"{prep.get('ns0_short', 0):,} shorter than {MIN_CHARS} characters"]
+    chain = (f"{prep['pages']:,} pages scanned → {prep['ns0']:,} in namespace 0 → " + ", ".join(skipped) + " skipped"
+             + (f", {prep['exact_duplicate']:,} exact duplicates dropped" if prep.get("exact_duplicate") else ", no exact duplicates")
+             + f" → {prep['written']:,} read by the build → {kept:,} released.")
+    terms = "; ".join(f"[{t['title']}]({t['url']})" for t in ev["terms"])
+    with (data_dir / f"{key}.attribution.jsonl").open(encoding="utf-8") as fh:
+        example = min((json.loads(next(fh))["url"] for _ in range(200)), key=len)  # a short real URL
+    created = scope["created_range"]
+    when = ev["checked_at"]
+    (data_dir / f"{key}.md").write_text(f"""# {key}
+
+{site['pretty']}
+
+## Dataset description
+- **Source (upstream):** {build['dump_base']}/
+- **Domain:** {site['domain']}
+- **Language:** Polish (pl)
+- **License:** `{before}` or `{after}` per record (by last-revision date)
+- **Created (range):** {created[0]}, {created[1]} (date of the page's last revision in the dump)
+- **Added:** {site['added']}; rebuilt {when} (UTC) from the official Wikimedia dump
+
+## Licensing — traceable basis
+Contributors' text on {site['host']} is licensed {site['family']}: {terms} (read {when} UTC). The site licence
+(`rightsinfo`) reads "{ev['site_licence']['rightsinfo']['text']}". Each row is labelled by its page's last revision in the dump:
+
+| last revision (UTC) | `license` | documents | tokens | share of tokens |
+|---|---|---:|---:|---:|
+{table}
+
+{licensing_text(key, ev)}
+
+{era}{review}
+
+Evidence: `{key}.license-evidence.json`.
+
+## Attribution
+Each row's `author` is `{site['author']}, <page URL>`, e.g.
+`{site['author']}, {example}`. The page history names the contributors; {ATTRIBUTION[key]}
+`{key}.attribution.jsonl` has one line per row: `id`, `pageid`, `revid` (the revision
+in the dump), `title`, `url`, `last_revision_at`, `license`. The row `id` is
+`{key}_<page id>` and `created` is the date of `last_revision_at`.
+
+The text is modified: wiki markup is converted to plain text (see Provenance).
+
+## Provenance
+Parsed from the official Wikimedia dump `{file['name'][:-8]}` by
+`src/fetch_wikimedia.py`; the file ({file['size']:,} bytes, sha1 `{file['sha1']}`) was matched against the
+dump's `dumpstatus.json` and `sha1sums.txt` (`{key}.build.json`). v0.2.0-v0.2.5 used the same dump
+date; the text set is the same (the rebuild adds the last-revision time).
+
+Articles (namespace 0) only. Redirects, empty pages and pages shorter than {MIN_CHARS} characters are skipped.
+Wikitext is converted with mwparserfromhell `strip_code(normalize=True, collapse=True)`, as in v0.2.5.
+Templates and comments are dropped. `<ref>` bodies, category links (`Kategoria:...`) and file-link
+options (`thumb|...`) are not removed and stay in the text; the wikipedia fetcher's `strip_article`
+removes them, this one does not, because that would change the text set. Of two pages with the same
+text (sha1 of the stripped text), the lower page id is kept.
+
+{chain}
+
+## Statistics
+| documents | characters | tokens (tiktoken proxy) |
+|---:|---:|---:|
+| {kept:,} | {st['chars']:,} | {tok:,} |
+
+{v025}
+
+## Per-document license metadata
+| license | documents |
+|---|---:|
+{labels}
+
+Author metadata present for **{st['authors_with_value']:,}** documents.
+
+## Filters applied (build_dynaword.py)
+- drop documents < 200 chars: **{st['drop_short']:,}** (the fetcher already dropped {prep.get('ns0_short', 0):,})
+- drop non-Polish (diacritic ratio): **{st['drop_lang']:,}**
+- exact cross-source dedup (sha1): **{st['drop_dup']:,}**
+- OCR alpha-ratio < 0.70 (OCR sources only): **{st['drop_ocr']:,}**
+- read {st['read']:,} → kept {kept:,}
+
+Token counts are a fast tiktoken (cl100k) proxy (~1% off Llama-3); the canonical
+Llama-3 count is computed at release.
+
+## Not checked
+{NOT_CHECKED[key]}
+""", encoding="utf-8")
+    print(f"{key}: datasheet written")
+
+
+ATTRIBUTION = {
+    "wikinews": "the terms page asks for a link to the source article, which the URL gives.",
+    "wikivoyage": "the Terms of Use (section 7b) accept a hyperlink or URL to the page as attribution.",
+    "wikibooks": "the Terms of Use (section 7b) accept a hyperlink or URL to the page as attribution.",
+}
+NOT_CHECKED = {
+    "wikinews": """- pastes from copyrighted sources, including articles copied from press agencies or other publishers (no sample was run)
+- the 2.5 → 4.0 label of pages edited after the cutoff (a reading of the site's terms page, not a lawyer's opinion;
+  the lawyer's answer to E1, the wiki 3.0/4.0 labelling, is still pending, and whether it extends to 2.5 → 4.0 is not settled),
+  and the time of day of the switch
+- how many released articles were created before 2005-09-25, the public-domain date in the terms page
+- text imported from elsewhere under another licence or with extra attribution requirements
+- quotations inside articles (Art. 29 of the Polish copyright act)
+- personal data (the NERGAL scrub runs before release)""",
+    "wikivoyage": """- pastes from copyrighted sources (no sample was run)
+- the 3.0 → 4.0 label of pages edited after the cutoff (a reading of 3.0 §4(b)(ii), not a lawyer's opinion;
+  the lawyer's answer to E1, the wiki 3.0/4.0 labelling, is still pending), and the time of day of the switch
+- text imported from elsewhere under another licence or with extra attribution requirements
+- text first contributed under GFDL before the 2009 move to CC BY-SA, and GFDL dual
+  licensing; only the CC BY-SA grant is relied on
+- quotations inside articles (Art. 29 of the Polish copyright act)
+- personal data (the NERGAL scrub runs before release)""",
+}
+NOT_CHECKED["wikibooks"] = NOT_CHECKED["wikivoyage"]
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("step", choices=["acquire", "prepare", "attribution", "datasheet"])
+    ap.add_argument("--out", required=True, type=Path)
+    ap.add_argument("--sources", nargs="+", default=list(SITES), choices=list(SITES))
+    ap.add_argument("--data-root", type=Path, default=Path(__file__).resolve().parent.parent / "data")
+    a = ap.parse_args()
+    a.out.mkdir(parents=True, exist_ok=True)
+    for key in a.sources:
+        data_dir = a.data_root / key
+        {"acquire": lambda: acquire(a.out, key), "prepare": lambda: prepare(a.out, key),
+         "attribution": lambda: attribution(a.out, data_dir, key),
+         "datasheet": lambda: datasheet(a.out, data_dir, key)}[a.step]()
 
 
 if __name__ == "__main__":

src/fetch_wikipedia.py

@@ -20,7 +20,6 @@ import argparse
 import bz2
 from collections import Counter
 from concurrent.futures import ProcessPoolExecutor
-from datetime import datetime, timezone
 import gzip
 import hashlib
 import json
@@ -34,6 +33,7 @@ sys.path.insert(0, str(Path(__file__).resolve().parent))
 from build_plwiki_talk_pl import (  # noqa: E402  shared plwiki dump helpers
     UA, _local, digest, load, now, page_url, request, request_json, save, sha1_file,
 )
+from rights import BY_SA_4_CUTOFF, license_for_revision  # noqa: E402,F401  re-exported for callers
 
 SOURCE = "wikipedia"
 AUTHOR = "Wikipedia contributors"  # + page URL; the page history names them
@@ -49,13 +49,6 @@ TOU_URL = "https://foundation.wikimedia.org/w/index.php?title=Policy:Terms_of_Us
 TOU_SHA256 = "c96ef93b439ff9b8242dc3233f41ede57c0984ef9153fafa51aa5f8cf0678832"
 TOU_EFFECTIVE = "These Terms of Use went into effect on June 7, 2023"
 
-# Text contributed under the 2014 ToU is CC BY-SA 3.0; the ToU in force from
-# 2023-06-07 moved new text to CC BY-SA 4.0. A page last edited on or after the
-# cutoff is an adaptation of its 3.0 text, which BY-SA 3.0 s4(b)(ii) lets us
-# distribute under 4.0 (same licence elements). Time of day of the switch is not
-# published, so midnight UTC labels that whole day 4.0 (the later licence).
-BY_SA_4_CUTOFF = datetime(2023, 6, 7, tzinfo=timezone.utc)
-
 # plwiki copyright-violation notice and its redirects (Szablon:NPA <- Copyvio, Plagiat).
 # Namespace prefix is case-insensitive, the first letter of the name too.
 COPYVIO_RE = re.compile(r"\{\{\s*(?:(?i:szablon|template)\s*:\s*)?(?:[Nn]PA|[Cc]opyvio|[Pp]lagiat)\s*(?:\||\}\})")
@@ -148,16 +141,6 @@ def ek_is_copyright(ek: dict) -> bool:
     return bool(EK_COPYRIGHT_RE.search(ek["reason"]))
 
 
-def license_for_revision(timestamp: str | None) -> str:
-    """SPDX label for a page whose last revision is at `timestamp` (ISO 8601 with zone)."""
-    if not timestamp:
-        raise ValueError("missing revision timestamp")
-    ts = datetime.fromisoformat(timestamp)
-    if ts.tzinfo is None:
-        raise ValueError(f"revision timestamp without timezone: {timestamp!r}")
-    return "CC-BY-SA-4.0" if ts >= BY_SA_4_CUTOFF else "CC-BY-SA-3.0"
-
-
 def text_key(text: str) -> bytes:
     """Exact-duplicate key, identical to build_dynaword's (sha1 of the stripped text)."""
     return hashlib.sha1(text.strip().encode("utf-8")).digest()

src/rights.py

@@ -4,7 +4,13 @@ Dynaword principle = openly licensed. Allow only PD / CC0 / CC-BY / CC-BY-SA.
 NC/ND are not open; InC / NoC-* / CNE are in-copyright or unclear -> drop.
 Wire into build_dynaword.py only for europeana (per-record); other sources keep
 their single per-source license.
+
+Also holds license_for_revision(): the per-page label of the Wikimedia sources
+(wikipedia, wikinews, wikivoyage, wikibooks), chosen by the page's last revision.
 """
+from __future__ import annotations
+
+from datetime import datetime, timezone
 
 # ponytail: substring match on the rights URI — finite, well-known statement set
 _OPEN = (
@@ -32,6 +38,30 @@ def spdx(uri: str) -> str:
     return "UNKNOWN"
 
 
+# Text contributed under the 2014 Wikimedia ToU is CC BY-SA 3.0; the ToU in force from
+# 2023-06-07 moved new text to CC BY-SA 4.0. A page last edited on or after the
+# cutoff is an adaptation of its 3.0 text, which BY-SA 3.0 s4(b)(ii) lets us
+# distribute under 4.0 (same licence elements). Time of day of the switch is not
+# published, so midnight UTC labels that whole day 4.0 (the later licence).
+BY_SA_4_CUTOFF = datetime(2023, 6, 7, tzinfo=timezone.utc)
+# pl.wikinews moved from CC BY 2.5 to CC BY 4.0 on 2024-12-16 (Wikinews:Warunki uzycia;
+# config deployed 08:08-08:32 UTC, Phabricator T381421). Same midnight-UTC rule.
+WIKINEWS_BY_4_CUTOFF = datetime(2024, 12, 16, tzinfo=timezone.utc)
+
+
+def license_for_revision(timestamp: str | None, cutoff: datetime = BY_SA_4_CUTOFF,
+                         before: str = "CC-BY-SA-3.0", after: str = "CC-BY-SA-4.0") -> str:
+    """SPDX label for a page whose last revision is at `timestamp` (ISO 8601 with zone):
+    `before` if it predates `cutoff`, else `after`. The defaults are the Wikimedia
+    CC BY-SA 3.0 -> 4.0 switch; wikinews passes its own cutoff and labels."""
+    if not timestamp:
+        raise ValueError("missing revision timestamp")
+    ts = datetime.fromisoformat(timestamp)
+    if ts.tzinfo is None:
+        raise ValueError(f"revision timestamp without timezone: {timestamp!r}")
+    return after if ts >= cutoff else before
+
+
 if __name__ == "__main__":  # self-check
     assert rights_ok("http://creativecommons.org/licenses/by-sa/4.0/")
     assert rights_ok("https://creativecommons.org/publicdomain/mark/1.0/")
@@ -44,4 +74,6 @@ if __name__ == "__main__":  # self-check
     assert spdx("http://creativecommons.org/licenses/by-sa/4.0/") == "CC-BY-SA-4.0"
     assert spdx("http://creativecommons.org/publicdomain/zero/1.0/") == "CC0-1.0"
     assert spdx("http://creativecommons.org/publicdomain/mark/1.0/") == "public-domain (PDM-1.0)"
+    assert license_for_revision("2023-06-06T23:59:59Z") == "CC-BY-SA-3.0"
+    assert license_for_revision("2023-06-07T00:00:00Z") == "CC-BY-SA-4.0"
     print("ok")

src/sources.py

@@ -355,18 +355,32 @@ SOURCES = {
         "added": "2026-07-02",
         "release": "0.2.0",
         "file_key": "plwikinews",  # fetched from Wikimedia dumps, NOT via SpeakLeash
+        "preserve_id": True,
+        "preserve_created": True,
         "pretty": "Polish Wikinews",
-        "license": "CC-BY-2.5",
-        "license_spdx": "CC-BY-2.5",
-        "traceable": "Wikinews content is released under CC-BY 2.5; attribution to "
-                     "contributors preserved.",
-        "upstream": "https://pl.wikinews.org/",
-        "provenance": "Fetched directly from the official Wikimedia dump "
-                      "(plwikinews-latest-pages-articles) by src/fetch_wikimedia.py; "
-                      "mainspace only, wikitext stripped via mwparserfromhell.",
+        "provenance": "Parsed directly from the official Wikimedia dump "
+                      "plwikinews-20260601-pages-articles (sha1 checked against the "
+                      "dump's dumpstatus.json and sha1sums.txt) by "
+                      "src/fetch_wikimedia.py. Articles (namespace 0) only, no "
+                      "redirects; one document per page, id from the page id. The text "
+                      "set is the one released in v0.2.0-v0.2.5; the rebuild adds the "
+                      "page's last-revision time, which sets the licence label.",
+        "license": "CC BY (2.5 or 4.0 per record, by last-revision date)",
+        "license_spdx": "MIXED",
+        "traceable": "pl.wikinews licenses its content CC BY 2.5 until 2024-12-16 and "
+                     "CC BY 4.0 from that day (its terms page). A page whose last "
+                     "revision predates 2024-12-16 is labelled CC-BY-2.5; one revised "
+                     "on or after that day is labelled CC-BY-4.0. It may still hold 2.5 "
+                     "text, and CC BY 2.5 has no later-version clause, so that label "
+                     "rests on the terms page alone. Each row's author field links its "
+                     "page, whose history names the contributors; "
+                     "wikinews.attribution.jsonl gives page id, revision id, title and "
+                     "last-revision time per row.",
+        "upstream": "https://dumps.wikimedia.org/plwikinews/20260601/",
         "domain": "news",
-        "created": "2005-01-01, 2025-12-31",
+        "created": "2011-12-24, 2026-05-25",
         "is_ocr": False,
+        "custom_datasheet": True,
     },
     "wikivoyage": {
         "added": "2026-07-02",

src/test_wikimedia_contract.py

@@ -0,0 +1,385 @@
+"""Unit and contract checks for src/fetch_wikimedia.py (wikinews, wikivoyage, wikibooks).
+
+The unit tests run on a fixture dump and never touch data/. `check_released(key, tmp_path)`
+is the contract on a released source; test_<key>_contract.py calls it, so a branch carrying
+one source's data is tested against that source only."""
+
+import bz2
+from collections import Counter
+from datetime import datetime, timedelta, timezone
+import gzip
+import json
+from pathlib import Path
+import re
+import shutil
+import subprocess
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+import pytest
+
+import fetch_wikimedia as fm
+import fetch_wikipedia as fw
+import rights
+from rights import BY_SA_4_CUTOFF, WIKINEWS_BY_4_CUTOFF, license_for_revision
+from sources import SOURCES
+from verify_paper_claims import license_family
+
+ROOT = Path(__file__).resolve().parents[1]
+KEYS = sorted(fm.SITES)
+SHA256 = re.compile(r"[0-9a-f]{64}")
+SHA1 = re.compile(r"[0-9a-f]{40}")
+
+
+def _read(path):
+    return json.loads(Path(path).read_text(encoding="utf-8"))
+
+
+# --- licence label per last-revision timestamp -------------------------------------------
+
+@pytest.mark.parametrize("timestamp, label", [
+    ("2023-06-07T00:00:00Z", "CC-BY-SA-4.0"),       # exactly the cutoff
+    ("2023-06-06T23:59:59Z", "CC-BY-SA-3.0"),       # one second before
+    ("2023-06-07T00:30:00+01:00", "CC-BY-SA-3.0"),  # 2023-06-06T23:30Z
+    ("2023-06-06T23:30:00-01:00", "CC-BY-SA-4.0"),  # 2023-06-07T00:30Z
+    ("2004-03-01T10:00:00Z", "CC-BY-SA-3.0"),
+    ("2026-09-01T12:00:00Z", "CC-BY-SA-4.0"),
+])
+def test_license_for_revision_defaults_are_the_wikimedia_by_sa_switch(timestamp, label):
+    assert license_for_revision(timestamp) == label
+
+
+@pytest.mark.parametrize("timestamp, label", [
+    ("2024-12-16T00:00:00Z", "CC-BY-4.0"),
+    ("2024-12-15T23:59:59Z", "CC-BY-2.5"),
+    ("2024-12-16T00:30:00+01:00", "CC-BY-2.5"),     # 2024-12-15T23:30Z
+    ("2024-12-15T23:30:00-01:00", "CC-BY-4.0"),     # 2024-12-16T00:30Z
+    ("2011-12-24T00:00:00Z", "CC-BY-2.5"),
+    ("2023-06-07T00:00:00Z", "CC-BY-2.5"),          # the BY-SA cutoff means nothing to wikinews
+])
+def test_license_for_revision_with_the_wikinews_cutoff(timestamp, label):
+    assert license_for_revision(timestamp, WIKINEWS_BY_4_CUTOFF, "CC-BY-2.5", "CC-BY-4.0") == label
+
+
+@pytest.mark.parametrize("timestamp", [None, "", "2023-06-07T00:00:00", "2023-06-07", "not a date"])
+@pytest.mark.parametrize("args", [(), (WIKINEWS_BY_4_CUTOFF, "CC-BY-2.5", "CC-BY-4.0")])
+def test_license_for_revision_fails_without_a_zoned_timestamp(timestamp, args):
+    with pytest.raises(ValueError):
+        license_for_revision(timestamp, *args)
+
+
+def test_cutoffs_are_midnight_utc_and_the_wikipedia_module_re_exports_the_helper():
+    for cutoff in (BY_SA_4_CUTOFF, WIKINEWS_BY_4_CUTOFF):
+        assert cutoff.utcoffset() == timedelta(0) and cutoff.time().isoformat() == "00:00:00"
+    assert (BY_SA_4_CUTOFF.date().isoformat(), WIKINEWS_BY_4_CUTOFF.date().isoformat()) == ("2023-06-07", "2024-12-16")
+    assert fw.license_for_revision is rights.license_for_revision and fw.BY_SA_4_CUTOFF is BY_SA_4_CUTOFF
+
+
+@pytest.mark.parametrize("key", KEYS)
+def test_site_config(key):
+    site = fm.SITES[key]
+    assert site["cutoff"].tzinfo is not None and site["before"] != site["after"]
+    assert fm.label(key, (site["cutoff"] - timedelta(seconds=1)).isoformat()) == site["before"]
+    assert fm.label(key, site["cutoff"].isoformat()) == site["after"]
+    assert site["cutoff"] == (WIKINEWS_BY_4_CUTOFF if key == "wikinews" else BY_SA_4_CUTOFF)
+    assert site["wiki"] == "pl" + key and site["host"] == f"pl.{key}.org"
+    assert all(SHA256.fullmatch(t["sha256"]) and t["effective"] and t["statement"] for t in site["terms"])
+    assert all(p["url"].startswith("https://creativecommons.org/licenses/") and p["statement"] for p in site["legal"])
+    assert ("clock" in site) == (key == "wikinews")  # only wikinews has a known time of day for the switch
+    assert fm.dump_base(key) == f"https://dumps.wikimedia.org/pl{key}/{fm.DUMP_DATE}"
+
+
+# --- small helpers -------------------------------------------------------------------------
+
+def test_page_url_quotes_the_title_and_keeps_namespace_and_subpage_separators():
+    assert fm.page_url("wikivoyage", "Kraków (miasto)") == "https://pl.wikivoyage.org/wiki/Krak%C3%B3w_%28miasto%29"
+    assert fm.page_url("wikibooks", "Książka:C/O podręczniku") == "https://pl.wikibooks.org/wiki/Ksi%C4%85%C5%BCka:C/O_podr%C4%99czniku"
+    assert fm.page_url("wikinews", None) == "https://pl.wikinews.org/wiki/"
+
+
+def test_strip_converts_wikitext_as_the_v025_builder_did():
+    # plain strip_code: templates and comments go, ref bodies and category links stay (see the card)
+    assert fm.strip("'''Ala''' ma [[kot|kota]]<!-- x -->{{Szablon|a}}.\n\n\n[[Kategoria:Koty]]") == "Ala ma kota.\n\nKategoria:Koty"
+    assert fm.strip("  \n") == ""
+
+
+def test_strip_reports_a_parser_failure_as_none(monkeypatch):
+    import mwparserfromhell
+
+    def boom(_):
+        raise RuntimeError("parser")
+    monkeypatch.setattr(mwparserfromhell, "parse", boom)
+    assert fm.strip("tekst") is None
+
+
+class _Reply:
+    def __init__(self, body):
+        self.content = body
+
+
+@pytest.mark.parametrize("body, ok", [
+    (b"<p>a later   version of this</p> <b>License</b> text", True),
+    (b"<p>text without the clause</p>", False),
+    (b"<p>a later version of this License text; also: later version</p>", True),
+])
+def test_legal_pin_requires_the_clause_the_label_rests_on(monkeypatch, body, ok):
+    pin = {"url": "https://x/legalcode", "section": "4", "statement": "a later version of this License"}
+    monkeypatch.setattr(fm, "request", lambda url: _Reply(body))
+    if ok:
+        assert fm.legal_pin(pin) == {**pin, "sha256": fm.hashlib.sha256(body).hexdigest()}
+    else:
+        with pytest.raises(ValueError, match="legal code changed"):
+            fm.legal_pin(pin)
+
+
+def test_legal_pin_fails_when_a_clause_that_must_be_absent_appears(monkeypatch):
+    pin = {"url": "https://x/legalcode", "section": "4(a)", "statement": "You may not sublicense", "absent": "later version"}
+    monkeypatch.setattr(fm, "request", lambda url: _Reply(b"You may not sublicense the Work"))
+    assert fm.legal_pin(pin)["sha256"]
+    monkeypatch.setattr(fm, "request", lambda url: _Reply(b"You may not sublicense the Work. A later version applies."))
+    with pytest.raises(ValueError, match="legal code changed"):
+        fm.legal_pin(pin)
+
+
+# --- dump pipeline on a fixture ------------------------------------------------------------
+
+def _page(pageid, title, ns, timestamp, text, redirect=""):
+    return (f"<page><title>{title}</title><ns>{ns}</ns><id>{pageid}</id>"
+            + (f'<redirect title="{redirect}" />' if redirect else "")
+            + f"<revision><id>{pageid * 100}</id><parentid>1</parentid>"
+            + (f"<timestamp>{timestamp}</timestamp>" if timestamp else "")
+            + f"<contributor><username>U</username><id>7</id></contributor>"
+            f"<text bytes=\"1\">{text}</text><sha1>x</sha1></revision></page>")
+
+
+def _wrap(*pages):
+    return ('<mediawiki xmlns="http://www.mediawiki.org/xml/export-0.11/"><siteinfo><sitename>W</sitename></siteinfo>'
+            + "".join(pages) + "</mediawiki>")
+
+
+OLD = "Stary artykuł opisuje wydarzenia sprzed wielu lat, spisane przez pierwszych autorów tego serwisu. " * 4
+BODY = "Ala jest polskim imieniem żeńskim, noszonym przez wiele znanych osób w różnych epokach. " * 4
+DOG = "Pies domowy jest udomowionym ssakiem z rodziny psowatych, towarzyszem człowieka od wieków. " * 4
+MOUSE = "Mysz domowa jest gryzoniem z rodziny myszowatych, żyjącym zwykle w pobliżu człowieka. " * 4
+NAME = "dump.xml.bz2"
+
+
+def _stamp(moment):
+    return moment.strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def _fixture(key):
+    """Pages around the site's cutoff; the page ids are in dump order."""
+    site = fm.SITES[key]
+    cut, era = site["cutoff"], datetime.fromisoformat(site["era_end"]) - timedelta(days=1)
+    return _wrap(
+        _page(5, "Stara", 0, _stamp(era), OLD),
+        _page(10, "Ala", 0, _stamp(cut), BODY + "[[Kategoria:Imiona]]"),   # the cutoff second
+        _page(11, "Przekierowanie", 0, _stamp(cut), "#PATRZ [[Ala]]", redirect="Ala"),
+        _page(12, "Dyskusja:Ala", 1, _stamp(cut), BODY),
+        _page(13, "Pusty", 0, _stamp(cut), ""),
+        _page(14, "Krótki", 0, _stamp(cut), "Krótki tekst."),
+        _page(15, "Kopia Ali", 0, _stamp(cut), BODY + "[[Kategoria:Imiona]]"),  # same text as 10
+        _page(16, "Pies", 0, _stamp(cut - timedelta(seconds=1)), DOG),
+        _page(17, "Mysz (zwierzę)", 0, _stamp(cut + timedelta(hours=9)), MOUSE),
+    )
+
+
+def _selection(tmp_path, key):
+    site = fm.SITES[key]
+    (tmp_path / "raw_dump").mkdir(exist_ok=True)
+    fm.save(tmp_path / f"{key}.selection.json", {
+        "observed_at": "2026-10-06T00:00:00Z", "dump_date": fm.DUMP_DATE, "dump_base": fm.dump_base(key),
+        "sha1sums_url": "s", "file": {"name": NAME, "size": 1, "sha1": "x"}, "rightsinfo": {"url": "r"},
+        "terms": site["terms"], "legal": site["legal"], "switch": None,
+        "cutoff": site["cutoff"].isoformat(), "before": site["before"], "after": site["after"],
+    })
+
+
+def _prepare(tmp_path, key, xml):
+    _selection(tmp_path, key)
+    (tmp_path / "raw_dump" / NAME).write_bytes(bz2.compress(xml.encode()))
+    fm.prepare(tmp_path, key)
+    out = subprocess.run(["zstd", "-dc", str(tmp_path / f"pl{key}.jsonl.zst")], capture_output=True, check=True)
+    return [json.loads(line) for line in out.stdout.decode().splitlines()]
+
+
+needs_zstd = pytest.mark.skipif(shutil.which("zstd") is None, reason="zstd CLI")
+
+
+@needs_zstd
+@pytest.mark.parametrize("key", KEYS)
+def test_prepare_labels_filters_and_dedups(tmp_path, key):
+    site = fm.SITES[key]
+    before, after = site["before"], site["after"]
+    rows = _prepare(tmp_path, key, _fixture(key))
+    # 15 repeats 10's text and is dropped (lowest id wins); redirect, talk page, empty and short pages are skipped
+    assert [r["id"] for r in rows] == [f"{key}_{i}" for i in (5, 10, 16, 17)]
+    assert [r["license"] for r in rows] == [before, after, before, after]
+    cut = site["cutoff"]
+    assert [r["created"] for r in rows][1:] == [cut.date().isoformat(), (cut - timedelta(seconds=1)).date().isoformat(),
+                                               cut.date().isoformat()]
+    assert rows[1]["author"] == f"{site['author']}, https://{site['host']}/wiki/Ala"
+    assert rows[3]["author"] == f"{site['author']}, https://{site['host']}/wiki/Mysz_%28zwierz%C4%99%29"
+    assert set(rows[0]) == {"id", "text", "created", "license", "author"}
+    prep = _read(tmp_path / f"{key}.prepare.json")
+    assert prep == {"counts": {"pages": 9, "ns0": 8, "ns0_redirect": 1, "ns0_empty": 1, "ns0_short": 1,
+                               "exact_duplicate": 1, "written": 4, before: 2, after: 2},
+                    "exact_duplicate_pageids": ["15"]}
+    with gzip.open(tmp_path / f"{key}.manifest.jsonl.gz", "rt", encoding="utf-8") as fh:
+        manifest = [json.loads(line) for line in fh]
+    assert [(m["id"], m["pageid"], m["revid"], m["license"]) for m in manifest] == [
+        (f"{key}_5", 5, 500, before), (f"{key}_10", 10, 1000, after), (f"{key}_16", 16, 1600, before), (f"{key}_17", 17, 1700, after)]
+    assert manifest[1]["last_revision_at"] == _stamp(cut) and manifest[1]["title"] == "Ala"
+
+
+@needs_zstd
+def test_prepare_fails_on_a_dump_out_of_page_id_order(tmp_path):
+    xml = _wrap(_page(20, "A", 0, "2020-01-01T00:00:00Z", BODY), _page(10, "B", 0, "2020-01-01T00:00:00Z", DOG))
+    with pytest.raises(ValueError, match="page-id order at 10"):
+        _prepare(tmp_path, "wikibooks", xml)
+
+
+@needs_zstd
+@pytest.mark.parametrize("timestamp", [None, "2020-01-01T00:00:00"])
+def test_prepare_fails_on_a_kept_page_without_a_usable_timestamp(tmp_path, timestamp):
+    xml = _wrap(_page(10, "A", 0, timestamp, BODY))
+    with pytest.raises(ValueError):
+        _prepare(tmp_path, "wikinews", xml)
+
+
+@needs_zstd
+def test_prepare_ignores_a_missing_timestamp_on_a_skipped_page(tmp_path):
+    xml = _wrap(_page(10, "A", 0, None, "#PATRZ [[B]]", redirect="B"), _page(11, "B", 0, "2020-01-01T00:00:00Z", BODY))
+    assert [r["id"] for r in _prepare(tmp_path, "wikinews", xml)] == ["wikinews_11"]
+
+
+def _kept_table(tmp_path, ids_tokens, rows):
+    """The parquet the build would leave: attribution reads id, created, license, token_count."""
+    by_id = {r["id"]: r for r in rows}
+    data = tmp_path / "data"
+    data.mkdir(exist_ok=True)
+    pq.write_table(pa.table({
+        "id": [i for i, _ in ids_tokens], "created": [by_id[i]["created"] for i, _ in ids_tokens],
+        "license": [by_id[i]["license"] for i, _ in ids_tokens], "token_count": [t for _, t in ids_tokens]}),
+        data / "x.parquet")
+    return data
+
+
+@needs_zstd
+@pytest.mark.parametrize("key", KEYS)
+def test_attribution_sidecars_cover_the_kept_rows_and_split_the_cutoff_day(tmp_path, key):
+    site = fm.SITES[key]
+    rows = _prepare(tmp_path, key, _fixture(key))
+    # the build keeps 5, 10 and 17 (16 fails its language gate)
+    kept = [(f"{key}_5", 100), (f"{key}_10", 200), (f"{key}_17", 300)]
+    data = _kept_table(tmp_path, kept, rows)
+    (data / "x.parquet").rename(data / f"{key}.parquet")
+    fm.attribution(tmp_path, data, key)
+    sidecar = data / f"{key}.attribution.jsonl"
+    recs = [json.loads(line) for line in sidecar.read_text(encoding="utf-8").splitlines()]
+    assert [r["id"] for r in recs] == [i for i, _ in kept]
+    assert set(recs[1]) == {"id", "pageid", "revid", "title", "url", "last_revision_at", "license"}
+    assert recs[2]["url"] == f"https://{site['host']}/wiki/Mysz_%28zwierz%C4%99%29" and recs[2]["revid"] == 1700
+
+    build = _read(data / f"{key}.build.json")
+    assert build["attribution_rows"] == 3 and build["attribution_sha256"] == fm.digest(sidecar.read_bytes())
+    assert build["prepare"] == _read(tmp_path / f"{key}.prepare.json") and build["labels"] == {"before": site["before"], "after": site["after"]}
+
+    ev = _read(data / f"{key}.license-evidence.json")
+    day = site["cutoff"].date().isoformat()
+    boundary = {"day": day, "docs_last_edited_that_day": 2}  # 10 at midnight and 17 at 09:00; 16 is the day before
+    if "clock" in site:
+        boundary.update(known_switch_time_utc=site["clock"], of_which_before_that_time=1)  # 10 only
+    assert ev["cutoff"] == {"at": site["cutoff"].isoformat(), "before": site["before"], "after": site["after"], "boundary_day": boundary}
+    scope = ev["release_scope"]
+    assert scope["labels"] == {site["before"]: 1, site["after"]: 2}
+    assert scope["tokens"] == {site["before"]: 100, site["after"]: 500}
+    assert scope["created_range"] == [min(r["created"] for r in rows if r["id"] in dict(kept)), day]
+    assert scope["last_edited_before_era_end"] == {"date": site["era_end"], "docs": 1, "tokens": 100}  # page 5
+    assert ev["status"] == ("documented-open-cc-by-sa" if "SA" in site["after"] else "documented-open-cc-by")
+    assert ev["checked_at"] == "2026-10-06" and ev["terms"] == site["terms"]
+
+
+@needs_zstd
+def test_attribution_fails_when_the_parquet_has_a_row_the_dump_does_not(tmp_path):
+    rows = _prepare(tmp_path, "wikibooks", _fixture("wikibooks"))
+    data = _kept_table(tmp_path, [("wikibooks_10", 1), ("wikibooks_999", 1)], rows + [{"id": "wikibooks_999", "created": "2020-01-01", "license": "x"}])
+    (data / "x.parquet").rename(data / "wikibooks.parquet")
+    with pytest.raises(ValueError, match="attribution rows 1 != parquet rows 2"):
+        fm.attribution(tmp_path, data, "wikibooks")
+
+
+# --- the contract on a released source -----------------------------------------------------
+
+def check_released(key, tmp_path):
+    """Checks that hold for any source built by fetch_wikimedia.py; counts specific to a source live in its own test file."""
+    site, data, entry = fm.SITES[key], ROOT / "data" / key, SOURCES[key]
+    stats, build, ev = (_read(data / f"{key}.{n}.json") for n in ("stats", "build", "license-evidence"))
+    assert pq.read_schema(data / f"{key}.parquet").names == ["id", "text", "source", "added", "created", "token_count", "license", "author"]
+    cols = pq.read_table(data / f"{key}.parquet").to_pydict()
+    n = len(cols["id"])
+    meta = {}
+    with (data / f"{key}.attribution.jsonl").open(encoding="utf-8") as fh:
+        for line in fh:
+            rec = json.loads(line)
+            meta[rec["id"]] = rec
+    sidecar = (data / f"{key}.attribution.jsonl").read_bytes()
+
+    # rows, counts, the unchanged text set
+    assert n == stats["kept"] == build["attribution_rows"] == len(meta) == len(set(cols["id"]))
+    assert set(cols["source"]) == {key} and len(set(cols["added"])) == 1
+    assert (stats["kept"], stats["chars"], stats["tokens"]) == site["v025"]  # the rebuild changes labels, not the text set
+    assert sum(len(t) for t in cols["text"]) == stats["chars"] and sum(cols["token_count"]) == stats["tokens"]
+    assert min(len(t) for t in cols["text"]) >= fm.MIN_CHARS and stats["drop_short"] == stats["drop_dup"] == 0
+    counts = build["prepare"]["counts"]
+    skipped = sum(counts.get(k, 0) for k in ("ns0_redirect", "ns0_empty", "ns0_strip_error", "ns0_short", "exact_duplicate"))
+    assert counts["ns0"] == skipped + counts["written"] and counts["written"] == stats["read"] == n + stats["drop_lang"]
+    assert counts[site["before"]] + counts[site["after"]] == counts["written"]
+    assert build["attribution_sha256"] == fm.digest(sidecar)
+
+    # every row's label, date, author and id follow the page's last revision
+    for row_id, created, label, author in zip(cols["id"], cols["created"], cols["license"], cols["author"]):
+        m = meta[row_id]
+        assert label == m["license"] == fm.label(key, m["last_revision_at"]) and label in (site["before"], site["after"])
+        assert created == m["last_revision_at"][:10]
+        assert m["url"] == fm.page_url(key, m["title"]) and author == f"{site['author']}, {m['url']}"
+        assert row_id == f"{key}_{m['pageid']}"
+    scope = ev["release_scope"]
+    tokens = Counter()
+    for label, tok in zip(cols["license"], cols["token_count"]):
+        tokens[label] += tok
+    assert stats["licenses"] == dict(Counter(cols["license"])) == scope["labels"] and scope["tokens"] == dict(tokens)
+    assert scope["created_range"] == [min(cols["created"]), max(cols["created"])]
+    day = site["cutoff"].date().isoformat()
+    on_day = [m["last_revision_at"] for m in meta.values() if m["last_revision_at"].startswith(day)]
+    assert ev["cutoff"]["boundary_day"]["docs_last_edited_that_day"] == len(on_day)
+    if "clock" in site:
+        assert ev["cutoff"]["boundary_day"]["of_which_before_that_time"] == sum(t.replace("T", " ").rstrip("Z") < site["clock"] for t in on_day)
+    old = [m for m in meta.values() if m["last_revision_at"] < site["era_end"]]
+    assert scope["last_edited_before_era_end"] == {"date": site["era_end"], "docs": len(old),
+                                                   "tokens": sum(t for i, t in zip(cols["id"], cols["token_count"]) if meta[i]["last_revision_at"] < site["era_end"])}
+
+    # the evidence is what the fetcher pins
+    assert ev["cutoff"]["at"] == site["cutoff"].isoformat() and ev["terms"] == site["terms"]
+    assert [(p["url"], p["section"], p["statement"]) for p in ev["legal"]] == [(p["url"], p["section"], p["statement"]) for p in site["legal"]]
+    assert all(SHA256.fullmatch(p["sha256"]) for p in ev["legal"]) and ev["switch"] == build["switch"]
+    assert (ev["switch"]["synced_by_utc"] == site["clock"] and ev["switch"]["gerrit_status"] == "MERGED") if "clock" in site else ev["switch"] is None
+    assert build["file"]["name"] == f"{site['wiki']}-{fm.DUMP_DATE}-pages-articles.xml.bz2" and SHA1.fullmatch(build["file"]["sha1"])
+    assert build["dump_date"] == fm.DUMP_DATE and build["dump_base"] == fm.dump_base(key)
+    assert re.fullmatch(r"\d{4}-\d\d-\d\d", ev["checked_at"])
+
+    # the registry entry and the card
+    assert entry["file_key"] == site["wiki"] and entry["preserve_id"] is True and entry["preserve_created"] is True
+    assert entry["license_spdx"] == "MIXED" and entry["release"] == "0.2.0" and entry["custom_datasheet"] is True
+    assert entry["upstream"] == build["dump_base"] + "/" and stats["license"] == entry["license"]
+    assert entry["created"] == ", ".join(scope["created_range"])
+    assert license_family(entry["license"]) == site["family"].replace(" ", "-")
+    work = tmp_path / "data"
+    work.mkdir()
+    for f in data.glob(f"{key}.*"):
+        if f.suffix in (".json", ".jsonl"):
+            shutil.copy(f, work)
+    fm.datasheet(tmp_path, work, key)  # the committed card is what the generator writes from the sidecars
+    assert (work / f"{key}.md").read_text(encoding="utf-8") == (data / f"{key}.md").read_text(encoding="utf-8")
+    return stats, ev

src/test_wikinews_contract.py

@@ -0,0 +1,12 @@
+"""Contract checks for the released wikinews source (Polish Wikinews, CC BY 2.5 until 2024-12-16 and CC BY 4.0 after); the shared checks live in test_wikimedia_contract.py."""
+
+from test_wikimedia_contract import check_released
+
+
+def test_wikinews_contract(tmp_path):
+    stats, ev = check_released("wikinews", tmp_path)
+    assert (stats["kept"], stats["tokens"]) == (24386, 12141355)
+    assert stats["licenses"] == {"CC-BY-2.5": 17581, "CC-BY-4.0": 6805}
+    assert ev["release_scope"]["tokens"] == {"CC-BY-2.5": 8956397, "CC-BY-4.0": 3184958}
+    assert ev["cutoff"]["boundary_day"] == {"day": "2024-12-16", "docs_last_edited_that_day": 6, "known_switch_time_utc": "2024-12-16 08:32:24", "of_which_before_that_time": 2}
+    assert ev["release_scope"]["last_edited_before_era_end"] == {"date": "2005-09-25", "docs": 0, "tokens": 0}