Add in-tree PII scrub (no new parquet) (#20)

- Add in-tree PII scrub and wire it into HPLT and Sejm fetchers (f02380ada54f72c34dcf195464c6639e840eb731)


Co-authored-by: Paweł Puzio <ppuzio@users.noreply.huggingface.co>

src/clean_hplt_v3.py

@@ -16,6 +16,10 @@ import zstandard as zstd
 import pyarrow as pa, pyarrow.parquet as pq
 import tiktoken
 
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from scrub_entities import scrub_entities
+from scrub_pii import scrub_pii
+
 ADDED = "2026-07-14"
 SOURCE = "european_hplt_v3_pl"
 LICENSE = "CC0-1.0"
@@ -125,6 +129,7 @@ def main():
     t0 = time.time()
 
     drops = {}; regs = {}; doms = {}; dom_counts = {}
+    pii_tot = {k: 0 for k in ("email", "phone", "pesel", "nip", "regon", "account")}
     ids, texts, tokens = [], [], []
     read = kept = chars = toks = 0
     mt_sum = 0.0
@@ -169,6 +174,11 @@ def main():
                 reg = o.get("web-register") or {}
                 rtop, _ = top_register(reg); regs[rtop] = regs.get(rtop, 0) + 1
                 mt_sum += float(reg.get("MT", 0.0)) if isinstance(reg, dict) else 0.0
+                text, pii = scrub_pii(text)
+                text, ner = scrub_entities(text, SOURCE)
+                for k, v in pii.items():
+                    pii_tot[k] = pii_tot.get(k, 0) + v
+                pii_tot["person"] = pii_tot.get("person", 0) + ner["person"]
                 tk = len(ENC.encode(text, disallowed_special=()))
                 ids.append(f"{out}_{kept}"); texts.append(text); tokens.append(tk)
                 kept += 1; chars += len(text); toks += tk
@@ -192,6 +202,7 @@ def main():
              "mt_prob_mean_kept": round(mt_sum / max(1, kept), 3),
              "domains_top_sample": dict(sorted(doms.items(), key=lambda x: -x[1])[:30]),
              "secs": round(time.time()-t0, 1),
+             "pii_scrub": pii_tot,
              "source_repo": f"HPLT/HPLT3.0 pol_Latn {a.bin_label} via {a.inp}"}
     (outd / f"{out}.stats.json").write_text(json.dumps(stats, ensure_ascii=False, indent=2)+"\n", encoding="utf-8")
     print("=== STATS ===")

src/fetch_govpl.py

@@ -21,18 +21,15 @@ Usage:
 from __future__ import annotations
 import argparse, json, re, subprocess, sys, threading, time
 from concurrent.futures import ThreadPoolExecutor
-from html import unescape
 from pathlib import Path
 
 sys.path.insert(0, str(Path(__file__).resolve().parent))
 from discover_govpl import BASE, http_get, http_get_url, listing_articles  # shared, DRY
+from html_text import html_to_text
 
 KEY = "govpl"  # build_dynaword reads <KEY>.jsonl.zst
 MIN_CHARS = 200  # same floor as build_dynaword; skip stubs early
 
-_SCRIPT = re.compile(r"(?is)<(script|style)[^>]*>.*?</\1>")
-_BLOCK_END = re.compile(r"(?i)</(p|div|h[1-6]|li|tr|table|ul|ol|blockquote)\s*>|<br\s*/?>")
-_TAG = re.compile(r"<[^>]+>")
 # Body ends where the editor-content region gives way to gallery/attachments/tags.
 _END_MARKER = re.compile(
     r'<[^>]+class="[^"]*(?:attachments|art-tags|tags|social|share|gallery|files)[^"]*"'
@@ -40,17 +37,6 @@ _END_MARKER = re.compile(
 _EDITOR = re.compile(r'<div class="editor-content"[^>]*>', re.I)
 
 
-def html_to_text(html: str) -> str:
-    html = _SCRIPT.sub("", html)
-    html = _BLOCK_END.sub("\n", html)
-    html = _TAG.sub("", html)
-    text = unescape(html)
-    text = re.sub(r"[ \t]+", " ", text)
-    text = re.sub(r" *\n *", "\n", text)
-    text = re.sub(r"\n{3,}", "\n\n", text)
-    return text.strip()
-
-
 def article_body(html: str) -> str:
     """Text of the article body. gov.pl pages carry the class twice; pick the
     richest editor-content region and cut at the trailing gallery/attachments.

src/fetch_sejm_api.py

@@ -16,6 +16,8 @@ import shutil
 import sys
 from typing import Any, Iterable
 
+sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent))
+from scrub_pii import scrub_pii
 
 SOURCE_NAME = "sejm_api"
 SOURCE_REPOSITORY = "PiotrSty/sejm-speeches-corpus"
@@ -82,6 +84,7 @@ def normalize_source_row(
         return None
 
     text = str(row["text"]).strip()
+    text, _ = scrub_pii(text)
     author = str(row.get("speaker", "")).strip()
     source_url = str(row.get("source_url", "")).strip()
     term = str(row.get("term", "")).strip()

src/fetch_sejm_interpellations.py

@@ -0,0 +1,235 @@
+#!/usr/bin/env python3
+"""Fetch Sejm interpellations and written questions into a SpeakLeash-style
+.jsonl.zst for build_dynaword.py.
+
+Official parliamentary materials, outside copyright under art. 4 pkt 2 pr. aut.,
+same legal basis as the shipped sejm_api shard. HTML body endpoints only —
+attachment-only replies (PDFs) and keyless prolongation stubs are skipped.
+
+Header chrome (nr / recipient / title / signatory / date) is stripped so it
+lives in meta, not text. PII regex-scrub runs before the line is written.
+
+Usage:
+  python3 src/fetch_sejm_interpellations.py --out ~/speakleash
+  python3 src/fetch_sejm_interpellations.py --out ~/speakleash --terms 10 --max-docs 30
+"""
+from __future__ import annotations
+import argparse, json, re, subprocess, sys, time
+from pathlib import Path
+from urllib.error import HTTPError, URLError
+from urllib.request import Request, urlopen
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from html_text import html_to_text
+from scrub_pii import scrub_pii
+
+API = "https://api.sejm.gov.pl"
+KEY = "sejm_interpellations"
+UA = {"User-Agent": "polish-dynaword/0.1 (+research; openly-licensed corpus)",
+      "Accept": "*/*"}
+MIN_CHARS = 200
+DEFAULT_TERMS = (7, 8, 9, 10)  # 1–6 time out; see artifacts/source_findings.md
+COLLECTIONS = ("interpellations", "writtenQuestions")
+
+_KIND = {
+    ("interpellations", False): "interpellation",
+    ("interpellations", True): "interpellation_reply",
+    ("writtenQuestions", False): "written_question",
+    ("writtenQuestions", True): "written_question_reply",
+}
+_COLLECTION = {
+    "interpellation": "interpellations",
+    "interpellation_reply": "interpellations",
+    "written_question": "writtenQuestions",
+    "written_question_reply": "writtenQuestions",
+}
+
+_HEAD = re.compile(r"(?is)<head[^>]*>.*?</head>")
+_H1 = re.compile(r"(?is)<h1[^>]*>.*?</h1>")
+_META_P = re.compile(
+    r'(?is)<p[^>]*class="[^"]*(?:int-recipient|int-title|intAuthor|'
+    r'intDateTresc|intDate)[^"]*"[^>]*>.*?</p>'
+)
+_AUTHOR_P = re.compile(r'(?is)<p[^>]*class="[^"]*intAuthor[^"]*"[^>]*>(.*?)</p>')
+_AUTHOR_LABEL = re.compile(r"^(Zgłaszający|Odpowiadający):\s*", re.I)
+_ATTACH_LINE = re.compile(
+    r"(?i)^(?:Treść odpowiedzi znajduje się w załączniku\.?|Załączniki|"
+    r"\(podpisane elektronicznie\).*|.*\.pdf)\s*$"
+)
+
+
+def should_fetch_reply(reply: dict | None) -> bool:
+    if not reply:
+        return False
+    key = reply.get("key")
+    if not key:
+        return False
+    return not reply.get("onlyAttachment")
+
+
+def body_url(term, collection, num, reply=None) -> str:
+    base = f"{API}/sejm/term{term}/{collection}/{num}"
+    if reply:
+        return f"{base}/reply/{reply['key']}/body"
+    return f"{base}/body"
+
+
+def _author_from_html(html: str) -> str:
+    m = _AUTHOR_P.search(html)
+    if not m:
+        return ""
+    return _AUTHOR_LABEL.sub("", html_to_text(m.group(1))).strip()
+
+
+def extract_body(html: str) -> str:
+    html = _HEAD.sub("", html)
+    html = _H1.sub("", html)
+    html = _META_P.sub("", html)
+    text = html_to_text(html)
+    lines = [ln for ln in text.splitlines() if not _ATTACH_LINE.match(ln.strip())]
+    return "\n".join(lines).strip()
+
+
+def normalize_document(kind: str, item: dict, html: str, reply: dict | None = None):
+    """Listing item + body HTML → {text, meta}, or None if thin / stub."""
+    text = extract_body(html)
+    text, _ = scrub_pii(text)
+    if len(text) < MIN_CHARS:
+        return None
+    collection = _COLLECTION[kind]
+    term = item.get("term")
+    num = item.get("num")
+    author = _author_from_html(html)
+    if not author and reply:
+        author = (reply.get("from") or "").strip()
+    date = (reply or {}).get("receiptDate") or item.get("receiptDate") or ""
+    meta = {
+        "url": body_url(term, collection, num, reply),
+        "term": term,
+        "num": num,
+        "kind": kind,
+        "title": item.get("title") or "",
+        "date": date,
+        "author": author,
+    }
+    if reply:
+        meta["reply_key"] = reply.get("key") or ""
+    return {"text": text, "meta": meta}
+
+
+def _get(url, tries=4):
+    last = None
+    for i in range(tries):
+        try:
+            with urlopen(Request(url, headers=UA), timeout=45) as r:
+                return r.read(), dict(r.headers)
+        except (HTTPError, URLError, TimeoutError) as e:
+            last = e
+            if isinstance(e, HTTPError) and e.code in (404, 500):
+                break
+            time.sleep(1.5 * (i + 1))
+    return None, {"error": repr(last)}
+
+
+def _get_json(url):
+    raw, hdrs = _get(url)
+    if raw is None:
+        return None, hdrs
+    return json.loads(raw), hdrs
+
+
+def iter_listing(term, collection, page_size):
+    offset = 0
+    while True:
+        url = f"{API}/sejm/term{term}/{collection}?limit={page_size}&offset={offset}"
+        items, hdrs = _get_json(url)
+        if items is None:
+            raise RuntimeError(f"list failed after retries: {url} ({hdrs.get('error')})")
+        if not items:
+            return
+        yield from items
+        offset += len(items)
+        if len(items) < page_size:
+            return
+
+
+def main(argv=None) -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--out", default="~/speakleash")
+    ap.add_argument("--terms", default="7,8,9,10",
+                    help="comma-separated Sejm terms (default 7-10)")
+    ap.add_argument("--collections", default="interpellations,writtenQuestions")
+    ap.add_argument("--page-size", type=int, default=50)
+    ap.add_argument("--max-docs", type=int, default=0, help="stop after N kept rows")
+    args = ap.parse_args(argv)
+
+    terms = [int(t) for t in args.terms.split(",") if t.strip()]
+    collections = [c.strip() for c in args.collections.split(",") if c.strip()]
+    out_dir = Path(args.out).expanduser()
+    out_dir.mkdir(parents=True, exist_ok=True)
+    jsonl = out_dir / f"{KEY}.jsonl"
+
+    done = set()
+    if jsonl.exists():
+        for ln in jsonl.open(encoding="utf-8"):
+            try:
+                done.add(json.loads(ln)["meta"]["url"])
+            except Exception:
+                pass
+        print(f"resume: {len(done):,} already fetched")
+
+    kept = seen = skipped = 0
+    t0 = time.time()
+    with jsonl.open("a", encoding="utf-8") as fo:
+        for term in terms:
+            for collection in collections:
+                print(f"term {term} {collection}", flush=True)
+                for item in iter_listing(term, collection, args.page_size):
+                    jobs = [(False, None)]
+                    for reply in item.get("replies") or []:
+                        if should_fetch_reply(reply):
+                            jobs.append((True, reply))
+                    for is_reply, reply in jobs:
+                        url = body_url(term, collection, item.get("num"), reply)
+                        seen += 1
+                        if url in done:
+                            continue
+                        raw, hdrs = _get(url)
+                        if raw is None:
+                            skipped += 1
+                            print(f"  WARN skip {url} {hdrs.get('error')}",
+                                  file=sys.stderr, flush=True)
+                            continue
+                        kind = _KIND[(collection, is_reply)]
+                        rec = normalize_document(
+                            kind, item, raw.decode("utf-8", "replace"), reply
+                        )
+                        done.add(url)
+                        if rec:
+                            fo.write(json.dumps(rec, ensure_ascii=False) + "\n")
+                            kept += 1
+                        else:
+                            skipped += 1
+                        if seen % 200 == 0:
+                            print(f"  seen {seen:,} kept {kept:,} skip {skipped:,} "
+                                  f"{seen / max(time.time() - t0, 1):.1f}/s", flush=True)
+                        if args.max_docs and kept >= args.max_docs:
+                            break
+                    if args.max_docs and kept >= args.max_docs:
+                        break
+                if args.max_docs and kept >= args.max_docs:
+                    break
+            if args.max_docs and kept >= args.max_docs:
+                break
+
+    print(f"fetched {kept:,} new docs ({skipped:,} skipped); compressing...", flush=True)
+    subprocess.run(
+        ["zstd", "-19", "-f", "--rm", str(jsonl), "-o", str(out_dir / f"{KEY}.jsonl.zst")],
+        check=True,
+    )
+    print(f"wrote {out_dir / (KEY + '.jsonl.zst')} in {round(time.time() - t0)}s")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

src/html_text.py

@@ -0,0 +1,23 @@
+"""Shared HTML → text for fetchers. Block tags become newlines; inline tags drop."""
+from __future__ import annotations
+import re
+from html import unescape
+
+_SCRIPT = re.compile(r"(?is)<(script|style)[^>]*>.*?</\1>")
+_BLOCK_END = re.compile(
+    r"(?i)</(p|div|h[1-6]|li|tr|table|ul|ol|blockquote)\s*>|<br\s*/?>"
+)
+_TAG = re.compile(r"<[^>]+>")
+
+
+def html_to_text(html: str) -> str:
+    if not html:
+        return ""
+    html = _SCRIPT.sub("", html)
+    html = _BLOCK_END.sub("\n", html)
+    html = _TAG.sub("", html)
+    text = unescape(html).replace("\r\n", "\n").replace("\r", "\n")
+    text = re.sub(r"[ \t]+", " ", text)
+    text = re.sub(r" *\n *", "\n", text)
+    text = re.sub(r"\n{3,}", "\n\n", text)
+    return text.strip()

src/scrub_entities.py

@@ -0,0 +1,160 @@
+"""PERSON-only NER replace for allowlisted web sources.
+
+FastPDN (ArkadiuszPawlak/fastpdn-ner-polish-pii, ONNX) tags person / street /
+city / org. We replace only PERSON* and expand to the whole word so a
+HerBERT hole cannot leave `[PII]ru[PII]`. Official and encyclopaedic sources
+are default-deny — names there are the content.
+
+Call after scrub_pii. Needs: pip install huggingface_hub tokenizers onnxruntime
+"""
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+
+from scrub_pii import PII_TAG
+
+MODEL_ID = "ArkadiuszPawlak/fastpdn-ner-polish-pii"
+PERSON_LABELS = frozenset({"PERSON", "PERSON_F", "PERSON_L"})
+NER_SOURCES = frozenset({
+    "european_hplt_v3_pl",
+    "govpl",
+    "samorzad_gov_pl",
+})
+_WORD = re.compile(r"[0-9A-Za-zÀ-ÿĄąĆćĘꣳŃńÓ󌜏źŻż'-]")
+
+_NER = None
+
+
+def source_allows_ner(source: str) -> bool:
+    return source in NER_SOURCES
+
+
+def _expand(text: str, start: int, end: int) -> tuple[int, int]:
+    while start > 0 and _WORD.match(text[start - 1]):
+        start -= 1
+    while end < len(text) and _WORD.match(text[end]):
+        end += 1
+    return start, end
+
+
+def apply_person_spans(text: str, spans: list[dict]) -> tuple[str, int]:
+    """Replace PERSON* spans with [PII]. City/org/street spans are ignored."""
+    kept: list[tuple[int, int]] = []
+    for s in spans:
+        if s.get("label") not in PERSON_LABELS:
+            continue
+        a, b = _expand(text, int(s["start"]), int(s["end"]))
+        if a < b:
+            kept.append((a, b))
+    kept.sort()
+    merged: list[tuple[int, int]] = []
+    for a, b in kept:
+        if merged and a <= merged[-1][1]:
+            merged[-1] = (merged[-1][0], max(merged[-1][1], b))
+        else:
+            merged.append((a, b))
+    out = text
+    for a, b in reversed(merged):
+        out = out[:a] + PII_TAG + out[b:]
+    return out, len(merged)
+
+
+def load_ner():
+    import onnxruntime as ort
+    from huggingface_hub import hf_hub_download
+    from tokenizers import Tokenizer
+
+    cfg = json.loads(Path(hf_hub_download(MODEL_ID, "config.json")).read_text())
+    tok = Tokenizer.from_file(hf_hub_download(MODEL_ID, "tokenizer.json"))
+    tok.enable_truncation(max_length=512)
+    sess = ort.InferenceSession(
+        hf_hub_download(MODEL_ID, "model_quantized.onnx"),
+        providers=["CPUExecutionProvider"],
+    )
+    return {
+        "sess": sess,
+        "tok": tok,
+        "id2label": {int(k): v for k, v in cfg["id2label"].items()},
+    }
+
+
+def _aggregate(text: str, labels: list[str], offsets, scores) -> list[dict]:
+    spans = []
+    cur = None
+    for lab, (start, end), score in zip(labels, offsets, scores):
+        if start == end or lab == "O" or "-" not in lab:
+            if cur:
+                spans.append(cur)
+                cur = None
+            continue
+        prefix, typ = lab.split("-", 1)
+        if cur and cur["label"] == typ and start <= cur["end"] + 1:
+            cur["end"] = end
+            cur["scores"].append(score)
+        elif prefix == "B" or cur is None or cur["label"] != typ:
+            if cur:
+                spans.append(cur)
+            cur = {"label": typ, "start": start, "end": end, "scores": [score]}
+        else:
+            cur["end"] = end
+            cur["scores"].append(score)
+    if cur:
+        spans.append(cur)
+    return [
+        {
+            "label": s["label"],
+            "text": text[s["start"]:s["end"]],
+            "score": round(sum(s["scores"]) / len(s["scores"]), 3),
+            "start": s["start"],
+            "end": s["end"],
+        }
+        for s in spans
+    ]
+
+
+def predict(ner, text: str) -> list[dict]:
+    import numpy as np
+
+    enc = ner["tok"].encode(text)
+    ids = np.array([enc.ids], dtype=np.int64)
+    mask = np.array([enc.attention_mask], dtype=np.int64)
+    logits = ner["sess"].run(
+        None,
+        {
+            "input_ids": ids,
+            "attention_mask": mask,
+            "token_type_ids": np.zeros_like(ids),
+        },
+    )[0][0]
+    pred = logits.argmax(axis=-1)
+    shift = logits - logits.max(axis=-1, keepdims=True)
+    exp = np.exp(shift)
+    prob = exp / exp.sum(axis=-1, keepdims=True)
+    labels = [ner["id2label"][int(i)] for i in pred]
+    scores = [float(prob[i, int(pred[i])]) for i in range(len(pred))]
+    return _aggregate(text, labels, enc.offsets, scores)
+
+
+def _ner():
+    global _NER
+    if _NER is None:
+        _NER = load_ner()
+    return _NER
+
+
+def scrub_entities(
+    text: str,
+    source: str,
+    spans: list[dict] | None = None,
+) -> tuple[str, dict[str, int]]:
+    """Return (text, {person: n}). No-op unless source is in NER_SOURCES."""
+    counts = {"person": 0}
+    if not text or not source_allows_ner(source):
+        return text, counts
+    if spans is None:
+        spans = predict(_ner(), text)
+    out, n = apply_person_spans(text, spans)
+    counts["person"] = n
+    return out, counts

src/scrub_pii.py

@@ -0,0 +1,180 @@
+"""Regex PII scrub for Polish web/official text.
+
+Replaces emails, phones, PESEL/NIP/REGON and account numbers in place so
+sentence structure survives. Names of public officials are left untouched —
+that is intentional, not a gap. Phones map to [Telefon]; everything else
+to [PII]. Checksums gate the national IDs so statute and case numbers stay.
+
+Call after HTML-to-text, before the parquet is written.
+"""
+from __future__ import annotations
+import datetime as dt
+import re
+
+PHONE_TAG = "[Telefon]"
+PII_TAG = "[PII]"
+COUNTS = ("email", "phone", "pesel", "nip", "regon", "account")
+
+# Mobile + geographic area codes (2-digit national prefix after trunk 0 / +48).
+_PL_PREFIX = {
+    "12", "13", "14", "15", "16", "17", "18", "22", "23", "24", "25", "29",
+    "32", "33", "34", "39", "41", "42", "43", "44", "45", "46", "48",
+    "50", "51", "52", "53", "54", "55", "56", "57", "58", "59",
+    "60", "61", "62", "63", "65", "66", "67", "68", "69",
+    "70", "71", "72", "73", "74", "75", "76", "77", "78", "79",
+    "80", "81", "82", "83", "84", "85", "86", "87", "88", "89",
+    "91", "94", "95",
+}
+
+_EMAIL_RE = re.compile(r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b")
+# Optional PL, then 26 digits with short space/tab/hyphen gaps (invoice style).
+_ACCOUNT_RE = re.compile(r"\b(?:PL[ \t-]*)?(?:\d[ \t-]*){25}\d\b", re.I)
+_REGON14_RE = re.compile(r"\b\d{14}\b")
+_PESEL_RE = re.compile(r"\b\d{11}\b")
+_NIP_DASH_RE = re.compile(r"\b\d{3}[-\s]\d{3}[-\s]\d{2}[-\s]\d{2}\b")
+_NIP_RE = re.compile(r"\b\d{10}\b")
+_REGON9_RE = re.compile(r"\b\d{9}\b")
+# Separators are short and local: one newline *or* a few punct/spaces.
+# Letters and blank lines break the match so body text is not swallowed.
+_SEP = r"(?:[ \t.\-()\u2013\u2014]{0,3}|\n)"
+_PHONE_RE = re.compile(
+    r"(?<!\d)(?:(?:\+|00)[ \t]*48" + _SEP + r")?"
+    r"(?:\(0?\d{2,3}\)" + _SEP + r")?"
+    r"\d(?:" + _SEP + r"\d){6,14}"
+)
+
+
+def _digits(s: str) -> str:
+    return re.sub(r"\D", "", s)
+
+
+def _pesel_ok(d: str) -> bool:
+    if len(d) != 11 or not d.isdigit():
+        return False
+    weights = (1, 3, 7, 9, 1, 3, 7, 9, 1, 3)
+    check = sum(w * int(x) for w, x in zip(weights, d[:-1]))
+    if str((10 - check % 10) % 10) != d[-1]:
+        return False
+    yy, mm, dd = int(d[0:2]), int(d[2:4]), int(d[4:6])
+    century = {0: 1900, 1: 2000, 2: 2100, 3: 2200, 4: 1800}.get(mm // 20)
+    if century is None:
+        return False
+    try:
+        dt.date(century + yy, mm % 20, dd)
+    except ValueError:
+        return False
+    return True
+
+
+def _nip_ok(d: str) -> bool:
+    if len(d) != 10 or not d.isdigit():
+        return False
+    weights = (6, 5, 7, 2, 3, 4, 5, 6, 7)
+    rem = sum(w * int(x) for w, x in zip(weights, d[:-1])) % 11
+    return rem != 10 and rem == int(d[-1])
+
+
+def _regon_ok(d: str) -> bool:
+    if not d.isdigit() or len(d) not in (9, 14):
+        return False
+    weights = ((8, 9, 2, 3, 4, 5, 6, 7) if len(d) == 9
+               else (2, 4, 8, 5, 0, 9, 7, 3, 6, 1, 2, 4, 8))
+    rem = sum(w * int(x) for w, x in zip(weights, d[:-1])) % 11
+    if rem == 10:
+        rem = 0
+    return rem == int(d[-1])
+
+
+def _iban_ok(raw: str) -> bool:
+    compact = re.sub(r"[\s-]+", "", raw).upper()
+    if compact.isdigit() and len(compact) == 26:
+        compact = "PL" + compact
+    if not re.fullmatch(r"PL\d{26}", compact):
+        return False
+    rearranged = compact[4:] + compact[:4]
+    nums = "".join(str(ord(c) - 55) if c.isalpha() else c for c in rearranged)
+    return int(nums) % 97 == 1
+
+
+def _pl_national_ok(d: str) -> bool:
+    return len(d) == 9 and d.isdigit() and d[:2] in _PL_PREFIX
+
+
+def _phone_ok(raw: str) -> bool:
+    s = raw.strip()
+    if re.fullmatch(r"\d{4}[-./]\d{2}[-./]\d{2}", s):
+        return False
+    if re.fullmatch(r"\d{2}-\d{3}", s):  # postal code
+        return False
+    # Ministry / court file numbers: BPRM.4820.2.3.2020, LUB-OMK.601.1.2024.3
+    if s.count(".") >= 3 or (s.count(".") >= 1 and re.search(r"20\d{2}", s)):
+        return False
+    if re.search(r"\d{1,2}[-./]\d{1,2}[-./](?:19|20)\d{2}", s):
+        return False
+    d = _digits(raw)
+    if d.startswith("00"):
+        d = d[2:]
+    if d.startswith("48") and len(d) >= 11:
+        rest = d[2:]
+        if rest.startswith("0"):
+            rest = rest[1:]
+        return _pl_national_ok(rest)
+    if d.startswith("0") and len(d) == 11 and d[:2] in {"01", "02", "07"}:
+        return True
+    if d.startswith("0") and len(d) >= 10:
+        return _pl_national_ok(d.lstrip("0"))
+    return _pl_national_ok(d)
+
+
+def _replace_checked(text: str, pattern: re.Pattern, tag: str, ok) -> tuple[str, int]:
+    n = 0
+
+    def _sub(m):
+        nonlocal n
+        if not ok(m.group(0)):
+            return m.group(0)
+        n += 1
+        return tag
+
+    return pattern.sub(_sub, text), n
+
+
+def _replace_phones(text: str) -> tuple[str, int]:
+    n = 0
+    out = []
+    pos = 0
+    while True:
+        m = _PHONE_RE.search(text, pos)
+        if not m:
+            out.append(text[pos:])
+            break
+        if _phone_ok(m.group(0)):
+            out.append(text[pos:m.start()])
+            out.append(PHONE_TAG)
+            n += 1
+            pos = m.end()
+        else:
+            out.append(text[pos:m.start() + 1])
+            pos = m.start() + 1
+    return "".join(out), n
+
+
+def scrub_pii(text: str) -> tuple[str, dict[str, int]]:
+    """Return (scrubbed_text, per-kind replacement counts). Idempotent."""
+    counts = {k: 0 for k in COUNTS}
+    if not text:
+        return text, counts
+
+    # Longest / most specific first so a 26-digit account is not sliced
+    # into REGON / PESEL / NIP / phone. Checksums live in the replace callback.
+    text, counts["account"] = _replace_checked(text, _ACCOUNT_RE, PII_TAG, _iban_ok)
+    text, n14 = _replace_checked(text, _REGON14_RE, PII_TAG, _regon_ok)
+    text, n9 = _replace_checked(text, _REGON9_RE, PII_TAG, _regon_ok)
+    counts["regon"] = n14 + n9
+    text, counts["pesel"] = _replace_checked(text, _PESEL_RE, PII_TAG, _pesel_ok)
+    text, n_dash = _replace_checked(text, _NIP_DASH_RE, PII_TAG, lambda s: _nip_ok(_digits(s)))
+    text, n_plain = _replace_checked(text, _NIP_RE, PII_TAG, _nip_ok)
+    counts["nip"] = n_dash + n_plain
+    text, counts["email"] = _replace_checked(text, _EMAIL_RE, PII_TAG, lambda _: True)
+    text, counts["phone"] = _replace_phones(text)
+    return text, counts

src/sources.py

@@ -99,6 +99,25 @@ SOURCES = {
         "created": "2023-01-01, 2026-07-03",
         "is_ocr": False,
     },
+    "sejm_interpellations": {
+        "file_key": "sejm_interpellations",
+        "pretty": "Sejm interpellations and written questions (terms 7–10)",
+        "license": "public-domain (official documents)",
+        "license_spdx": "LicenseRef-Polish-Official-Documents",
+        "traceable": "Official parliamentary materials excluded from copyright "
+                     "under Polish Copyright Act art. 4(2); reusable under "
+                     "the Polish Open Data Act arts. 2(12), 5, 14 and 17.",
+        "upstream": "https://api.sejm.gov.pl/",
+        "provenance": "Fetched from api.sejm.gov.pl HTML body endpoints by "
+                      "src/fetch_sejm_interpellations.py (interpellations + "
+                      "writtenQuestions, terms 7–10). Header chrome stripped into "
+                      "meta; attachment-only and keyless replies skipped; "
+                      "src/scrub_pii.py applied before jsonl write.",
+        "domain": "political/written",
+        "created": "2011-11-08, 2026-09-04",
+        "is_ocr": False,
+        "custom_datasheet": True,
+    },
     "parlamint_pl": {
         "file_key": "parlamint_pl",
         "pretty": "ParlaMint-PL (parliamentary debates, 2015-2022)",
@@ -337,7 +356,9 @@ SOURCES = {
                       "min 400 chars / 80 words, boilerplate/adult/legalish drop, length cap "
                       "120k chars, CJK-mojibake drop, wikipedia/wikisource/wikimedia + file-host "
                       "domains excluded, per-domain cap. Phone->[Telefon] / email+national-ID->[PII] "
-                      "PII-scrub (v12b, independent dual-lens verify). Token counts via tiktoken cl100k.",
+                      "via src/scrub_pii.py (in-tree; supersedes the out-of-repo v12b pass); "
+                      "PERSON mentions → [PII] via src/scrub_entities.py on this web shard only. "
+                      "Token counts via tiktoken cl100k.",
         "domain": "web",
         "created": "2012-01-01, 2024-12-31",
         "is_ocr": False,

src/test_scrub_entities.py

@@ -0,0 +1,112 @@
+"""PERSON-only NER replace: allowlist + whole-word guard. No model download."""
+import sys
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from scrub_entities import (
+    NER_SOURCES,
+    apply_person_spans,
+    source_allows_ner,
+    scrub_entities,
+)
+
+SEJM = (
+    "Marszałek Sejmu Szymon Hołownia otworzył posiedzenie. "
+    "Głos zabrał poseł Donald Tusk w imieniu Klubu Koalicja Obywatelska."
+)
+HRUB = "Hrubieszów położony w województwie lubelskim."
+
+
+def _span(label, text, start, end=None):
+    end = end if end is not None else start + len(text)
+    return {"label": label, "text": text, "start": start, "end": end, "score": 1.0}
+
+
+class AllowlistTest(unittest.TestCase):
+    def test_web_sources_allowed(self):
+        for key in ("european_hplt_v3_pl", "govpl", "samorzad_gov_pl"):
+            self.assertTrue(source_allows_ner(key), key)
+        self.assertEqual(
+            NER_SOURCES,
+            frozenset({"european_hplt_v3_pl", "govpl", "samorzad_gov_pl"}),
+        )
+
+    def test_official_sources_blocked(self):
+        for key in (
+            "parlamint_pl", "sejm_api", "sejm_interpellations",
+            "parliamentary", "eurlex", "dziennik_ustaw", "wikipedia",
+        ):
+            self.assertFalse(source_allows_ner(key), key)
+
+    def test_blocked_source_does_not_replace_even_with_spans(self):
+        spans = [_span("PERSON", "Szymon Hołownia", SEJM.index("Szymon Hołownia"))]
+        out, counts = scrub_entities(SEJM, source="parlamint_pl", spans=spans)
+        self.assertEqual(out, SEJM)
+        self.assertIn("Szymon Hołownia", out)
+        self.assertEqual(counts["person"], 0)
+
+    def test_blocked_sejm_api_same(self):
+        spans = [_span("PERSON", "Donald Tusk", SEJM.index("Donald Tusk"))]
+        out, counts = scrub_entities(SEJM, source="sejm_api", spans=spans)
+        self.assertEqual(out, SEJM)
+        self.assertEqual(counts["person"], 0)
+
+
+class ApplyPersonSpansTest(unittest.TestCase):
+    def test_person_becomes_pii_keeps_sentence(self):
+        text = "Kontakt: Anna Nowak, ul. 3 Maja."
+        spans = [_span("PERSON", "Anna Nowak", text.index("Anna Nowak"))]
+        out, n = apply_person_spans(text, spans)
+        self.assertEqual(n, 1)
+        self.assertIn("[PII]", out)
+        self.assertNotIn("Anna Nowak", out)
+        self.assertIn("Kontakt:", out)
+        self.assertIn("ul. 3 Maja.", out)
+
+    def test_city_and_org_are_ignored(self):
+        text = HRUB + " Sony i Ministerstwo Finansów."
+        spans = [
+            _span("CITY", "H", 0, 1),
+            _span("CITY", "bieszów", 3, 10),
+            _span("ORG", "Sony", text.index("Sony")),
+            _span("ORG", "Ministerstwo Finansów", text.index("Ministerstwo")),
+        ]
+        out, n = apply_person_spans(text, spans)
+        self.assertEqual(n, 0)
+        self.assertEqual(out, text)
+        self.assertIn("Hrubieszów", out)
+
+    def test_gapped_person_subwords_expand_to_whole_word(self):
+        # Same hole as Hrubieszów: middle letters tagged O.
+        text = "Hrubieszów"
+        spans = [
+            _span("PERSON", "H", 0, 1),
+            _span("PERSON", "bieszów", 3, 10),
+        ]
+        out, n = apply_person_spans(text, spans)
+        self.assertEqual(n, 1)
+        self.assertEqual(out, "[PII]")
+        self.assertNotIn("ru", out)
+
+    def test_partial_person_expands_to_word(self):
+        text = "Widziałem Kowalskiego wczoraj."
+        spans = [_span("PERSON", "Kowal", text.index("Kowal"), text.index("Kowal") + 5)]
+        out, n = apply_person_spans(text, spans)
+        self.assertEqual(n, 1)
+        self.assertNotIn("Kowalskiego", out)
+        self.assertEqual(out, "Widziałem [PII] wczoraj.")
+
+    def test_allowed_source_uses_injected_spans(self):
+        text = "Zgłosiła to Anna Nowak."
+        spans = [_span("PERSON", "Anna Nowak", text.index("Anna Nowak"))]
+        out, counts = scrub_entities(
+            text, source="european_hplt_v3_pl", spans=spans,
+        )
+        self.assertEqual(counts["person"], 1)
+        self.assertNotIn("Anna Nowak", out)
+
+
+if __name__ == "__main__":
+    unittest.main()

src/test_scrub_pii.py

@@ -0,0 +1,245 @@
+"""TDD contract for regex PII scrub (email, phone, PESEL/NIP/REGON, account)."""
+import sys
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from scrub_pii import scrub_pii
+
+# Checksum-valid fixtures (not live identifiers of private people).
+PESEL = "44051401458"
+NIP = "1234563218"
+REGON9 = "123456785"
+REGON14 = "12345678512347"
+IBAN = "PL61109010140000071219812874"
+
+
+class ScrubPiiTest(unittest.TestCase):
+    def _scrub(self, text):
+        return scrub_pii(text)
+
+    def test_email_becomes_pii(self):
+        out, counts = self._scrub("Pisz na jan.kowalski@example.com dziś.")
+        self.assertIn("[PII]", out)
+        self.assertNotIn("jan.kowalski@example.com", out)
+        self.assertEqual(counts["email"], 1)
+        self.assertIn("Pisz na", out)
+        self.assertIn("dziś.", out)
+
+    def test_mobile_and_grouped_phone_become_telefon(self):
+        out, counts = self._scrub("Zadzwoń 501 234 567 albo 501-234-567.")
+        self.assertEqual(out.count("[Telefon]"), 2)
+        self.assertNotIn("501", out)
+        self.assertEqual(counts["phone"], 2)
+
+    def test_leading_zero_landline(self):
+        out, counts = self._scrub("Siedziba: 022 123 45 67 w Warszawie.")
+        self.assertIn("[Telefon]", out)
+        self.assertNotIn("022", out)
+        self.assertEqual(counts["phone"], 1)
+
+    def test_plus48_paren(self):
+        out, counts = self._scrub("Kontakt: +48 (22) 123-45-67.")
+        self.assertIn("[Telefon]", out)
+        self.assertNotIn("+48", out)
+        self.assertNotIn("123-45-67", out)
+        self.assertEqual(counts["phone"], 1)
+
+    def test_dzwon_label_family(self):
+        out, counts = self._scrub("dzwoń: 601234567 lub tel. 602-234-567")
+        self.assertEqual(counts["phone"], 2)
+        self.assertNotIn("601234567", out)
+        self.assertNotIn("602-234-567", out)
+
+    def test_newline_over_span(self):
+        out, counts = self._scrub("tel.\n+48\n501\n234\n567\nproszę dzwonić")
+        self.assertIn("[Telefon]", out)
+        self.assertEqual(counts["phone"], 1)
+        self.assertNotIn("501", out)
+
+    def test_foreign_uk_bare(self):
+        out, counts = self._scrub("London office 020 7946 0958 weekday mornings.")
+        self.assertIn("[Telefon]", out)
+        self.assertNotIn("7946", out)
+        self.assertEqual(counts["phone"], 1)
+
+    def test_pesel_nip_regon_iban(self):
+        text = (
+            f"PESEL {PESEL}, NIP {NIP}, REGON {REGON9} / {REGON14}, "
+            f"konto {IBAN}."
+        )
+        out, counts = self._scrub(text)
+        self.assertNotIn(PESEL, out)
+        self.assertNotIn(NIP, out)
+        self.assertNotIn(REGON14, out)
+        self.assertNotIn(IBAN, out)
+        self.assertEqual(out.count("[PII]"), 5)
+        self.assertEqual(counts["pesel"], 1)
+        self.assertEqual(counts["nip"], 1)
+        self.assertEqual(counts["regon"], 2)
+        self.assertEqual(counts["account"], 1)
+
+    def test_nip_with_dashes(self):
+        out, counts = self._scrub("NIP 123-456-32-18 na fakturze.")
+        self.assertIn("[PII]", out)
+        self.assertNotIn("123-456-32-18", out)
+        self.assertEqual(counts["nip"], 1)
+
+    def test_invalid_eleven_digits_are_not_pesel(self):
+        # Same length as PESEL, fails checksum — statute / case-like numbers stay.
+        bogus = "44051401457"
+        out, counts = self._scrub(f"Sygnatura {bogus} pozostaje.")
+        self.assertIn(bogus, out)
+        self.assertEqual(counts["pesel"], 0)
+
+    def test_dates_and_case_numbers_survive(self):
+        text = "Wyrok z 2018-03-22, sygn. II K 336/17, art. 4 pkt 2."
+        out, counts = self._scrub(text)
+        self.assertEqual(out, text)
+        self.assertEqual(sum(counts.values()), 0)
+
+    def test_official_names_stay(self):
+        text = "Poseł Jan Kowalski złożył interpelację w Sejmie RP."
+        out, counts = self._scrub(text)
+        self.assertEqual(out, text)
+        self.assertEqual(sum(counts.values()), 0)
+
+    def test_idempotent(self):
+        once, _ = self._scrub(f"mail a@b.pl tel +48 501 234 567 PESEL {PESEL}")
+        twice, counts = self._scrub(once)
+        self.assertEqual(once, twice)
+        self.assertEqual(sum(counts.values()), 0)
+
+    def test_postal_code_and_krs_survive(self):
+        text = "Kod 02-123 Warszawa, KRS 0000123456, kwota 500,00 zł."
+        out, counts = self._scrub(text)
+        self.assertEqual(out, text)
+        self.assertEqual(counts["phone"], 0)
+        self.assertEqual(sum(counts.values()), 0)
+
+    def test_kw_and_postal_range_survive(self):
+        text = "KW KR1P/00012345/6, kod 00-950, okres 2020-2024."
+        out, counts = self._scrub(text)
+        self.assertEqual(out, text)
+        self.assertEqual(counts["phone"], 0)
+
+    def test_newline_phone_does_not_consume_unrelated_text(self):
+        text = "tel.\nW sprawie art. 5\nproszę dzwonić 501 234 567."
+        out, counts = self._scrub(text)
+        self.assertIn("W sprawie art. 5", out)
+        self.assertIn("[Telefon]", out)
+        self.assertEqual(counts["phone"], 1)
+        self.assertNotIn("501", out)
+
+    def test_iban_without_pl_prefix(self):
+        bare_iban = "61109010140000071219812874"
+        out, counts = self._scrub(f"Rachunek nr {bare_iban}")
+        self.assertNotIn(bare_iban, out)
+        self.assertEqual(counts["account"], 1)
+        self.assertEqual(counts["phone"], 0)
+
+    def test_spaced_iban_and_nip_prefixes(self):
+        spaced = "61 1090 1014 0000 0712 1981 2874"
+        text = f"nr rachunku: {spaced}; NIP:{NIP}; NIP-{NIP}."
+        out, counts = self._scrub(text)
+        self.assertNotIn("1090", out)
+        self.assertNotIn(NIP, out)
+        self.assertEqual(counts["account"], 1)
+        self.assertEqual(counts["nip"], 2)
+        self.assertEqual(counts["phone"], 0)
+
+    def test_execution_order_precedence(self):
+        text = f"Przelew na {IBAN}."
+        out, counts = self._scrub(text)
+        self.assertNotIn("611090", out)
+        self.assertEqual(counts["account"], 1)
+        self.assertEqual(counts["pesel"], 0)
+        self.assertEqual(counts["phone"], 0)
+        self.assertEqual(counts["regon"], 0)
+
+    def test_complex_email_formats(self):
+        addr = "jan.k+alert@pwr.edu.pl"
+        out, counts = self._scrub(f"Kontakt: {addr}")
+        self.assertNotIn(addr, out)
+        self.assertEqual(counts["email"], 1)
+        nested = "jan.kowalski+test@subdomain.example.pwr.edu.pl"
+        out, counts = self._scrub(nested)
+        self.assertNotIn(nested, out)
+        self.assertEqual(counts["email"], 1)
+
+    def test_pii_inside_brackets_or_quotes(self):
+        out, counts = self._scrub(f'("email: jan@ex.com", PESEL: "{PESEL}")')
+        self.assertNotIn("jan@ex.com", out)
+        self.assertNotIn(PESEL, out)
+        self.assertEqual(counts["email"], 1)
+        self.assertEqual(counts["pesel"], 1)
+
+    def test_iban_with_mixed_dashes_and_spaces(self):
+        # Same MOD-97 number as IBAN, invoice-style PL + space + hyphen groups.
+        mixed_iban = "PL 61-1090-1014-0000-0712-1981-2874"
+        out, counts = self._scrub(f"Rachunek: {mixed_iban}")
+        self.assertNotIn("1090", out)
+        self.assertNotIn("0712", out)
+        self.assertEqual(counts["account"], 1)
+        self.assertEqual(counts["phone"], 0)
+
+    def test_nip_and_regon_with_colons_and_newlines(self):
+        text = f"NIP:\n{NIP}\nREGON:\n{REGON9}"
+        out, counts = self._scrub(text)
+        self.assertNotIn(NIP, out)
+        self.assertNotIn(REGON9, out)
+        self.assertEqual(counts["nip"], 1)
+        self.assertEqual(counts["regon"], 1)
+        self.assertIn("NIP:", out)
+        self.assertIn("REGON:", out)
+
+    def test_postal_code_does_not_trigger_phone(self):
+        text = "Adres: ul. Wiejska 4, 00-902 Warszawa."
+        out, counts = self._scrub(text)
+        self.assertEqual(out, text)
+        self.assertEqual(counts["phone"], 0)
+
+    def test_newline_phone_is_bounded(self):
+        text = "tel.\n\n\nW sprawie umowy proszę dzwonić pod 501 234 567."
+        out, counts = self._scrub(text)
+        self.assertIn("W sprawie umowy", out)
+        self.assertEqual(counts["phone"], 1)
+        self.assertNotIn("501", out)
+
+    def test_datetime_stamps_are_not_phones(self):
+        # HPLT leftover: DD-MM-YYYY HH:MM looks like a leading-0 landline.
+        text = "wpis - 08-03-2020 13:27 | 08-07-2014 16:15:00 na liście."
+        out, counts = self._scrub(text)
+        self.assertEqual(out, text)
+        self.assertEqual(counts["phone"], 0)
+
+    def test_en_dash_grouped_phone(self):
+        out, counts = self._scrub("sekretariat tel. 65 544–47-32 od poniedziałku")
+        self.assertIn("[Telefon]", out)
+        self.assertNotIn("544", out)
+        self.assertEqual(counts["phone"], 1)
+
+    def test_ministry_file_numbers_are_not_phones(self):
+        # Real Sejm sample FPs: dotted znak / attachment stems look like landlines.
+        text = (
+            "decyzja (znak: BPRM.4820.2.3.2020). "
+            "pismem znak: DF.III.8200.12.2020.PP. "
+            "Zalacznik do pisma LUB-OMK.601.1.2024.3.pdf"
+        )
+        out, counts = self._scrub(text)
+        self.assertEqual(out, text)
+        self.assertEqual(counts["phone"], 0)
+
+    def test_iban_takes_precedence_over_substring_matches(self):
+        text = f"Numer konta do wpłaty: {IBAN}"
+        out, counts = self._scrub(text)
+        self.assertEqual(counts["account"], 1)
+        self.assertEqual(counts["pesel"], 0)
+        self.assertEqual(counts["phone"], 0)
+        self.assertEqual(counts["regon"], 0)
+        self.assertEqual(counts["nip"], 0)
+
+
+if __name__ == "__main__":
+    unittest.main()

src/test_sejm_interpellations_contract.py

@@ -0,0 +1,120 @@
+"""TDD contract for Sejm interpellations / written-questions ingestion."""
+import sys
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from fetch_sejm_interpellations import (
+    MIN_CHARS,
+    normalize_document,
+    should_fetch_reply,
+)
+
+BODY = (
+    "Szanowny Panie Ministrze! " + ("Ogrody działkowe wymagają ochrony prawnej. " * 12)
+)
+
+Q_HTML = f"""<!DOCTYPE html>
+<html lang="pl"><head><title>Interpelacja w sprawie ogrodów</title></head>
+<body>
+<h1>Interpelacja nr 1</h1>
+<p class="int-recipient">do ministra rozwoju i technologii</p>
+<p class="int-title">w sprawie sytuacji w rodzinnych ogrodach działkowych</p>
+<p class="intAuthor">Zgłaszający: Katarzyna Osos</p>
+<p class="intDateTresc">Data wpływu: 15-11-2023</p>
+<p>{BODY}</p>
+<p>Podstawa: decyzja (znak: BPRM.4820.2.3.2020).</p>
+</body></html>
+"""
+
+R_HTML = f"""<!DOCTYPE html>
+<html lang="pl"><head><title>Odpowiedź na interpelację w sprawie ogrodów</title></head>
+<body>
+<h1>Odpowiedź na interpelację nr 8</h1>
+<p class="int-title">w sprawie tzw. specustawy</p>
+<p class="intAuthor">Odpowiadający: minister rodziny Agnieszka Dziemianowicz-Bąk</p>
+<p class="intDate">Warszawa, 22-02-2024</p>
+<p>Szanowny Panie Marszałku, {"odpowiadając informuję jak poniżej. " * 15}</p>
+</body></html>
+"""
+
+STUB_HTML = """<!DOCTYPE html>
+<html><head><title>Odpowiedź</title></head>
+<body>
+<h1>Odpowiedź na interpelację nr 806</h1>
+<p class="int-title">w sprawie warunków sanitarnych</p>
+<p class="intAuthor">Odpowiadający: sekretarz stanu Krzysztof Kukucki</p>
+<p class="intDate">Warszawa, 20-02-2024</p>
+<p>Treść odpowiedzi znajduje się w załączniku.</p>
+<p>Załączniki</p>
+<p>LUB-OMK.601.1.2024.3.pdf</p>
+</body></html>
+"""
+
+ITEM = {
+    "num": 1,
+    "term": 10,
+    "title": "Interpelacja w sprawie sytuacji w rodzinnych ogrodach działkowych",
+    "receiptDate": "2023-11-15",
+    "from": ["277"],
+    "to": ["minister rozwoju i technologii"],
+}
+
+
+class SejmInterpellationsContractTest(unittest.TestCase):
+    def test_should_fetch_reply_requires_key_and_html(self):
+        self.assertTrue(should_fetch_reply({"key": "D2QJNB", "onlyAttachment": False}))
+        self.assertFalse(should_fetch_reply({"key": "X", "onlyAttachment": True}))
+        self.assertFalse(should_fetch_reply({"onlyAttachment": False}))
+        self.assertFalse(should_fetch_reply({"key": None, "onlyAttachment": False}))
+        self.assertFalse(should_fetch_reply({}))
+
+    def test_question_strips_header_keeps_body_and_file_number(self):
+        row = normalize_document("interpellation", ITEM, Q_HTML)
+        self.assertIsNotNone(row)
+        self.assertEqual(set(row), {"text", "meta"})
+        self.assertNotIn("<", row["text"])
+        self.assertNotIn("Interpelacja nr 1", row["text"])
+        self.assertNotIn("Zgłaszający:", row["text"])
+        self.assertNotIn("Data wpływu:", row["text"])
+        self.assertNotIn("do ministra rozwoju", row["text"])
+        self.assertIn("Ogrody działkowe", row["text"])
+        self.assertIn("BPRM.4820.2.3.2020", row["text"])  # not a phone
+        self.assertGreaterEqual(len(row["text"]), MIN_CHARS)
+        self.assertEqual(row["meta"]["num"], 1)
+        self.assertEqual(row["meta"]["term"], 10)
+        self.assertEqual(row["meta"]["kind"], "interpellation")
+        self.assertEqual(row["meta"]["author"], "Katarzyna Osos")
+        self.assertTrue(row["meta"]["url"].endswith("/interpellations/1/body"))
+
+    def test_reply_strips_header_and_records_key(self):
+        reply = {"key": "D2QJNB", "from": "Minister Agnieszka Dziemianowicz-Bąk",
+                 "receiptDate": "2024-02-22", "onlyAttachment": False}
+        item = {**ITEM, "num": 8}
+        row = normalize_document("interpellation_reply", item, R_HTML, reply=reply)
+        self.assertIsNotNone(row)
+        self.assertNotIn("Odpowiedź na interpelację nr 8", row["text"])
+        self.assertNotIn("Odpowiadający:", row["text"])
+        self.assertNotIn("Warszawa, 22-02-2024", row["text"])
+        self.assertIn("Szanowny Panie Marszałku", row["text"])
+        self.assertEqual(row["meta"]["kind"], "interpellation_reply")
+        self.assertEqual(row["meta"]["reply_key"], "D2QJNB")
+        self.assertIn("Dziemianowicz", row["meta"]["author"])
+        self.assertTrue(row["meta"]["url"].endswith("/interpellations/8/reply/D2QJNB/body"))
+
+    def test_attachment_stub_is_rejected(self):
+        reply = {"key": "ABC", "from": "X", "receiptDate": "2024-02-20"}
+        self.assertIsNone(normalize_document(
+            "interpellation_reply", {**ITEM, "num": 806}, STUB_HTML, reply=reply
+        ))
+
+    def test_written_question_url(self):
+        item = {**ITEM, "title": "Zapytanie w sprawie świadczeń"}
+        row = normalize_document("written_question", item, Q_HTML)
+        self.assertTrue(row["meta"]["url"].endswith("/writtenQuestions/1/body"))
+        self.assertEqual(row["meta"]["kind"], "written_question")
+
+
+if __name__ == "__main__":
+    unittest.main()