wikipedia: record links and a citations table (v2#110)

data/wikipedia/citations/wikipedia.citations.parquet

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

data/wikipedia/wikipedia.attribution.jsonl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:aac58a47f87d548e0a42477e41a686a18705b86b95b25f2ce45d89d27bf38d09
-size 455694527
+oid sha256:9929e5eccc2cdaa60b804bd9f6d0771a6c3518dfe4681101e29ecf163fe6464e
+size 977918698

data/wikipedia/wikipedia.build.json

@@ -1,7 +1,53 @@
 {
   "attribution_rows": 1468647,
-  "attribution_sha256": "aac58a47f87d548e0a42477e41a686a18705b86b95b25f2ce45d89d27bf38d09",
+  "attribution_sha256": "9929e5eccc2cdaa60b804bd9f6d0771a6c3518dfe4681101e29ecf163fe6464e",
   "by_sa_4_cutoff": "2023-06-07T00:00:00+00:00",
+  "citations": {
+    "citations": 7476723,
+    "dumpstatus_url": "https://dumps.wikimedia.org/plwiki/20260901/dumpstatus.json",
+    "file": "citations/wikipedia.citations.parquet",
+    "issue": "slayerlabs/polish-dynaword-v2#110",
+    "rows": 1468647,
+    "rows_with_citations": 1165616,
+    "sha256": "c667e5df36ab36eb7b812daa6f792c541d2023799b50157c6e3b9fc0d47e3fd3",
+    "shards": [
+      {
+        "name": "plwiki-20260901-pages-meta-current1.xml-p1p187037.bz2",
+        "sha1": "2ba8aaceac41ab61745b254be74f5b178a950753",
+        "size": 250876720
+      },
+      {
+        "name": "plwiki-20260901-pages-meta-current2.xml-p187038p564779.bz2",
+        "sha1": "29e56cb64d15138257c071d6aaca72b70fe6345c",
+        "size": 251907424
+      },
+      {
+        "name": "plwiki-20260901-pages-meta-current3.xml-p564780p1199518.bz2",
+        "sha1": "73eb6a68a39bcd63793a136174b479aad251691f",
+        "size": 368007181
+      },
+      {
+        "name": "plwiki-20260901-pages-meta-current4.xml-p1199519p2047892.bz2",
+        "sha1": "87ef59a7603a6269ec9223283a131c173cd3ab12",
+        "size": 498502596
+      },
+      {
+        "name": "plwiki-20260901-pages-meta-current5.xml-p2047893p3462393.bz2",
+        "sha1": "7d4685c6a85878490b0c70cf4dfcf5c8e5190368",
+        "size": 739442045
+      },
+      {
+        "name": "plwiki-20260901-pages-meta-current6.xml-p3462394p4962393.bz2",
+        "sha1": "d0dcce1c3222bb7747b4ea4e167611e5f4e791d4",
+        "size": 700902977
+      },
+      {
+        "name": "plwiki-20260901-pages-meta-current6.xml-p4962394p6142332.bz2",
+        "sha1": "f775b611e6bdb8a0ecbc5f9896b1b52685d1f5b6",
+        "size": 690784561
+      }
+    ]
+  },
   "copyvio_tagged": [
     {
       "pageid": "3581",

data/wikipedia/wikipedia.md

@@ -100,6 +100,11 @@ to the sample's dropped rows. Of the other 97, 88 were deleted after a deletion
 7 as duplicates, needless disambiguations, advertising, spam or nonsense, and 2 were deleted
 for a history merge or a move and restored. They are kept: a quality call, not a rights one.
 
+Text quoted from other works is not under these licences. It is used under the quotation right
+(Art. 29 of the Polish copyright act), which holds while a quotation stays in its context with its
+author and source named. Each page is released as one record, not cut into quotations, and the
+footnotes and citation templates that name the sources are kept in `citations`.
+
 Evidence: `wikipedia.license-evidence.json`.
 
 ## Attribution
@@ -111,6 +116,17 @@ in the dump), `title`, `url`, `last_revision_at`, `license`,
 `license_basis` (how the label was decided, see Licensing) and `pre_cutoff_revid` (the page's last revision
 before the cutoff, null for a page created after it or edited after it and since deleted; its text is at `https://pl.wikipedia.org/w/index.php?oldid=<pre_cutoff_revid>`). The row `id` is
 `wikipedia_<page id>` and `created` is the date of `last_revision_at`.
+Each line also gives `permalink` (`https://pl.wikipedia.org/w/index.php?oldid=<revid>`, the shipped revision),
+`history_url` (`https://pl.wikipedia.org/w/index.php?curid=<pageid>&action=history`, the page history, which names
+the contributors), `license_urls` (the deed of each licence in `license`) and `conversion` (how the text was made
+from the wikitext, in one line). Neither link opens for a page deleted since.
+The source citations are in `citations/wikipedia.citations.parquet`, a table of `id` and `citations` with the release's
+rows in the same order and row groups. `citations` lists the page's source citations as wikitext: the non-empty `<ref>` bodies, then the
+`Cytuj...`/`Cite...` templates outside them (1,165,616 rows have any). Each list is in page order, without repeats, and empty for a page
+with none: 7,476,723 citations in all. They are read from the 7 pages-meta-current shards of the same 20260901 dump (names,
+sizes and sha1 in `wikipedia.build.json` `citations`, each matched against `dumpstatus.json`), whose revision of
+every row is the shipped `revid` with its `last_revision_at`. The table is in a folder of its own so that the
+`data/*/*.parquet` file pattern (the README's dataset config, the scripts in `src`) does not read it as documents.
 
 The text is modified: wiki markup is converted to plain text (see Provenance).
 
@@ -125,7 +141,7 @@ Articles (namespace 0) only. Redirects, empty pages and pages with a copyright-v
 notice are skipped; pages listed in `COPIED_PAGES` or with a copyright `{{ek}}` reason are
 dropped after the duplicate check, so a copy of their text on another page goes with them. Wikitext is converted with mwparserfromhell
 `strip_code(normalize=True, collapse=True)`, as in the sibling Wikimedia builders, after
-removing `<ref>` bodies, file and category links and behaviour switches (`__NOTOC__`).
+removing `<ref>` bodies (kept in the citations table, see Attribution), file and category links and behaviour switches (`__NOTOC__`).
 Templates (infoboxes, navigation boxes), `<math>`, galleries and comments are dropped;
 table cells stay as flattened text; section headings stay as their own line. Of two
 pages with the same text (sha1 of the stripped text), the lower page id is kept.
@@ -186,7 +202,7 @@ Llama-3 count is computed at release.
   requirements (Terms of Use, Re-use); notices kept in templates are removed by the conversion
 - 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)
+- whether each quotation inside articles stays within Art. 29 (see Licensing)
 - deletion discussions and maintenance notices other than `{{NPA}}` and `{{ek}}`; their
   reasons are not read, except the deletion logs above
 - pages deleted from plwiki after the stub dump (2026-10-01), and other pages by the authors
@@ -194,4 +210,4 @@ Llama-3 count is computed at release.
 - "Teatr Piosenki Młyn" (`wikipedia_4033410`), deleted for copyright on 2017-05-23 and recreated
   by 2017-07-14: the released text was not compared with the deleted one (it is among the
   88 deleted after a discussion in 2026)
-- personal data (the NERGAL scrub runs before release)
+- personal data, in the text and in the citations (the NERGAL scrub runs before release)

src/fetch_wikimedia.py

@@ -223,7 +223,8 @@ def withheld_template(key: str, wikitext: str) -> str | None:
 # The templates kept as a page's `source_notes` (v2#110, 3B): where its text came from. Wikinews: the
 # imports (IMPORT_TEMPLATES); Wikibooks: the licence templates, not {{Licencja}}, which holds the author's
 # e-mail; Wikivoyage's ({{Atrybucja}}, {{Import}}) are on withheld pages only; the talk pages keep citations only
-# (clean_plwiki_talk.py provenance).
+# (clean_plwiki_talk.py provenance). Wikipedia has no entry: no shipped article carries such a template, and its
+# citations ship in a file of their own (fetch_wikipedia.py citations).
 SOURCE_NOTE_TEMPLATES = {
     "wikinews": frozenset(IMPORT_TEMPLATES["wikinews"]),
     "wikibooks": frozenset({"Cc-by-sa-3.0-tekst", "Cc-by-3.0-tekst", "GFDL-1.3-Cc-by-sa-3.0-tekst", "PD-tekst",
@@ -242,7 +243,7 @@ def page_sources(key: str, wikitext: str) -> tuple[list[str], list[str]]:
     outside a <ref>; source_notes: the SOURCE_NOTE_TEMPLATES[key] templates, wherever they are."""
     import mwparserfromhell
     code = mwparserfromhell.parse(wikitext)
-    notes = [str(t) for t in code.filter_templates(recursive=True) if template_name(t) in SOURCE_NOTE_TEMPLATES[key]]
+    notes = [str(t) for t in code.filter_templates(recursive=True) if template_name(t) in SOURCE_NOTE_TEMPLATES.get(key, ())]
     refs = [t for t in code.filter_tags(recursive=True) if str(t.tag).strip().lower() == "ref"]
     cites = [body for t in refs if (body := str(t.contents or "").strip())]
     for ref in refs:
@@ -871,10 +872,16 @@ QUOTATIONS = ("Text quoted from other works is not under these licences. It is u
               "footnotes and citation templates that name the sources are kept in `citations`.")
 
 
+def citations_sentence(key: str, n_cites: int) -> str:
+    """The cards' account of what page_sources puts in `citations`; n_cites rows have any."""
+    cites = sorted(CITATION_TEMPLATES.get(key, ()))
+    return (f"`citations` lists the page's source citations as wikitext: the non-empty `<ref>` bodies, then the\n"
+            f"`Cytuj...`/`Cite...` templates{''.join(f', `{{{{{name}}}}}`' for name in cites)} outside them ({n_cites:,} rows have any).")
+
+
 def sources_text(key: str, side: list[dict]) -> str:
     """The cards' account of the sidecar's `citations` and `source_notes` (page_sources, v2#110 3B)."""
-    cites = sorted(CITATION_TEMPLATES.get(key, ()))
-    shown = SOURCE_NOTE_TEMPLATES[key] - set(WITHHELD_TEMPLATES.get(key, ()))  # a withheld page is in no row
+    shown =SOURCE_NOTE_TEMPLATES[key] - set(WITHHELD_TEMPLATES.get(key, ()))  # a withheld page is in no row
     notes = ", ".join(f"`{{{{{name}}}}}`" for name in sorted(shown))
     n_cites, n_notes = (sum(bool(rec[f]) for rec in side) for f in ("citations", "source_notes"))
     if notes:
@@ -886,9 +893,7 @@ def sources_text(key: str, side: list[dict]) -> str:
                  + ", which say where text came from, are withheld (see Provenance).")
     else:  # the talk pages (clean_plwiki_talk.py provenance keeps citations only)
         notes = "`source_notes` is an empty list on every row: notes on where text\ncame from are read on content pages only."
-    return (f"`citations` lists the page's source citations as wikitext: the non-empty `<ref>` bodies, then the\n"
-            f"`Cytuj...`/`Cite...` templates{''.join(f', `{{{{{name}}}}}`' for name in cites)} outside them ({n_cites:,} rows have any). "
-            + notes + " Each list is in page order, without repeats.")
+    return citations_sentence(key, n_cites) + " " + notes + " Each list is in page order, without repeats."
 
 
 def datasheet(out: Path, data_dir: Path, key: str) -> None:

src/fetch_wikipedia.py

@@ -25,6 +25,10 @@ labels on the committed release; the pages-articles dump is not re-read. H=<hist
         --history $H/wikipedia.history.jsonl --fetched $H/wikipedia --parquet data/wikipedia/wikipedia.parquet \\
         --out $H/wikipedia.labels.jsonl
     python3 src/fetch_wikipedia.py relabel --out $H  # data/wikipedia; the card is edited by hand
+
+Each row's source citations (v2#110, option A) are read from the same dump's pages-meta-current shards, which hold
+the shipped revision of every page. M=<their dir, never committed>
+    python3 src/fetch_wikipedia.py citations --out $M  # data/wikipedia/citations; build.json `citations`
 """
 from __future__ import annotations
 
@@ -54,6 +58,7 @@ DUMP_BASE = f"https://dumps.wikimedia.org/plwiki/{DUMP_DATE}"
 DUMPSTATUS_URL = f"{DUMP_BASE}/dumpstatus.json"
 SHA1SUMS_URL = f"{DUMP_BASE}/plwiki-{DUMP_DATE}-sha1sums.txt"
 SHARD_RE = re.compile(r"plwiki-\d{8}-pages-articles\d+\.xml-p\d+p\d+\.bz2")
+META_CURRENT_RE = re.compile(r"plwiki-\d{8}-pages-meta-current\d+\.xml-p\d+p\d+\.bz2")
 RIGHTSINFO_URL = ("https://pl.wikipedia.org/w/api.php?action=query&meta=siteinfo"
                   "&siprop=rightsinfo&format=json")
 # WMF Terms of Use, revision in force from 2023-06-07 (sections 7(b)/7(c); history note).
@@ -176,15 +181,19 @@ def text_key(text: str) -> bytes:
     return hashlib.sha1(text.strip().encode("utf-8")).digest()
 
 
+def by_first_page(files: list[dict]) -> list[dict]:
+    """Dump shards in page-id order (the first page id in each name)."""
+    return sorted(files, key=lambda f: int(re.search(r"-p(\d+)p", f["name"]).group(1)))
+
+
 def discover(out: Path) -> None:
     status = request_json(DUMPSTATUS_URL)
     sums = {name: sha for sha, name in (line.split() for line in request(SHA1SUMS_URL).text.splitlines() if line.strip())}
     job = status["jobs"]["articlesdump"]
     if job.get("status") != "done":
         raise ValueError(f"articlesdump not done: {job.get('status')}")
-    files = sorted(({"name": name, "url": f"{DUMP_BASE}/{name}", "size": meta["size"], "sha1": meta["sha1"]}
-                    for name, meta in job["files"].items() if SHARD_RE.fullmatch(name)),
-                   key=lambda f: int(re.search(r"-p(\d+)p", f["name"]).group(1)))
+    files = by_first_page([{"name": name, "url": f"{DUMP_BASE}/{name}", "size": meta["size"], "sha1": meta["sha1"]}
+                           for name, meta in job["files"].items() if SHARD_RE.fullmatch(name)])
     if not files:
         raise ValueError("no pages-articles shards")
     for f in files:
@@ -402,8 +411,8 @@ def withhold(data_dir: Path) -> None:
         print(f"{SOURCE}: nothing to withhold")
         return
     build = load(path("build.json"))
-    if "licence_labels" in build:  # ponytail: relabel's case counts would keep the withheld rows
-        raise ValueError(f"{SOURCE}: withhold before relabel, then filter the labels to the sidecar")
+    if "licence_labels" in build or "citations" in build:  # ponytail: relabel's counts and the citations would keep them
+        raise ValueError(f"{SOURCE}: withhold before relabel and citations, then filter their output to the sidecar")
     held_ids = {rec["id"] for rec in held}
     table = pq.read_table(path("parquet"))
     table = table.filter(pc.invert(pc.is_in(table["id"], pa.array(sorted(held_ids)))))
@@ -453,9 +462,95 @@ def relabel(out: Path, data_dir: Path) -> None:
     print(f"{SOURCE}: relabelled, {docs}")
 
 
+def _shard_citations(job: tuple[Path, str, frozenset[str]]) -> dict[str, tuple[str, str, list[str]]]:
+    """citations' work on one pages-meta-current shard: {pageid: (revid, timestamp, citations)} of the pages in `wanted`."""
+    from fetch_wikimedia import page_sources  # not at the top: fetch_wikimedia imports this module
+    path, sha1, wanted = job
+    if sha1_file(path) != sha1:
+        raise ValueError(f"sha1 mismatch: {path.name}")
+    found = {}
+    with bz2.open(path, "rb") as fh:
+        for pageid, revid, _, _, timestamp, _, wikitext in pages(fh):
+            if pageid not in wanted:
+                continue
+            if pageid in found:
+                raise ValueError(f"page {pageid} twice in {path.name}")
+            found[pageid] = (revid, timestamp, page_sources(SOURCE, wikitext)[0])
+    return found
+
+
+def citations(dumps: Path, data_dir: Path, status: dict, workers: int) -> None:
+    """citations/wikipedia.citations.parquet: `id` and `citations` (fetch_wikimedia.page_sources: the non-empty <ref>
+    bodies, then the Cytuj*/Cite* templates outside them, as wikitext) of every row, in the release's order, read from
+    the pages-meta-current shards in `dumps` that `status` (the dump's dumpstatus.json) lists, sha1-checked. A page
+    missing from them, or there at another revision or timestamp than the sidecar's, stops it. In a folder: the
+    release's `data/*/*.parquet` glob would read a parquet next to wikipedia.parquet as text rows. build.json
+    `citations` records the shards, counts and sha256; rerunning changes nothing."""
+    import pyarrow as pa
+    import pyarrow.parquet as pq
+    with (data_dir / f"{SOURCE}.attribution.jsonl").open(encoding="utf-8") as fh:  # in page id order
+        meta = {rec["id"]: (str(rec["pageid"]), str(rec["revid"]), rec["last_revision_at"]) for rec in map(json.loads, fh)}
+    release = data_dir / f"{SOURCE}.parquet"
+    ids = pq.read_table(release, columns=["id"])["id"].to_pylist()
+    if len(ids) != len(meta) or meta.keys() != set(ids):
+        raise ValueError("the sidecar's ids are not the parquet's")
+    side = [(row_id, *meta[row_id]) for row_id in ids]
+    shards = by_first_page([{"name": name, "size": f["size"], "sha1": f["sha1"]}
+                            for name, f in status["jobs"]["metacurrentdump"]["files"].items()
+                            if META_CURRENT_RE.fullmatch(name)])
+    if not shards:
+        raise ValueError("no pages-meta-current shards in dumpstatus.json")
+    wanted, found = frozenset(pageid for _, pageid, _, _ in side), {}
+    with ProcessPoolExecutor(max_workers=workers) as pool:
+        for part in pool.map(_shard_citations, [(dumps / f["name"], f["sha1"], wanted) for f in shards]):
+            if twice := found.keys() & part.keys():
+                raise ValueError(f"pages in two shards: {sorted(twice)[:5]}")
+            found.update(part)
+    bad = []
+    for row_id, pageid, revid, at in side:
+        if pageid not in found:
+            bad.append(f"{row_id}: not in the dump")
+        elif found[pageid][:2] != (revid, at):
+            bad.append(f"{row_id}: the dump has revision {found[pageid][0]} at {found[pageid][1]}")
+    if bad:
+        raise ValueError(f"{len(bad)} rows do not match the dump: {bad[:5]}")
+    path = data_dir / "citations" / f"{SOURCE}.citations.parquet"
+    path.parent.mkdir(exist_ok=True)
+    schema = pa.schema([("id", pa.string()), ("citations", pa.list_(pa.string()))])
+    group = pq.ParquetFile(release).metadata.row_group(0).num_rows  # the release's row groups, so row n is row n in both
+    with pq.ParquetWriter(path, schema, compression="zstd") as writer:
+        for start in range(0, len(side), group):  # a group at a time: one string array caps at 2 GiB
+            rows = side[start:start + group]
+            writer.write_table(pa.table([[r[0] for r in rows], [found[r[1]][2] for r in rows]], schema=schema),
+                               row_group_size=group)
+    cites = [found[pageid][2] for _, pageid, _, _ in side]
+    build = load(data_dir / f"{SOURCE}.build.json")
+    build["citations"] = {
+        "issue": "slayerlabs/polish-dynaword-v2#110", "file": path.relative_to(data_dir).as_posix(),
+        "dumpstatus_url": DUMPSTATUS_URL, "shards": shards, "rows": len(cites),
+        "rows_with_citations": sum(map(bool, cites)), "citations": sum(map(len, cites)), "sha256": digest(path.read_bytes()),
+    }
+    save(data_dir / f"{SOURCE}.build.json", build)
+    print(f"{SOURCE}: {build['citations']['rows_with_citations']} rows with {build['citations']['citations']} citations")
+
+
+def citations_text(build: dict) -> str:
+    """The card's account of the citations table (build.json `citations`); the card is edited by hand around it."""
+    from fetch_wikimedia import citations_sentence  # not at the top: fetch_wikimedia imports this module
+    c = build["citations"]
+    return (f"The source citations are in `{c['file']}`, a table of `id` and `citations` with the release's\n"
+            f"rows in the same order and row groups. " + citations_sentence(SOURCE, c["rows_with_citations"])
+            + f" Each list is in page order, without repeats, and empty for a page\nwith none: {c['citations']:,} citations in all. "
+            f"They are read from the {len(c['shards'])} pages-meta-current shards of the same {DUMP_DATE} dump (names,\n"
+            f"sizes and sha1 in `{SOURCE}.build.json` `citations`, each matched against `dumpstatus.json`), whose revision of\n"
+            f"every row is the shipped `revid` with its `last_revision_at`. The table is in a folder of its own so that the\n"
+            f"`data/*/*.parquet` file pattern (the README's dataset config, the scripts in `src`) does not read it as documents.")
+
+
 def main() -> None:
     ap = argparse.ArgumentParser()
-    ap.add_argument("step", choices=["discover", "acquire", "extract", "prepare", "attribution", "withhold", "relabel"])
+    ap.add_argument("step", choices=["discover", "acquire", "extract", "prepare", "attribution", "withhold", "relabel",
+                                     "citations"])
     ap.add_argument("--out", required=True, type=Path)
     ap.add_argument("--data-dir", type=Path, default=Path(__file__).resolve().parent.parent / "data" / SOURCE)
     ap.add_argument("--workers", type=int, default=8)
@@ -464,7 +559,8 @@ def main() -> None:
     {"discover": lambda: discover(a.out), "acquire": lambda: acquire(a.out),
      "extract": lambda: extract(a.out, a.workers), "prepare": lambda: prepare(a.out),
      "attribution": lambda: attribution(a.out, a.data_dir), "withhold": lambda: withhold(a.data_dir),
-     "relabel": lambda: relabel(a.out, a.data_dir)}[a.step]()
+     "relabel": lambda: relabel(a.out, a.data_dir),
+     "citations": lambda: citations(a.out, a.data_dir, request_json(DUMPSTATUS_URL), a.workers)}[a.step]()
 
 
 if __name__ == "__main__":

src/takedown.py

@@ -9,11 +9,12 @@ when a row is added; takedown/register.md records every one.
   python3 src/takedown.py row data/<k>/<k>.parquet <id> [<id> ...]   # rows to append to the blocklist
   python3 src/takedown.py apply [data/<k>/<k>.parquet ...]           # default: every shard under data/
 
-`apply` drops blocked rows from each shard and from the <k>.*.jsonl files next
-to it, subtracts them from <k>.stats.json and refreshes <k>.checksums.json for
-the files it rewrote. build_dynaword.py runs it on every shard it builds. A
-shard from any other builder needs an `apply` before it is committed, and
-test_takedown.py fails until it has had one.
+`apply` drops blocked rows from each shard, from the <k>.*.jsonl files next
+to it and from the <k>.*.parquet tables in a folder next to it (such as
+citations/<k>.citations.parquet), subtracts them from <k>.stats.json and
+refreshes <k>.checksums.json for the files it rewrote. build_dynaword.py runs
+it on every shard it builds. A shard from any other builder needs an `apply`
+before it is committed, and test_takedown.py fails until it has had one.
 """
 from __future__ import annotations
 
@@ -182,14 +183,15 @@ def _refresh_checksums(sums: dict, rewritten: set[Path]) -> None:
 
 
 def apply(paths: list[Path], bl: Blocklist | None = None) -> dict[Path, int]:
-    """Drop blocked records from each shard and its sidecar files; return rows dropped per shard.
+    """Drop blocked records from each shard, its sidecar files and its tables; return rows dropped per shard.
 
     scan() starts worker processes, which on macOS re-run the calling script's top level:
     call this from under `if __name__ == "__main__":`.
     """
     bl = load() if bl is None else bl
     sidecars = {p: sorted(p.parent.glob(f"{p.stem}.*.jsonl")) for p in paths}
-    pointers = [f for p in paths for f in [p, *sidecars[p]] if is_lfs_pointer(f)]
+    tables = {p: sorted(p.parent.glob(f"*/{p.stem}.*.parquet")) for p in paths}  # e.g. citations/<k>.citations.parquet
+    pointers = [f for p in paths for f in [p, *sidecars[p], *tables[p]] if is_lfs_pointer(f)]
     if pointers:
         raise RuntimeError(f"LFS pointers, run `git lfs pull` first: {[str(f) for f in pointers]}")
     found = scan(paths, bl)
@@ -206,13 +208,18 @@ def apply(paths: list[Path], bl: Blocklist | None = None) -> dict[Path, int]:
                 elif how == "text":
                     print(f"  ! {source}/{rec_id}: text matches a blocklisted record filed under another id or source. "
                           f"Blocklist row for it:\n{source}\t{rec_id}\t{key}")
-        # Attribution and decision lines carry no text: drop the ids just cut from the shard as well.
+        # Attribution and decision lines and the tables carry no text: drop the ids just cut from the shard as well.
         side_bl = bl if gone is None else Blocklist(bl.ids | {(source, i) for i in gone["id"].to_pylist()}, bl.hashes)
         samples = 0
         for f in sidecars[path]:
             if n := _drop_lines(f, side_bl):
                 rewritten.add(f)
                 samples += n if f.name == f"{source}.sample.jsonl" else 0
+        for f in tables[path]:
+            ids = pq.read_table(f, columns=["id"])["id"].to_pylist()
+            if drop := {n for n, rec_id in enumerate(ids) if (source, rec_id) in side_bl.ids}:
+                _drop_rows(f, drop)
+                rewritten.add(f)
         stats = path.with_name(f"{source}.stats.json")
         if (gone is not None or samples) and stats.exists():
             gone = gone if gone is not None else pq.read_schema(path).empty_table()

src/test_takedown.py

@@ -38,6 +38,20 @@ def test_no_file_next_to_a_shard_holds_a_blocklisted_record():
     assert hits == {}
 
 
+def test_no_table_next_to_a_shard_holds_a_record_the_shard_lacks():
+    """data/<k>/*/<k>.*.parquet (citations/wikipedia.citations.parquet) holds only ids its shard has, none blocklisted."""
+    bl, hits = takedown.load(), {}
+    for f in sorted(DATA.glob("*/*/*.parquet")):
+        shard = f.parent.parent / f"{f.name.split('.')[0]}.parquet"
+        if takedown.is_lfs_pointer(f) or takedown.is_lfs_pointer(shard):
+            continue
+        kept = set(pq.read_table(shard, columns=["id"])["id"].to_pylist())
+        ids = pq.read_table(f, columns=["id"])["id"].to_pylist()
+        if bad := [i for i in ids if (shard.stem, i) in bl.ids or i not in kept]:
+            hits[str(f.relative_to(ROOT))] = bad[:5]
+    assert hits == {}
+
+
 def _register_rows() -> list[list[str]]:
     lines = REGISTER.read_text(encoding="utf-8").splitlines()
     start = lines.index("| date | source | record id | reason class | action |") + 2
@@ -97,7 +111,7 @@ def _texts():
 
 
 def _source(tmp_path):
-    """data/demo with four records, the sidecar files a source ships, and their checksums."""
+    """data/demo with four records, the sidecar files a source ships, a table in a folder, and their checksums."""
     d = tmp_path / "data" / "demo"
     d.mkdir(parents=True)
     texts = _texts()
@@ -114,15 +128,22 @@ def _source(tmp_path):
         encoding="utf-8")
     (d / "demo.attribution.jsonl").write_text("".join(json.dumps({"id": i, "url": f"https://x/{i}"}) + "\n" for i in ids))
     (d / "demo.md").write_text("# demo\n")
+    (d / "citations").mkdir()
+    pq.write_table(pa.table({"id": ids, "citations": [[f"Źródło {n}"] for n in range(4)]}),
+                   d / "citations" / "demo.citations.parquet")
     (d / "demo.stats.json").write_text(json.dumps({
         "kept": 4, "tokens": 100, "chars": sum(map(len, texts)), "authors_with_value": 2,
         "licenses": {"CC0": 3, "CC-BY-4.0": 1}, "sample_count": 2, "by_year": {"2020": 4},
     }, indent=2))
-    sums = {f.name: hashlib.sha256(f.read_bytes()).hexdigest() for f in sorted(d.iterdir())}
+    sums = {f.name: hashlib.sha256(f.read_bytes()).hexdigest() for f in sorted(d.iterdir()) if f.is_file()}
     (d / "demo.checksums.json").write_text(json.dumps(sums, indent=2) + "\n")
     return d
 
 
+def _files(d):
+    return {f.relative_to(d).as_posix(): f.read_bytes() for f in sorted(d.rglob("*")) if f.is_file()}
+
+
 def _blocklist():
     texts = _texts()
     return Blocklist(
@@ -140,6 +161,9 @@ def test_apply_drops_blocked_records_from_the_shard_and_every_sidecar(tmp_path,
     assert pq.read_table(shard)["id"].to_pylist() == ["demo_1"]
     assert [json.loads(ln)["id"] for ln in (d / "demo.sample.jsonl").read_text().splitlines()] == ["demo_1"]
     assert [json.loads(ln)["id"] for ln in (d / "demo.attribution.jsonl").read_text().splitlines()] == ["demo_1"]
+    # demo_2 is caught by its text, which the table does not carry: it goes by the id the shard dropped
+    assert pq.read_table(d / "citations" / "demo.citations.parquet").to_pydict() == {
+        "id": ["demo_1"], "citations": [["Źródło 1"]]}
     stats_raw = (d / "demo.stats.json").read_text()
     assert not stats_raw.endswith("\n")  # layout kept
     assert json.loads(stats_raw) == {
@@ -157,21 +181,22 @@ def test_apply_drops_blocked_records_from_the_shard_and_every_sidecar(tmp_path,
 def test_apply_is_a_no_op_once_applied(tmp_path):
     d = _source(tmp_path)
     takedown.apply([d / "demo.parquet"], _blocklist())
-    before = {f.name: f.read_bytes() for f in d.iterdir()}
+    before = _files(d)
     assert takedown.apply([d / "demo.parquet"], _blocklist()) == {d / "demo.parquet": 0}
-    assert {f.name: f.read_bytes() for f in d.iterdir()} == before
+    assert _files(d) == before
 
 
 def test_apply_leaves_a_clean_source_byte_for_byte(tmp_path):
     d = _source(tmp_path)
-    before = {f.name: f.read_bytes() for f in d.iterdir()}
+    before = _files(d)
     takedown.apply([d / "demo.parquet"], Blocklist(frozenset({("other", "x")}), frozenset({"0" * 64})))
-    assert {f.name: f.read_bytes() for f in d.iterdir()} == before
+    assert _files(d) == before
 
 
-def test_apply_refuses_lfs_pointers(tmp_path):
+@pytest.mark.parametrize("name", ["demo.attribution.jsonl", "citations/demo.citations.parquet"])
+def test_apply_refuses_lfs_pointers(tmp_path, name):
     d = _source(tmp_path)
-    (d / "demo.attribution.jsonl").write_text("version https://git-lfs.github.com/spec/v1\noid sha256:00\nsize 1\n")
+    (d / name).write_text("version https://git-lfs.github.com/spec/v1\noid sha256:00\nsize 1\n")
     with pytest.raises(RuntimeError, match="git lfs pull"):
         takedown.apply([d / "demo.parquet"], _blocklist())
 

src/test_wikipedia_contract.py

@@ -8,8 +8,10 @@ from pathlib import Path
 import re
 import shutil
 import subprocess
+from xml.sax.saxutils import escape
 
 import pyarrow as pa
+import pyarrow.compute as pc
 import pyarrow.parquet as pq
 import pytest
 
@@ -247,9 +249,90 @@ def test_withhold_drops_pages_added_after_the_build(tmp_path, monkeypatch):
     assert {p.name: p.read_bytes() for p in tmp_path.iterdir()} == before
 
     monkeypatch.setattr(fw, "COPIED_PAGES", {10: "Ala: deleted"})
-    fw.save(tmp_path / "wikipedia.build.json", {**build, "licence_labels": {}})
-    with pytest.raises(ValueError, match="before relabel"):
-        fw.withhold(tmp_path)
+    for step in ("licence_labels", "citations"):
+        fw.save(tmp_path / "wikipedia.build.json", {**build, step: {}})
+        with pytest.raises(ValueError, match="before relabel and citations"):
+            fw.withhold(tmp_path)
+
+
+S1 = "plwiki-20260901-pages-meta-current1.xml-p1p15.bz2"
+S2 = "plwiki-20260901-pages-meta-current2.xml-p16p30.bz2"
+CITED = ("Ala ma kota<ref>Jan K., ''Koty'', 2001.</ref> i psa<ref name=\"x\" /><ref name=\"p\">{{Cytuj książkę|tytuł=Psy}}"
+         "</ref> oraz {{Cytuj stronę|url=http://x.pl|tytuł=X}}<ref>Jan K., ''Koty'', 2001.</ref>.")
+SHARDS = {S1: [(10, "Ala", 0, "2023-06-07T00:00:00Z", CITED), (12, "Kot", 0, "2020-01-01T00:00:00Z", "Bez przypisów."),
+               (13, "Dyskusja:Kot", 1, "2020-01-01T00:00:00Z", "Tak<ref>x</ref>")],
+          S2: [(16, "Pies", 0, "2021-01-01T00:00:00Z", "Pies<ref>Psy, 1999.</ref>")]}
+SIDE = [(16, 1600, "2021-01-01T00:00:00Z"), (10, 1000, "2023-06-07T00:00:00Z"), (12, 1200, "2020-01-01T00:00:00Z")]
+
+
+def _citations_inputs(tmp_path, shards=SHARDS, side=SIDE, release=None, bad_sha1=None):
+    """fw.citations' inputs: shards in tmp/dumps; a data dir whose release has `side`'s rows in its order, in row groups
+    of 2, and whose sidecar has them in page id order; a dumpstatus.json that lists the shards last first, next to the
+    combined file."""
+    dumps, data = tmp_path / "dumps", tmp_path / "data"
+    dumps.mkdir()
+    data.mkdir()
+    files = {"plwiki-20260901-pages-meta-current.xml.bz2": {"size": 1, "sha1": "0" * 40}}
+    for name, rows in shards.items():
+        (dumps / name).write_bytes(bz2.compress((
+            '<mediawiki xmlns="http://www.mediawiki.org/xml/export-0.11/">'
+            + "".join(_page(pageid, title, ns, at, escape(text)) for pageid, title, ns, at, text in rows)
+            + "</mediawiki>").encode()))
+        files[name] = {"size": (dumps / name).stat().st_size,
+                       "sha1": "0" * 40 if name == bad_sha1 else fw.sha1_file(dumps / name)}
+    ids = [f"wikipedia_{pageid}" for pageid, _, _ in side]
+    pq.write_table(pa.table({"id": release or ids}), data / "wikipedia.parquet", row_group_size=2)
+    (data / "wikipedia.attribution.jsonl").write_text("".join(
+        json.dumps({"id": f"wikipedia_{pageid}", "pageid": pageid, "revid": revid, "last_revision_at": at}) + "\n"
+        for pageid, revid, at in sorted(side)))
+    fw.save(data / "wikipedia.build.json", {"attribution_rows": len(side)})
+    return dumps, data, {"jobs": {"metacurrentdump": {"files": dict(reversed(files.items()))}}}
+
+
+def test_citations_reads_each_rows_revision_from_the_dump(tmp_path):
+    dumps, data, status = _citations_inputs(tmp_path)
+    fw.citations(dumps, data, status, workers=2)
+    path = data / "citations" / "wikipedia.citations.parquet"
+    table = pq.read_table(path)
+    assert table.schema == pa.schema([("id", pa.string()), ("citations", pa.list_(pa.string()))])
+    # the release's order, not the sidecar's; a ref named but empty is not a citation, and a repeated one counts once
+    assert table.to_pydict() == {"id": ["wikipedia_16", "wikipedia_10", "wikipedia_12"], "citations": [
+        ["Psy, 1999."],
+        ["Jan K., ''Koty'', 2001.", "{{Cytuj książkę|tytuł=Psy}}", "{{Cytuj stronę|url=http://x.pl|tytuł=X}}"],
+        []]}
+    meta = pq.ParquetFile(path).metadata
+    assert [meta.row_group(i).num_rows for i in range(meta.num_row_groups)] == [2, 1]  # the release's row groups
+    shards = status["jobs"]["metacurrentdump"]["files"]
+    assert fw.load(data / "wikipedia.build.json") == {"attribution_rows": 3, "citations": {
+        "issue": "slayerlabs/polish-dynaword-v2#110", "file": "citations/wikipedia.citations.parquet",
+        "dumpstatus_url": fw.DUMPSTATUS_URL, "shards": [{"name": S1, **shards[S1]}, {"name": S2, **shards[S2]}],
+        "rows": 3, "rows_with_citations": 2, "citations": 4, "sha256": fm.digest(path.read_bytes())}}
+    text = fw.citations_text(fw.load(data / "wikipedia.build.json"))
+    assert "`citations/wikipedia.citations.parquet`" in text
+    assert "the 2 pages-meta-current shards of the same 20260901 dump" in text
+    assert "(2 rows have any)" in text and "4 citations in all" in text
+
+    before = {p: p.read_bytes() for p in data.rglob("*") if p.is_file()}
+    fw.citations(dumps, data, status, workers=2)  # rerun: nothing changes
+    assert {p: p.read_bytes() for p in data.rglob("*") if p.is_file()} == before
+
+
+@pytest.mark.parametrize("change, error", [
+    ({"side": [(16, 1601, "2021-01-01T00:00:00Z")] + SIDE[1:]}, r"wikipedia_16: the dump has revision 1600 at 2021-"),
+    ({"side": [(16, 1600, "2021-01-01T00:00:01Z")] + SIDE[1:]}, r"wikipedia_16: the dump has revision 1600 at 2021-"),
+    ({"side": SIDE + [(99, 9900, "2020-01-01T00:00:00Z")]}, r"wikipedia_99: not in the dump"),
+    ({"shards": {S1: SHARDS[S1], S2: SHARDS[S2] + SHARDS[S1][:1]}}, r"pages in two shards: \['10'\]"),
+    ({"shards": {S1: SHARDS[S1] + SHARDS[S1][1:2], S2: SHARDS[S2]}}, r"page 12 twice in " + S1),
+    ({"bad_sha1": S2}, r"sha1 mismatch: " + S2),
+    ({"shards": {}}, r"no pages-meta-current shards"),
+    ({"release": ["wikipedia_16", "wikipedia_10"]}, r"the sidecar's ids are not the parquet's"),
+    ({"release": ["wikipedia_16", "wikipedia_10", "wikipedia_10"]}, r"the sidecar's ids are not the parquet's"),
+])
+def test_citations_stops_when_the_dump_is_not_the_release(tmp_path, change, error):
+    dumps, data, status = _citations_inputs(tmp_path, **change)
+    with pytest.raises(ValueError, match=error):
+        fw.citations(dumps, data, status, workers=2)
+    assert not (data / "citations").exists() and "citations" not in fw.load(data / "wikipedia.build.json")
 
 
 # --- released data -------------------------------------------------------------------------
@@ -353,6 +436,33 @@ def test_every_row_is_labelled_by_contribution():
     assert fm.links_text("pl.wikipedia.org") in card
 
 
+def test_citations_table_matches_the_release():
+    """citations/wikipedia.citations.parquet (v2#110, option A) has every released row, in the same order and row
+    groups, and is the file and counts build.json and the card give."""
+    build = _read("build")
+    c = build["citations"]
+    path = DATA / c["file"]
+    assert c["file"] == "citations/wikipedia.citations.parquet" and c["sha256"] == fm.digest(path.read_bytes())
+    table = pq.read_table(path)
+    assert table.schema == pa.schema([("id", pa.string()), ("citations", pa.list_(pa.string()))])
+    assert table["id"].to_pylist() == _released()[1]["id"]
+    groups = [[f.metadata.row_group(i).num_rows for i in range(f.metadata.num_row_groups)]
+              for f in (pq.ParquetFile(path), pq.ParquetFile(DATA / "wikipedia.parquet"))]
+    assert groups[0] == groups[1]
+    lengths = pc.list_value_length(table["citations"])
+    assert c["rows"] == table.num_rows
+    assert c["rows_with_citations"] == pc.sum(pc.greater(lengths, 0)).as_py()
+    assert c["citations"] == pc.sum(lengths).as_py()
+    assert pc.min(pc.utf8_length(pc.list_flatten(table["citations"]))).as_py() > 0
+    assert c["dumpstatus_url"] == fw.DUMPSTATUS_URL and c["shards"] == fw.by_first_page(c["shards"])
+    for shard in c["shards"]:
+        assert fw.META_CURRENT_RE.fullmatch(shard["name"]) and shard["name"].startswith(f"plwiki-{fw.DUMP_DATE}-")
+        assert re.fullmatch(r"[0-9a-f]{40}", shard["sha1"]) and shard["size"] > 0
+    card = (DATA / "wikipedia.md").read_text(encoding="utf-8")
+    assert fw.citations_text(build) in card
+    assert fm.QUOTATIONS in card  # v2#110 E2: quotations rest on Art. 29, not the licence
+
+
 def test_copyright_sample_matches_the_release():
     """The sample must be redrawn if the released rows change, except by the copyright drops.
 

takedown/PROCEDURE.md

@@ -80,10 +80,12 @@ Work in your own worktree, on a branch for the PR.
    python3 src/takedown.py apply data/<k>/<k>.parquet [...]
    ```
 
-   This drops the rows from the shard and from every `<k>.*.jsonl` file next
-   to it. It subtracts them from the shared counters in `<k>.stats.json` and
-   refreshes `<k>.checksums.json`. Breakdowns such as `by_year` stay as they
-   were until the source's builder reruns.
+   This drops the rows from the shard, from every `<k>.*.jsonl` file next to
+   it and from every `<k>.*.parquet` table in a folder next to it, such as
+   `citations/<k>.citations.parquet`. It subtracts them from the shared
+   counters in `<k>.stats.json` and refreshes `<k>.checksums.json`.
+   Breakdowns such as `by_year` stay as they were until the source's builder
+   reruns.
 
 4. Find what still mentions the record. The id and the phrase can sit in the
    README, `artifacts/`, the datasheet `data/<k>/<k>.md`, `qa.json`, audits