Add source: eli_pdf_acts — Dziennik Ustaw and Monitor Polski acts published only as PDF

artifacts/source_findings.md

@@ -1008,3 +1008,40 @@ quoted third-party passages.
 spot-check noisy sources, a "0 residual" pattern count is not evidence; (2)
 CAPTCHA-gated origins are reproducible only via pinned checksums, not re-fetch -
 say so in the datasheet instead of pretending a before/after can be regenerated.
+
+## eli_pdf_acts — Dziennik Ustaw / Monitor Polski acts published only as PDF
+
+**Investigated** — 2026-10-01.
+
+**Verdict** — `added` (proposed with `release: None`). 33,795 acts / 209,434,373
+`cl100k_base` tokens that `dziennik_ustaw` cannot contain, because it reads
+`text.html` and the ELI API has none for them.
+
+**Enumeration** — `GET https://api.sejm.gov.pl/eli/acts/{DU|MP}/{year}` lists every
+act with `textHTML` / `textPDF` flags. All years 1918–2026 (checked 2026-10-01):
+164,568 acts, 39,110 with HTML up to 2025. **Monitor Polski: 0 of 66,697 acts have
+HTML**, in every year. Dziennik Ustaw: 2025–2026 0 of 3,185; 2000–2011 3,984 of
+23,604; 2012–2024 all but 98; before 2000 mostly PDF only. The PDF is
+`.../{pos}/text.pdf`. Text extraction is the hard part: Dz.U. 2000–2010 PDFs use
+QuarkXPress fonts with Mac Central European codes mapped as Mac Roman
+(`ROZPORZÑDZENIE`, `noÊników`, `s∏u˝àcych` from pdftotext), two columns, and one
+PDF per act that is really the issue's pages (neighbouring acts on the first and
+last page). This source uses eli2md's published conversions (see datasheet) and
+keeps only acts with `textHTML: false` at fetch time.
+
+**License evidence** — verified: Copyright Act art. 4 pkt 1 (normative acts) and
+pkt 2 (official documents and materials)
+(<https://eli.gov.pl/api/acts/DU/2025/24/text/O/D20250024.pdf>), as for
+`dziennik_ustaw`. Monitor Polski's non-normative items (notices, reports) are pkt 2.
+
+**Blockers** — none to merge with `release: None`. Before release: full NERGAL pass
+(only the rules layer ran); Monitor Polski names private persons in official
+records (party/committee financial reports, decorations), which NERGAL leaves by
+design; near-dedup against `dziennik_ustaw` (consolidated texts of 2025–2026
+repeat earlier ones).
+
+**Lesson** — check the API flags before assuming a "DU + MP" source covers MP:
+`fetch_eli.py`'s `textHTML` filter silently removed every Monitor Polski act. For
+OCR'd legal text, the document-level alpha-ratio gate is the wrong tool (20% of
+acts are under 0.70 because of dates, amounts and table numbers); a per-line
+filter on OCR lines only removed 2.8% of OCR characters.

data/eli_pdf_acts/eli_pdf_acts.attribution.jsonl

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

data/eli_pdf_acts/eli_pdf_acts.md

@@ -0,0 +1,179 @@
+# eli_pdf_acts — Dziennik Ustaw and Monitor Polski acts published only as PDF
+
+Polish official journals, the acts that the Sejm ELI API has **only as PDF**:
+**33,795 documents / 209,434,373 `cl100k_base` tokens / 544,132,888 characters**.
+All of Monitor Polski 2012–2026 (18,162 acts), Dziennik Ustaw 2000–2006
+(12,357 acts of the 12,362 without HTML) and Dziennik Ustaw 2025–2026 plus the 98
+PDF-only acts of 2020–2023 (3,276).
+
+## Why this is not already in `dziennik_ustaw`
+
+`src/fetch_eli.py` takes `text.html` and skips every act whose ELI list entry has
+`textHTML: false`. The ELI lists (`GET https://api.sejm.gov.pl/eli/acts/{DU|MP}/{year}`,
+all years 1918–2026, checked 2026-10-01) give:
+
+| | acts | with `textHTML` |
+|---|---:|---:|
+| Monitor Polski, every year | 66,697 | **0** |
+| Dziennik Ustaw 2000–2011 | 23,604 | 3,984 |
+| Dziennik Ustaw 2012–2024 | 30,234 | 30,136 |
+| Dziennik Ustaw 2025–2026 | 3,185 | **0** |
+
+So `dziennik_ustaw` holds no Monitor Polski act (despite its title), no act of 2025,
+and about one Dziennik Ustaw act in six from 2000–2011. This source is the
+complement and nothing more: the fetcher keeps an act only if the ELI list says
+`textHTML: false` at fetch time (all 33,801 input rows passed; 0 had HTML), so the
+two sources cannot hold the same act. If the API later adds HTML for an act, the
+next fetch drops it here.
+
+## Origin and license
+
+- Origin: the official PDFs of Dziennik Ustaw and Monitor Polski (Rządowe Centrum
+  Legislacji), served by the Sejm ELI API at
+  `https://api.sejm.gov.pl/eli/acts/{DU|MP}/{year}/{pos}/text.pdf`. Each document's
+  PDF URL, the PDF's SHA-256 and the converter version are in
+  `eli_pdf_acts.attribution.jsonl`; the `id` is the ELI address
+  (`eli_pdf_acts_DU_2003_991` = Dz.U. 2003 poz. 991).
+- Conversion: [eli2md](https://github.com/PolskiAgentW/eli2md) (MIT), versions
+  0.6.7–0.6.18. The converted acts are published as three datasets, pinned here by
+  revision: [`PolskiAgentW/monitor-polski-md`](https://huggingface.co/datasets/PolskiAgentW/monitor-polski-md)
+  @020d5b5, [`PolskiAgentW/dziennik-ustaw-md`](https://huggingface.co/datasets/PolskiAgentW/dziennik-ustaw-md)
+  @f20d217, [`PolskiAgentW/dziennik-ustaw-2000-2011-md`](https://huggingface.co/datasets/PolskiAgentW/dziennik-ustaw-2000-2011-md)
+  @5c07e50 (CC0-1.0).
+- License: normative acts and their official drafts (art. 4 pkt 1) and official
+  documents and materials (art. 4 pkt 2) are not subject to copyright —
+  [Copyright Act, art. 4](https://eli.gov.pl/api/acts/DU/2025/24/text/O/D20250024.pdf),
+  the same basis as `dziennik_ustaw`. Monitor Polski also prints non-normative
+  official documents (notices, announcements, reports of state bodies); these fall
+  under art. 4 pkt 2. No Creative Commons grant is claimed for the texts.
+
+## What the texts are
+
+- **Genre**: statutes, regulations, ordinances, resolutions, notices
+  (obwieszczenia, komunikaty), Constitutional Tribunal rulings, ratified
+  international agreements and their annexes (forms, tables, maps), consolidated
+  texts (teksty jednolite), corrections; in Monitor Polski also appointments,
+  financial reports of political parties and election committees, and other
+  reports of state bodies.
+- **Register**: formal legal and administrative Polish; long enumerations,
+  references and numeric tables.
+- **Time span**: Dziennik Ustaw 2000–2006, 2020–2021, 2023, 2025–2026;
+  Monitor Polski 2012–2026 (by journal year). `created` is the act's own date
+  ("z dnia …", ELI `announcementDate`), else its publication date, each used only if it falls in the journal year or
+  the year before: 1999-09-30 to 2026-09-29. 33 acts (international agreements,
+  conventions, protocols and denunciations: 32 in Dz.U. 2000, 1 in M.P. 2022)
+  have only an older title date (signing) and no publication date in the API;
+  they get the source range `1999-09-30, 2026-09-29`.
+- **OCR**: born-digital PDFs, except pages without a usable text layer (scans of
+  annexes, forms, maps, and some whole acts of 2000–2002), which eli2md reads with
+  tesseract 5 (`pol`). 45,114 of 246,251 PDF pages; 2,821 documents contain OCR
+  text; 78.3M of the 544M characters come from OCR.
+- Not machine-translated, not user-generated.
+
+## Quality of the conversion (measured against the ELI HTML where it exists)
+
+Plain text extraction does not work on these PDFs. Dziennik Ustaw 2000–2010 was
+typeset in QuarkXPress with Polish letters in Mac Central European codes mapped as
+Mac Roman, the pages have two columns, and an act's PDF is the pages of the issue
+it is printed on, so its first and last page carry the neighbouring acts.
+`pdftotext` on Dz.U. 2003 poz. 991, first page:
+
+```
+Za∏àcznik do rozporzàdzenia Ministra Infrastruktury
+[…]
+ROZPORZÑDZENIE MINISTRA KULTURY1)
+w sprawie okreÊlenia kategorii urzàdzeƒ i noÊników s∏u˝àcych do utrwalania utworów oraz op∏at od tych
+```
+
+This source, same act:
+
+```
+ROZPORZĄDZENIE MINISTRA KULTURY1)
+
+z dnia 2 czerwca 2003 r.
+
+w sprawie określenia kategorii urządzeń i nośników służących do utrwalania utworów oraz opłat od tych urządzeń i nośników z tytułu ich sprzedaży przez producentów i importerów
+```
+
+Measured on random samples drawn and committed before scoring, scored once,
+with the act's HTML as reference (only acts that have both can be scored):
+
+- Dz.U. 2000–2009, sample s5207 (53 acts, 255,122 reference words): reference words
+  recovered in order (LCS) — eli2md **0.993**; on the same PDFs pdfplumber 0.358,
+  pypdf 0.621, PyMuPDF 0.676, pdftotext 0.641
+  ([eval/extractors_2000_2009_s5207.md](https://github.com/PolskiAgentW/eli2md/blob/main/eval/extractors_2000_2009_s5207.md)).
+- Dz.U. 2012+, test sample s5113 (90 acts): main text words R 0.9993 / P 0.9979,
+  footnotes R 0.9701 / P 0.9564, annexes R 0.9973 / P 0.9627
+  ([README, 0.6.7](https://github.com/PolskiAgentW/eli2md#readme)).
+- **Not measured**: Monitor Polski (no act has HTML) and Dziennik Ustaw 2025–2026
+  (none has HTML). Monitor Polski was checked by eye on samples only.
+- OCR text is not covered by these numbers except for whole-act scans in s5207.
+
+## Collection and normalization
+
+Every step is in `src/fetch_eli_pdf_acts.py`, so the shard is reproducible from
+the script and the pinned revisions.
+
+1. **Select**: rows of the three pinned datasets whose act is `textHTML: false` in
+   the current ELI list for its year (33,801 of 33,801). 5 of them come out empty
+   and are dropped: Dz.U. 2000 poz. 48, 681, 682, 786, 886, one-page scans for
+   which the converter produced no text.
+2. **Markdown → text**: the first-line `# title` (written by eli2md from API
+   metadata; the act's printed title follows in the body) and eli2md's notes about
+   pages ("> [Strona 3 PDF nie ma czytelnej warstwy tekstowej …]", 61,984 lines,
+   9.2M characters) are dropped. OCR'd text comes as `> ` lines: the marker is
+   dropped, and an OCR line is dropped as noise if it has no word of 3+ letters, or
+   has under 50% letters among its non-space characters and fewer than 3 such
+   words — 128,782 of 658,233 OCR lines, 2.3M of 80.6M OCR characters (2.8%; 0.41%
+   of all text): stray digits of table cells, chart axis labels, stamp and grid
+   debris. This also drops some genuine numeric table rows (lists of customs codes
+   or parcel numbers). Heading hashes (`##### § 1.` → `§ 1.`), `**`, the `*…*`
+   eli2md puts around signature lines (`*Prezes Rady Ministrów: D. Tusk*`, 28,303
+   lines), image
+   links and markdown backslash escapes are removed; footnote marks `[^3]` become
+   `3)` and definitions `3) …`, as printed. Asterisks printed in the acts (`*)`
+   footnotes, marks in tariff tables) are kept.
+3. **Unicode and whitespace**: NFKC; no-break, thin and other spaces → space;
+   zero-width characters, soft hyphens and control characters dropped; spaces
+   collapsed, lines trimmed, at most one empty line in a row. Polish quotation
+   marks „…” and dashes are kept as printed.
+4. **PII**: the rules layer of [SlayerLab/NERGAL](https://huggingface.co/SlayerLab/NERGAL)
+   1.1.2 (`scrub_pii.py` at revision e0caa8b, SHA-256 checked against
+   `hybrid.json`): 8,847 spans (4,956 `[PII]`, 3,891 `[Telefon]`) in 661
+   documents (501 Monitor Polski, 160 Dziennik Ustaw), mostly phone/fax
+   numbers, e-mails, NIP/REGON/KRS and bank accounts in Monitor Polski notices
+   (financial reports of parties and election committees, tender notices) and the
+   ePUAP addresses of municipalities in MP 2023/503. A few hits are numbers in
+   tables. **The NERGAL model layer was not run** (CPU only); the shard needs a
+   full NERGAL pass before a release.
+5. **Gates** (`build_dynaword.py`): `is_ocr` is `False`, so the document-level
+   alpha-ratio gate does not run. It would drop 6,964 acts (20%), mostly short
+   notices and tables full of dates and amounts; OCR noise is handled per line in
+   step 2 instead. Other gates: 0 dropped as too short, 0 as
+   not Polish; exact dedup dropped 1 (M.P. 2020 poz. 747: the
+   same notice as poz. 736, printed twice).
+
+Article numbering, tables (as text rows) and annexes are kept: they are content.
+
+## Inclusion argument and caveats
+
+What this adds: the official journal text the corpus does not have — all of
+Monitor Polski, Dziennik Ustaw 2025–2026, and the 2000–2006 Dziennik Ustaw acts
+missing from `dziennik_ustaw` — with text that general PDF extractors garble on
+these years.
+
+Caveats:
+- Unofficial text from automatic conversion; the binding text is the PDF.
+- OCR'd parts (14% of characters) keep OCR errors, worst in tables and forms.
+  Tables are flattened to text rows.
+- Monitor Polski names private persons in official capacities and records
+  (party and committee financial reports, auditors, decorations, appointments).
+  NERGAL does not remove names by design.
+- Near-duplicates with `dziennik_ustaw` remain: a consolidated text (tekst
+  jednolity) of 2025–2026 repeats much of an earlier consolidated text of the
+  same law that `dziennik_ustaw` has from HTML; corrections repeat fragments.
+- Converter versions differ by year (0.6.7–0.6.18, per document in the sidecar).
+  Known: Dz.U. 2000 poz. 175 (0.6.16) still ends with the issue's colophon.
+- Coverage: Dziennik Ustaw 2007–2011 is being converted and is not in the pinned
+  revision yet; Dziennik Ustaw before 2000 and Monitor Polski before 2012 are not
+  converted.

data/eli_pdf_acts/eli_pdf_acts.parquet

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

data/eli_pdf_acts/eli_pdf_acts.stats.json

@@ -0,0 +1,16 @@
+{
+  "read": 33796,
+  "kept": 33795,
+  "drop_short": 0,
+  "drop_lang": 0,
+  "drop_dup": 1,
+  "drop_ocr": 0,
+  "chars": 544132888,
+  "tokens": 209434373,
+  "licenses": {
+    "public-domain (official documents)": 33795
+  },
+  "authors_with_value": 0,
+  "secs": 29.3,
+  "license": "public-domain (official documents)"
+}

src/fetch_eli_pdf_acts.py

@@ -0,0 +1,302 @@
+#!/usr/bin/env python3
+"""Fetch the Polish acts that the Sejm ELI API publishes only as PDF, as text, into a
+SpeakLeash-style .jsonl.zst for build_dynaword.py (source `eli_pdf_acts`).
+
+`dziennik_ustaw` (src/fetch_eli.py) takes text.html and skips every act with
+`textHTML: false`. That skips all of Monitor Polski (the API has no HTML for any
+MP act), Dziennik Ustaw 2025 onward, most of Dziennik Ustaw before 2012, and a
+few acts 2020-2023. This source is that complement and nothing else: an act is
+kept only if the ELI list for its year says `textHTML: false` at fetch time, so
+the two sources never hold the same act.
+
+Text: the official PDFs (https://api.sejm.gov.pl/eli/acts/{pub}/{year}/{pos}/text.pdf)
+converted by eli2md (https://github.com/PolskiAgentW/eli2md, MIT; text layer with
+the PDFs' broken font encodings repaired, page furniture removed, columns put in
+reading order, OCR (tesseract) for pages with no usable text layer). The converted
+acts are published as three Hugging Face datasets, pinned here by revision:
+  PolskiAgentW/monitor-polski-md            MP 2012-2026
+  PolskiAgentW/dziennik-ustaw-md            DU 2025-2026 and the 2020-2023 PDF-only acts
+  PolskiAgentW/dziennik-ustaw-2000-2011-md  DU 2000-2011 (years added as converted)
+Each row has `source_pdf` and `pdf_sha256`, so a document can be checked against
+the PDF it came from.
+
+Normalization (markdown -> text), in order:
+  1. drop the first-line `# title` (eli2md writes it from API metadata; the act's
+     own title follows in the body) and the converter's notes about pages
+     (`> [Strona N PDF nie ma czytelnej warstwy tekstowej ...]` and the like);
+  2. OCR'd text comes as `> ` quote lines: drop the marker, and drop an OCR line
+     that is noise read off images, form grids or stamps: no word of 3+ letters, or
+     under 50% letters among its non-space characters and fewer than 3 such words;
+  3. strip markdown: heading hashes (`##### § 1.` -> `§ 1.`), `**`, the `*…*` eli2md
+     puts around signature lines (`*Prezes Rady Ministrów: D. Tusk*`), image links,
+     backslash escapes of markdown punctuation; footnote marks `[^3]` -> `3)` and
+     definitions `[^3]: …` -> `3) …`, the way the printed acts mark them;
+  4. NFKC, no-break/thin/zero-width spaces to space (or dropped), soft hyphens and
+     control characters dropped, quote/dash zoo left as printed; spaces collapsed,
+     lines trimmed, at most one empty line in a row;
+  5. SlayerLab/NERGAL rules (`scrub_pii.py`, pinned revision, SHA256 checked).
+     The NERGAL model pass is not run here (no GPU); it has to be run before a release.
+Article numbering, tables (as `|` rows) and annex text are kept: they are content.
+`created` is the act's date from its title in the current ELI list, else its publication date
+(see act_date()).
+
+Usage:
+  python3 src/fetch_eli_pdf_acts.py --out ~/speakleash
+  python3 src/build_dynaword.py --sources eli_pdf_acts --speakleash-dir ~/speakleash --out .
+  python3 src/fetch_eli_pdf_acts.py --out ~/speakleash --attribution data/eli_pdf_acts/eli_pdf_acts.parquet
+
+The last step writes data/eli_pdf_acts/eli_pdf_acts.attribution.jsonl: for each id in the
+built shard, its ELI address, source PDF URL, PDF sha256 and converter version.
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import importlib.util
+import json
+import re
+import subprocess
+import sys
+import time
+import unicodedata
+from concurrent.futures import ProcessPoolExecutor
+from pathlib import Path
+from urllib.error import HTTPError, URLError
+from urllib.request import Request, urlopen
+
+KEY = "eli_pdf_acts"
+LICENSE = "public-domain (official documents)"
+API = "https://api.sejm.gov.pl/eli/acts"
+UA = {"User-Agent": "polish-dynaword/0.1 (+research; openly-licensed corpus)"}
+# dataset -> pinned revision (git sha on the Hub)
+DATASETS = {
+    "PolskiAgentW/monitor-polski-md": "020d5b5f0023bb17a2df911dae7c2650656ef3e1",
+    "PolskiAgentW/dziennik-ustaw-md": "f20d217b2e351e5527543fc7be6860c3c1fa1e86",
+    "PolskiAgentW/dziennik-ustaw-2000-2011-md": "5c07e5019e439f8bc4d5f5d75ab075fca525874b",
+}
+NERGAL_REPO = "SlayerLab/NERGAL"
+NERGAL_REV = "e0caa8b88afe213c52394afe425fb1504070f5ee"  # 1.1.2
+NERGAL_RULES_SHA256 = "08faef844c850bcd438c904d0b3f898df47c8bde8dd827d36ebffd39dc1594fb"
+FIELDS = ("id", "text", "created", "eli", "source_pdf", "pdf_sha256", "converter")
+
+ELI_RE = re.compile(r"^(DU|MP)/(\d{4})/(\d+)$")
+MONTHS = {m: i for i, m in enumerate("stycznia lutego marca kwietnia maja czerwca lipca sierpnia września "
+                                       "października listopada grudnia".split(), 1)}
+TITLE_DATE_RE = re.compile(r"\bz dnia (\d{1,2}) (" + "|".join(MONTHS) + r") (\d{4}) ?r\.")
+# converter notes eli2md puts in quote lines, e.g. "> [Strona 3 PDF nie ma czytelnej warstwy tekstowej …]"
+NOTE_RE = re.compile(r"^> \[(Strona|Strony|Na stronie|Na stronach) .*\]\s*$")
+FOOTDEF_RE = re.compile(r"^\[\^(\w+)\]:\s?")
+FOOTREF_RE = re.compile(r"\[\^(\w+)\]")
+HEADING_RE = re.compile(r"^#{1,6} ")
+IMAGE_RE = re.compile(r"!\[[^\]]*\]\([^)]*\)")
+# eli2md writes a signature block as one italic line, "*Prezes Rady Ministrów: D. Tusk*"; a printed line that
+# starts and ends with "*" (customs-tariff rows, "*) footnote") has no "Title: Name" colon or starts with ")"
+SIGNATURE_RE = re.compile(r"^\*([^\s*)][^*]*:[^*]*[^\s*])\*$")
+ESCAPE_RE = re.compile(r"\\([\\`*_{}\[\]()#+\-.!|>~])")
+LETTER_RE = re.compile(r"[^\W\d_]")
+WORD3_RE = re.compile(r"[^\W\d_]{3,}")
+# no-break, thin, figure, narrow and other unicode spaces -> space; zero-width -> nothing
+SPACES = dict.fromkeys(map(ord, "            "
+                                  "  　"), " ")
+SPACES.update(dict.fromkeys(map(ord, "​‌‍⁠­"), None))  # + soft hyphen
+
+
+def ocr_noise(line: str) -> bool:
+    """An OCR line read off a picture, form grid or stamp rather than off text."""
+    chars = [c for c in line if not c.isspace()]
+    if not chars:
+        return True
+    words = len(WORD3_RE.findall(line))
+    letters = len(LETTER_RE.findall(line))
+    # a long citation line ("… Nr 30, poz. 179, z 1991 r. Nr 4, …") is mostly digits but has words
+    return words == 0 or (letters / len(chars) < 0.5 and words < 3)
+
+
+def md_to_text(md: str) -> tuple[str, dict[str, int]]:
+    """eli2md markdown -> plain text (steps 1-3 of the module doc). Returns text and counts."""
+    st = {"notes": 0, "ocr_lines": 0, "ocr_noise": 0}
+    lines = md.split("\n")
+    if lines and lines[0].startswith("# "):
+        lines = lines[1:]
+    out = []
+    for line in lines:
+        if NOTE_RE.match(line):
+            st["notes"] += 1
+            continue
+        if line.startswith(">"):
+            line = line[2:] if line.startswith("> ") else line[1:]
+            st["ocr_lines"] += 1
+            if ocr_noise(line):
+                st["ocr_noise"] += 1
+                continue
+        else:
+            line = SIGNATURE_RE.sub(r"\1", line)
+        line = HEADING_RE.sub("", line)
+        line = FOOTDEF_RE.sub(lambda m: f"{m.group(1)}) ", line)
+        line = FOOTREF_RE.sub(lambda m: f"{m.group(1)})", line)
+        line = IMAGE_RE.sub("", line).replace("**", "")
+        line = ESCAPE_RE.sub(r"\1", line)
+        out.append(line)
+    return "\n".join(out), st
+
+
+def normalize(text: str) -> str:
+    """Step 4: unicode and whitespace."""
+    text = unicodedata.normalize("NFKC", text).translate(SPACES)
+    text = "".join(c for c in text if c in "\n\t" or unicodedata.category(c)[0] != "C")
+    lines = [re.sub(r"[ \t]+", " ", ln).strip() for ln in text.split("\n")]
+    return re.sub(r"\n{3,}", "\n\n", "\n".join(lines)).strip()
+
+
+def act_date(entry: dict, year: int) -> str:
+    """The act's date as its title gives it ("… z dnia 5 grudnia 2000 r. …"), else its publication date, each only
+    if it falls in the journal year or the year before; else "" (build_dynaword then uses the source's range).
+    Not the API's announcementDate: it has typos (DU/2020/2059 "z dnia 27 października 2020" -> 2020-11-27,
+    DU/2026/34 "z dnia 17 grudnia 2025" -> 2026-12-17). A title's first "z dnia" can belong to another document
+    (a treaty amended, a convention a reservation was made to), hence the year window."""
+    m = TITLE_DATE_RE.search(entry.get("title") or "")
+    if m and year - 1 <= int(m.group(3)) <= year:
+        return f"{int(m.group(3)):04d}-{MONTHS[m.group(2)]:02d}-{int(m.group(1)):02d}"
+    pub = entry.get("promulgation") or ""
+    return pub if pub[:4] == str(year) else ""
+
+
+def _get(url: str, tries: int = 4):
+    for i in range(tries):
+        try:
+            with urlopen(Request(url, headers=UA), timeout=60) as r:
+                return json.loads(r.read())
+        except (HTTPError, URLError, TimeoutError):
+            time.sleep(2 * (i + 1))
+    raise RuntimeError(f"ELI API failed: {url}")
+
+
+def pdf_only(pub: str, year: int, cache: dict) -> dict[int, dict]:
+    """Acts the ELI API has as PDF but not as HTML, as of now: position -> list entry."""
+    if (pub, year) not in cache:
+        items = _get(f"{API}/{pub}/{year}").get("items", [])
+        cache[pub, year] = {it["pos"]: it for it in items if not it.get("textHTML") and it.get("textPDF")}
+    return cache[pub, year]
+
+
+def load_rules(cache_dir: Path):
+    from huggingface_hub import hf_hub_download
+    path = hf_hub_download(NERGAL_REPO, "scrub_pii.py", revision=NERGAL_REV, cache_dir=cache_dir)
+    digest = hashlib.sha256(Path(path).read_bytes()).hexdigest()
+    if digest != NERGAL_RULES_SHA256:
+        raise RuntimeError(f"NERGAL scrub_pii.py sha256 {digest} != {NERGAL_RULES_SHA256}")
+    spec = importlib.util.spec_from_file_location("scrub_pii", path)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+_RULES = None
+
+
+def _init(rules_path: str) -> None:
+    global _RULES
+    spec = importlib.util.spec_from_file_location("scrub_pii", rules_path)
+    _RULES = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(_RULES)
+
+
+def convert(row: dict) -> tuple[dict | None, dict]:
+    """One dataset row -> (jsonl record or None, counts)."""
+    text, st = md_to_text(row["markdown"] or "")
+    text = normalize(text)
+    text, hits = _RULES.scrub_pii(text)
+    st["pii_masks"] = sum(hits.values())
+    if not text:
+        return None, st
+    m = ELI_RE.match(row["eli"])
+    rec = {
+        "id": f"{KEY}_{m.group(1)}_{m.group(2)}_{m.group(3)}",
+        "text": text,
+        "created": row["created"],
+        "eli": row["eli"],
+        "source_pdf": row["source_pdf"],
+        "pdf_sha256": row["pdf_sha256"],
+        "converter": row["converter"],
+    }
+    return rec, st
+
+
+def write_attribution(jsonl_zst: Path, shard: Path) -> int:
+    """Sidecar rows (all FIELDS but text) for the ids that made it into the built shard, in shard order."""
+    import pyarrow.parquet as pq
+    import zstandard
+    ids = pq.read_table(shard, columns=["id"]).column("id").to_pylist()
+    meta = {}
+    with jsonl_zst.open("rb") as fh:
+        for line in zstandard.ZstdDecompressor().stream_reader(fh).read().decode("utf-8").splitlines():
+            rec = json.loads(line)
+            meta[rec["id"]] = {k: rec[k] for k in FIELDS if k != "text"}
+    out = shard.with_name(f"{KEY}.attribution.jsonl")
+    with out.open("w", encoding="utf-8") as f:
+        for i in ids:
+            f.write(json.dumps(meta[i], ensure_ascii=False) + "\n")
+    return len(ids)
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--out", default="~/speakleash")
+    ap.add_argument("--cache", default="~/.cache/eli_pdf_acts")
+    ap.add_argument("--workers", type=int, default=4)
+    ap.add_argument("--attribution", metavar="SHARD", help="only write the sidecar for a built shard")
+    args = ap.parse_args()
+    if args.attribution:
+        n = write_attribution(Path(args.out).expanduser() / f"{KEY}.jsonl.zst", Path(args.attribution))
+        print(f"attribution: {n:,} rows")
+        return
+    import pyarrow.parquet as pq
+    from huggingface_hub import hf_hub_download
+
+    out_dir = Path(args.out).expanduser()
+    out_dir.mkdir(parents=True, exist_ok=True)
+    cache_dir = Path(args.cache).expanduser()
+    rules_path = load_rules(cache_dir).__file__
+    flags: dict = {}
+    seen: set[str] = set()
+    tot = {"rows": 0, "kept": 0, "not_pdf_only": 0, "dup_eli": 0, "empty": 0, "notes": 0, "ocr_lines": 0,
+           "ocr_noise": 0, "pii_masks": 0}
+    jsonl = out_dir / f"{KEY}.jsonl"
+    with jsonl.open("w", encoding="utf-8") as f, \
+            ProcessPoolExecutor(args.workers, initializer=_init, initargs=(rules_path,)) as pool:
+        for repo, rev in DATASETS.items():
+            name = repo.split("/")[1]
+            path = hf_hub_download(repo, f"data/{name}.parquet", repo_type="dataset", revision=rev,
+                                   cache_dir=cache_dir)
+            cols = ["eli", "source_pdf", "pdf_sha256", "converter", "markdown"]
+            rows = []
+            for row in pq.read_table(path, columns=cols).to_pylist():
+                tot["rows"] += 1
+                pub, year, pos = ELI_RE.match(row["eli"]).groups()
+                entry = pdf_only(pub, int(year), flags).get(int(pos))
+                if entry is None:
+                    tot["not_pdf_only"] += 1
+                    continue
+                row["created"] = act_date(entry, int(year))
+                if row["eli"] in seen:
+                    tot["dup_eli"] += 1
+                    continue
+                seen.add(row["eli"])
+                rows.append(row)
+            for rec, st in pool.map(convert, rows, chunksize=64):
+                for k in ("notes", "ocr_lines", "ocr_noise", "pii_masks"):
+                    tot[k] += st[k]
+                if rec is None:
+                    tot["empty"] += 1
+                    continue
+                f.write(json.dumps({k: rec[k] for k in FIELDS}, ensure_ascii=False) + "\n")
+                tot["kept"] += 1
+            print(f"  {repo}@{rev[:8]}: {len(rows):,} PDF-only acts", flush=True)
+    subprocess.run(["zstd", "-q", "-f", "-19", "-T0", str(jsonl), "-o", str(jsonl) + ".zst"], check=True)
+    jsonl.unlink()
+    print(json.dumps(tot, indent=1))
+    (out_dir / f"{KEY}.fetch_stats.json").write_text(json.dumps(tot, indent=1))
+
+
+if __name__ == "__main__":
+    main()

src/sources.py

@@ -774,6 +774,32 @@ SOURCES = {
         "is_ocr": False,
         "custom_datasheet": True,
     },
+    "eli_pdf_acts": {
+        "added": "2026-10-01",
+        "release": None,
+        "file_key": "eli_pdf_acts",  # fetched by src/fetch_eli_pdf_acts.py, NOT via SpeakLeash
+        "pretty": "Dziennik Ustaw + Monitor Polski acts published only as PDF",
+        "license": "public-domain (official documents)",
+        "license_spdx": "CC0-1.0",
+        "traceable": "Normative acts (art. 4 pkt 1) and official documents (art. 4 pkt 2) "
+                     "are not subject to copyright under the Polish Copyright Act, the "
+                     "same basis as dziennik_ustaw. Per-record source_url and pdf_sha256 "
+                     "in the attribution sidecar pin the official PDF on api.sejm.gov.pl.",
+        "upstream": "https://api.sejm.gov.pl/eli/acts",
+        "provenance": "Acts whose ELI list entry has textHTML=false (the ones "
+                      "src/fetch_eli.py skips): official PDFs converted by eli2md "
+                      "(published as PolskiAgentW/{monitor-polski-md,dziennik-ustaw-md,"
+                      "dziennik-ustaw-2000-2011-md}, pinned revisions), markdown to text, "
+                      "OCR-noise lines dropped, NFKC/whitespace normalization, NERGAL "
+                      "rules layer (scrub_pii.py) only - re-run through full "
+                      "SlayerLab/NERGAL before release.",
+        "domain": "legal",
+        "created": "1999-09-30, 2026-09-29",
+        "is_ocr": False,  # partly OCR'd; the document-level alpha gate would drop 20% (tables, dates)
+        "preserve_id": True,  # ids carry the ELI address
+        "preserve_created": True,  # the act's own date
+        "custom_datasheet": True,
+    },
 }
 
 # Fallback stamp for a source with no recorded "added" date of its own.

src/test_eli_pdf_acts_contract.py

@@ -0,0 +1,124 @@
+"""Contract for eli_pdf_acts: markdown -> text normalization and the shipped shard."""
+import json
+import re
+import sys
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from fetch_eli_pdf_acts import ELI_RE, FIELDS, KEY, LICENSE, act_date, md_to_text, normalize, ocr_noise
+
+ROOT = Path(__file__).resolve().parents[1]
+DATA = ROOT / "data" / KEY
+SCHEMA = ["id", "text", "source", "added", "created", "token_count", "license", "author"]
+ID_RE = re.compile(rf"^{KEY}_(DU|MP)_(\d{{4}})_(\d+)$")
+
+
+class MarkdownToTextTest(unittest.TestCase):
+    def test_title_heading_dropped_units_kept(self):
+        md = "# Ustawa z dnia 1 lipca 2005 r. o czymś\n\nUSTAWA\n\n##### Art. 1.\n\n1. Treść **ważna**."
+        text = normalize(md_to_text(md)[0])  # the order convert() uses
+        self.assertNotIn("#", text)
+        self.assertTrue(text.startswith("USTAWA"))
+        self.assertIn("Art. 1.", text)
+        self.assertIn("1. Treść ważna.", text)
+
+    def test_converter_notes_dropped_ocr_kept(self):
+        md = ("# T\n\n> [Strona 3 PDF nie ma czytelnej warstwy tekstowej. Tekst poniżej odczytał OCR (tesseract).]\n\n"
+              "> Załącznik nr 1 do rozporządzenia Ministra Zdrowia\n\n> jo] O| OO; ry 2\n\n> 58")
+        text, st = md_to_text(md)
+        self.assertNotIn("Strona 3", text)
+        self.assertIn("Załącznik nr 1 do rozporządzenia Ministra Zdrowia", text)
+        self.assertNotIn("jo]", text)
+        self.assertNotIn("58", text)
+        self.assertEqual(st["notes"], 1)
+        self.assertEqual(st["ocr_noise"], 2)
+
+    def test_citation_heavy_ocr_line_is_not_noise(self):
+        self.assertFalse(ocr_noise("Na podstawie art. 91 ust. 2 ustawy z dnia 6 kwietnia 1990 r. o Policji "
+                                   "(Dz. U. Nr 30, poz. 179, z 1991 r. Nr 94, poz. 422 i Nr 107, poz. 461)"))
+        self.assertTrue(ocr_noise("0709 60 100 0709 90 0709 90 90 0 ex 0709 90 90 0"))
+
+    def test_footnotes_and_escapes(self):
+        text, _ = md_to_text("# T\n\nMINISTRA KULTURY[^1]\n\nA \\| B \\- C \\[x\\] \\d{11}\n\n[^1]: Minister Kultury kieruje działem.")
+        self.assertIn("MINISTRA KULTURY1)", text)
+        self.assertIn("1) Minister Kultury kieruje działem.", text)
+        self.assertIn("A | B - C [x] \\d{11}", text)  # markdown escapes undone, other backslashes kept
+
+    def test_signature_italics_dropped_printed_asterisks_kept(self):
+        md = ("# T\n\n*Prezes Rady Ministrów: D. Tusk*\n\n*) Należy wpisać bieżący rok.*\n\n"
+              "*3926 90 910 - - - - Wyprodukowane z arkusza *\n\n> *Minister Zdrowia: X*")
+        lines = normalize(md_to_text(md)[0]).split("\n\n")
+        self.assertEqual(lines[0], "Prezes Rady Ministrów: D. Tusk")
+        self.assertEqual(lines[1], "*) Należy wpisać bieżący rok.*")
+        self.assertEqual(lines[2], "*3926 90 910 - - - - Wyprodukowane z arkusza *")
+        self.assertEqual(lines[3], "*Minister Zdrowia: X*")  # OCR text is not eli2md markup
+
+    def test_normalize_unicode_and_whitespace(self):
+        raw = "a\u00a0b\u200b c\u00ad d\x07  e \n\n\n\n f\ufb01"
+        self.assertEqual(normalize(raw), "a b c d e\n\nffi")
+        self.assertEqual(normalize("„Art. 5. …”"), "„Art. 5. ...”")  # NFKC folds the ellipsis only
+
+
+class ActDateTest(unittest.TestCase):
+    def test_title_date_wins_over_api_typo(self):
+        entry = {"title": "Obwieszczenie Marszałka Sejmu z dnia 27 października 2020 r. w sprawie …",
+                 "announcementDate": "2020-11-27", "promulgation": "2020-11-20"}
+        self.assertEqual(act_date(entry, 2020), "2020-10-27")
+        self.assertEqual(act_date({"title": "Ustawa z dnia 17 grudnia 2025 r. o …"}, 2026), "2025-12-17")
+
+    def test_other_documents_date_falls_back_to_publication(self):
+        entry = {"title": "Umowa między Rządem RP a Rządem Związkowym z dnia 18 lipca 1972 r. …",
+                 "promulgation": "2000-04-12"}
+        self.assertEqual(act_date(entry, 2000), "2000-04-12")
+
+    def test_no_credible_date(self):
+        self.assertEqual(act_date({"title": "Umowa sporządzona dnia 22 lipca 1944 r.", "promulgation": "1997-08-21"}, 2022), "")
+
+
+@unittest.skipUnless((DATA / f"{KEY}.parquet").exists(), "shard not built")
+class ShardContractTest(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        import pyarrow.parquet as pq
+        cls.table = pq.read_table(DATA / f"{KEY}.parquet", columns=[c for c in SCHEMA if c != "text"])
+        cls.stats = json.loads((DATA / f"{KEY}.stats.json").read_text())
+
+    def test_schema(self):
+        import pyarrow.parquet as pq
+        self.assertEqual(pq.ParquetFile(DATA / f"{KEY}.parquet").schema_arrow.names, SCHEMA)
+
+    def test_uniform_source_and_license(self):
+        self.assertEqual(set(self.table.column("source").to_pylist()), {KEY})
+        self.assertEqual(set(self.table.column("license").to_pylist()), {LICENSE})
+
+    def test_ids_are_unique_eli_addresses(self):
+        ids = self.table.column("id").to_pylist()
+        self.assertEqual(len(ids), len(set(ids)))
+        self.assertTrue(all(ID_RE.match(i) for i in ids))
+
+    def test_positive_tokens_and_dates(self):
+        self.assertGreater(min(self.table.column("token_count").to_pylist()), 0)
+        from sources import SOURCES
+        fallback = SOURCES[KEY]["created"]
+        created = self.table.column("created").to_pylist()
+        self.assertTrue(all(re.match(r"^\d{4}-\d{2}-\d{2}$", c) or c == fallback for c in created))
+        self.assertLess(sum(c == fallback for c in created), 50)  # 33 on 2026-10-01
+
+    def test_stats_consistent(self):
+        self.assertEqual(self.stats["kept"], self.table.num_rows)
+        self.assertEqual(self.stats["tokens"], sum(self.table.column("token_count").to_pylist()))
+
+    def test_attribution_sidecar_matches_shard(self):
+        rows = [json.loads(ln) for ln in (DATA / f"{KEY}.attribution.jsonl").read_text().splitlines()]
+        self.assertEqual([r["id"] for r in rows], self.table.column("id").to_pylist())
+        for r in rows[:: max(1, len(rows) // 500)]:
+            self.assertEqual(set(r), set(FIELDS) - {"text"})
+            self.assertTrue(ELI_RE.match(r["eli"]))
+            self.assertEqual(r["source_pdf"], f"https://api.sejm.gov.pl/eli/acts/{r['eli']}/text.pdf")
+            self.assertRegex(r["pdf_sha256"], r"^[0-9a-f]{64}$")
+
+
+if __name__ == "__main__":
+    unittest.main()