Move PII scrubbing to SlayerLab/NERGAL (#38)

- Move PII scrubbing out of the corpus repo to SlayerLab/NERGAL. (12f7612e6c5f2f661c1d4d4617a5d26ff9883127)

AGENTS.md

@@ -114,12 +114,11 @@ What a fetcher should do to `text` before writing the `.jsonl.zst`:
   source (license footers, institutional disclaimers, "Pokaż odpowiedź"-style UI
   chrome) should be detected by frequency across the shard and removed, not
   hand-listed.
-- **Personal data**: scrub before the parquet is written, not after. At minimum
-  email addresses, phone numbers, and national identifiers (PESEL, NIP, REGON,
-  account numbers). Replace with a stable placeholder (`[PII]`, `[Telefon]`)
-  rather than deleting, so sentence structure survives. Names of public
-  officials acting in an official capacity are not PII and should stay —
-  removing them would gut parliamentary and judicial sources.
+- **Personal data**: do not keep a scrubber in this repo. Apply
+  [`SlayerLab/NERGAL`](https://huggingface.co/SlayerLab/NERGAL) before the
+  parquet is written (frozen regex ∪ model; placeholders `[PII]` / `[Telefon]`).
+  Names of public officials acting in an official capacity are not PII and
+  should stay — removing them would gut parliamentary and judicial sources.
 
 Two rules about all of the above:
 

src/clean_hplt_v3.py

@@ -17,8 +17,6 @@ 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"
@@ -129,7 +127,6 @@ 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
@@ -174,11 +171,6 @@ 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
@@ -202,7 +194,6 @@ 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_sejm_api.py

@@ -17,7 +17,6 @@ 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"
@@ -84,7 +83,6 @@ 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

@@ -7,7 +7,7 @@ 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.
+lives in meta, not text. PII scrubbing is SlayerLab/NERGAL, not this repo.
 
 Usage:
   python3 src/fetch_sejm_interpellations.py --out ~/speakleash
@@ -21,7 +21,6 @@ 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"
@@ -93,7 +92,6 @@ def extract_body(html: str) -> str:
 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]

src/pii_mixed_regression_cases.json

@@ -1,446 +0,0 @@
-{
-  "synthetic": true,
-  "policy": "Invented regression examples; no corpus excerpts or document references. Email and web domains use example.com. Phone/identifier values test syntax, not assignment; public emergency codes retain their literal semantics.",
-  "cases": [
-    {
-      "name": "vanity_phone",
-      "text": "Biuro Przykład, ☏ +1 202 555-TEST (8378), +1 202 555-0142.",
-      "mask": [
-        {
-          "start": 18,
-          "end": 40,
-          "text": "+1 202 555-TEST (8378)",
-          "label": "phone"
-        },
-        {
-          "start": 42,
-          "end": 57,
-          "text": "+1 202 555-0142",
-          "label": "phone"
-        }
-      ],
-      "preserve": []
-    },
-    {
-      "name": "email_space_inside_domain",
-      "text": "Kontakt: osoba@sub- domena.example.com.",
-      "mask": [
-        {
-          "start": 9,
-          "end": 38,
-          "text": "osoba@sub- domena.example.com",
-          "label": "pii"
-        }
-      ],
-      "preserve": []
-    },
-    {
-      "name": "shared_area_code_phone_pair",
-      "text": "Restauracja Przykład, ulica Przykładowa 12. ☎ (8426) 23-45-61, 23-45-62. Godziny 10.00-22.00.",
-      "mask": [
-        {
-          "start": 46,
-          "end": 61,
-          "text": "(8426) 23-45-61",
-          "label": "phone"
-        },
-        {
-          "start": 63,
-          "end": 71,
-          "text": "23-45-62",
-          "label": "phone"
-        }
-      ],
-      "preserve": [
-        {
-          "start": 81,
-          "end": 92,
-          "text": "10.00-22.00"
-        }
-      ]
-    },
-    {
-      "name": "email_domain_line_break",
-      "text": "Autor przykładowego artykułu (autor@poczta.\nexample.com).\nTytuł publikacji.",
-      "mask": [
-        {
-          "start": 30,
-          "end": 55,
-          "text": "autor@poczta.\nexample.com",
-          "label": "pii"
-        }
-      ],
-      "preserve": []
-    },
-    {
-      "name": "international_trunk_in_business_listing",
-      "text": "Kemping Przykład, +27 (0)13 234-5612 oferuje noclegi.\n\nKemping Testowy +27 (0)13 234-5613 ma basen.",
-      "mask": [
-        {
-          "start": 18,
-          "end": 36,
-          "text": "+27 (0)13 234-5612",
-          "label": "phone"
-        },
-        {
-          "start": 71,
-          "end": 89,
-          "text": "+27 (0)13 234-5613",
-          "label": "phone"
-        }
-      ],
-      "preserve": []
-    },
-    {
-      "name": "emergency_number_lists",
-      "text": "Biuro testowe, tel. 22 123-45-67, tel. alarmowe 997 i 112.\n\nStraż pożarna\ntel. 22 123-45-68, tel. alarmowe 998 i 112.",
-      "mask": [
-        {
-          "start": 48,
-          "end": 51,
-          "text": "997",
-          "label": "phone"
-        },
-        {
-          "start": 54,
-          "end": 57,
-          "text": "112",
-          "label": "phone"
-        },
-        {
-          "start": 107,
-          "end": 110,
-          "text": "998",
-          "label": "phone"
-        },
-        {
-          "start": 113,
-          "end": 116,
-          "text": "112",
-          "label": "phone"
-        }
-      ],
-      "preserve": []
-    },
-    {
-      "name": "emergency_directory_labels",
-      "text": "Numery telefonów\nW sytuacjach awaryjnych\nStraż pożarna: 122\nPolicja: 133\nRatunek: 144\nLekarz pogotowia ratunkowego: 141",
-      "mask": [
-        {
-          "start": 82,
-          "end": 85,
-          "text": "144",
-          "label": "phone"
-        },
-        {
-          "start": 116,
-          "end": 119,
-          "text": "141",
-          "label": "phone"
-        }
-      ],
-      "preserve": []
-    },
-    {
-      "name": "foreign_short_service_directory",
-      "text": "W przypadku pytań i problemów\nBiuro podróży Przykład: +43 (0)5 2345\nObsługa rzeczy znalezionych: +43 (0)1 23 456 78 23 456\nAwaria automatów: +43 (0)5 2345 67\nSiedziba administracji: +43 (0)1 23456\nInformacje można uzyskać dzwoniąc pod numer biura podróży +43 (0)5 2345.",
-      "mask": [
-        {
-          "start": 54,
-          "end": 67,
-          "text": "+43 (0)5 2345",
-          "label": "phone"
-        },
-        {
-          "start": 97,
-          "end": 122,
-          "text": "+43 (0)1 23 456 78 23 456",
-          "label": "phone"
-        },
-        {
-          "start": 141,
-          "end": 157,
-          "text": "+43 (0)5 2345 67",
-          "label": "phone"
-        },
-        {
-          "start": 182,
-          "end": 196,
-          "text": "+43 (0)1 23456",
-          "label": "phone"
-        },
-        {
-          "start": 255,
-          "end": 268,
-          "text": "+43 (0)5 2345",
-          "label": "phone"
-        }
-      ],
-      "preserve": []
-    },
-    {
-      "name": "email_space_after_at",
-      "text": "Faks: +81 23-456-7812, biuro@ sub.example.com. Godziny 09:00-18:00.",
-      "mask": [
-        {
-          "start": 23,
-          "end": 45,
-          "text": "biuro@ sub.example.com",
-          "label": "pii"
-        }
-      ],
-      "preserve": [
-        {
-          "start": 55,
-          "end": 66,
-          "text": "09:00-18:00"
-        }
-      ]
-    },
-    {
-      "name": "phone_symbol_with_foreign_area_code",
-      "text": "Punkt Przykład. ☎ (384) 234 - 56 - 71. Godziny 10:00-22:00.",
-      "mask": [
-        {
-          "start": 18,
-          "end": 37,
-          "text": "(384) 234 - 56 - 71",
-          "label": "phone"
-        }
-      ],
-      "preserve": [
-        {
-          "start": 47,
-          "end": 58,
-          "text": "10:00-22:00"
-        }
-      ]
-    },
-    {
-      "name": "phone_stops_before_street_number",
-      "text": "Restauracja Przykład, ☏ +86 574-2345-6712. 87 ulica Przykładowa. Opis lokalu.",
-      "mask": [
-        {
-          "start": 24,
-          "end": 41,
-          "text": "+86 574-2345-6712",
-          "label": "phone"
-        }
-      ],
-      "preserve": [
-        {
-          "start": 41,
-          "end": 45,
-          "text": ". 87"
-        }
-      ]
-    },
-    {
-      "name": "five_digit_helpline",
-      "text": "Informacje o usłudze.\n\nInfolinia Centrum Przykład (dla zgłoszeń produkcyjnych): 19 876\n\nDalszy opis usługi.",
-      "mask": [
-        {
-          "start": 80,
-          "end": 86,
-          "text": "19 876",
-          "label": "phone"
-        }
-      ],
-      "preserve": []
-    },
-    {
-      "name": "epuap_list_with_lub",
-      "text": "Skrytki ePUAP: /przyklad123/skrytka lub /przyklad123/SkrytkaESP, albo\nadres e-mail: biuro@example.com.",
-      "mask": [
-        {
-          "start": 15,
-          "end": 35,
-          "text": "/przyklad123/skrytka",
-          "label": "pii"
-        },
-        {
-          "start": 40,
-          "end": 63,
-          "text": "/przyklad123/SkrytkaESP",
-          "label": "pii"
-        },
-        {
-          "start": 84,
-          "end": 101,
-          "text": "biuro@example.com",
-          "label": "pii"
-        }
-      ],
-      "preserve": []
-    },
-    {
-      "name": "microcontroller_is_not_iban",
-      "text": "The test device uses the AD0227 microcontroller and transmits sample data.",
-      "mask": [],
-      "preserve": [
-        {
-          "start": 25,
-          "end": 51,
-          "text": "AD0227 microcontroller and"
-        }
-      ]
-    },
-    {
-      "name": "helpline_and_support_line_context",
-      "text": "Całodobowy telefon w sprawie pomocy – 116 789 oraz Linię Wsparcia dla Uczestników - 22 123 45 67.\n\nOsoby dzwoniące na numer 116 789 otrzymują informacje.",
-      "mask": [
-        {
-          "start": 38,
-          "end": 45,
-          "text": "116 789",
-          "label": "phone"
-        },
-        {
-          "start": 84,
-          "end": 96,
-          "text": "22 123 45 67",
-          "label": "phone"
-        },
-        {
-          "start": 124,
-          "end": 131,
-          "text": "116 789",
-          "label": "phone"
-        }
-      ],
-      "preserve": []
-    },
-    {
-      "name": "phone_range_suffix",
-      "text": "Centrum Przykład, ulica Testowa 12, telefon centrala: 048/ 234 56 71 do 73.\nDalszy opis działalności.",
-      "mask": [
-        {
-          "start": 54,
-          "end": 74,
-          "text": "048/ 234 56 71 do 73",
-          "label": "phone"
-        }
-      ],
-      "preserve": []
-    },
-    {
-      "name": "short_foreign_emergency_numbers",
-      "text": "Placówka Przykład, ☏ +49341 2345-6, numer bezpłatny: 110 (w nagłych wypadkach).\nPlacówka Testowa, ☏ +49341987-65432, bezpłatny: 110 (w nagłych wypadkach).",
-      "mask": [
-        {
-          "start": 53,
-          "end": 56,
-          "text": "110",
-          "label": "phone"
-        },
-        {
-          "start": 128,
-          "end": 131,
-          "text": "110",
-          "label": "phone"
-        }
-      ],
-      "preserve": []
-    },
-    {
-      "name": "blik_phone_contact",
-      "text": "Można przesłać środki Blikiem: 794 23 45 67 z dopiskiem Test.\n\nDalsze informacje.",
-      "mask": [
-        {
-          "start": 31,
-          "end": 43,
-          "text": "794 23 45 67",
-          "label": "phone"
-        }
-      ],
-      "preserve": []
-    },
-    {
-      "name": "phone_before_price",
-      "text": "Bar Przykład, ulica Testowa 12, ☎ +39552345671. 3,00 € za przekąskę. 9-19.",
-      "mask": [
-        {
-          "start": 34,
-          "end": 46,
-          "text": "+39552345671",
-          "label": "phone"
-        }
-      ],
-      "preserve": [
-        {
-          "start": 48,
-          "end": 54,
-          "text": "3,00 €"
-        },
-        {
-          "start": 69,
-          "end": 73,
-          "text": "9-19"
-        }
-      ]
-    },
-    {
-      "name": "url_query_digits_are_not_pesel",
-      "text": "https://example.com/article/?doing_wp_cron=1234567890.44051401458\n12345678901.\nPrzykładowy przypis.",
-      "mask": [],
-      "preserve": [
-        {
-          "start": 54,
-          "end": 65,
-          "text": "44051401458"
-        }
-      ]
-    },
-    {
-      "name": "six_digit_helpline",
-      "text": "Informacja o finansowaniu dla telefonu zaufania, 116 789, jest dostępna w raporcie.",
-      "mask": [
-        {
-          "start": 49,
-          "end": 56,
-          "text": "116 789",
-          "label": "phone"
-        }
-      ],
-      "preserve": []
-    },
-    {
-      "name": "foreign_mobile_dotted_format",
-      "text": "Ośrodek Przykład, ulica Testowa 12. Tel 075.2345671 Tel. komórkowy 347.2345671. Dalszy opis.",
-      "mask": [
-        {
-          "start": 67,
-          "end": 78,
-          "text": "347.2345671",
-          "label": "phone"
-        }
-      ],
-      "preserve": []
-    },
-    {
-      "name": "trademark_registration_is_not_pii",
-      "text": "Przykładowy znak towarowy o numerze R-234567 jest chroniony do 2027 roku.",
-      "mask": [],
-      "preserve": [
-        {
-          "start": 36,
-          "end": 44,
-          "text": "R-234567"
-        }
-      ]
-    },
-    {
-      "name": "ordinary_phone_keeps_phone_label",
-      "text": "Biuro Przykład, ☏ +1 202 555-0142, numer bezpłatny: +1 202 555-0143.",
-      "mask": [
-        {
-          "start": 52,
-          "end": 67,
-          "text": "+1 202 555-0143",
-          "label": "phone"
-        }
-      ],
-      "preserve": []
-    }
-  ]
-}

src/pii_wikivoyage_regression_cases.json

@@ -1,415 +0,0 @@
-{
-  "synthetic": true,
-  "policy": "Invented regression examples; no corpus excerpts or document references. Email and web domains use example.com. Phone/identifier values test syntax, not assignment; public emergency codes retain their literal semantics.",
-  "cases": [
-    {
-      "name": "wikivoyage_thai_dialling_and_fax_list",
-      "text": "Kontakt\n\nPlacówka Przykład\n\nBudynek 123-125, piętro 4\n\nUlica Testowa, 12345 Miasto\n\nStrona www: https://example.com/\n\nTelefony:\n\nCentrala placówki\n\n- dzwoniąc z Polski z tel. stacjonarnego 0066 2 234 5612\n\n- dzwoniąc z Polski z tel. komórkowego +66 2 234 5612\n\n- dzwoniąc z Tajlandii z tel. lokalnego 0 2 234 5612\n\nFax:\n\n- z Polski 0066 2 234 5613\n\n- z Tajlandii 0 2 234 5613\n\nAdresy e-mail:\n\nSekretariat: sekretariat@example.com\n\nBiuro: biuro@example.com\n\nInna placówka\n\nUlica Testowa 2, D - 12345 Miasto\n\nTelefon: +49 30 23 45 67 12\n\nFax: +49 30 23 45 67 13\n\nhttps://branch.example.com\n\nE-mail: kontakt@branch.example.com",
-      "mask": [
-        {
-          "start": 189,
-          "end": 204,
-          "text": "0066 2 234 5612",
-          "label": "phone"
-        },
-        {
-          "start": 245,
-          "end": 259,
-          "text": "+66 2 234 5612",
-          "label": "phone"
-        },
-        {
-          "start": 301,
-          "end": 313,
-          "text": "0 2 234 5612",
-          "label": "phone"
-        },
-        {
-          "start": 332,
-          "end": 347,
-          "text": "0066 2 234 5613",
-          "label": "phone"
-        },
-        {
-          "start": 363,
-          "end": 375,
-          "text": "0 2 234 5613",
-          "label": "phone"
-        },
-        {
-          "start": 406,
-          "end": 429,
-          "text": "sekretariat@example.com",
-          "label": "pii"
-        },
-        {
-          "start": 438,
-          "end": 455,
-          "text": "biuro@example.com",
-          "label": "pii"
-        },
-        {
-          "start": 516,
-          "end": 534,
-          "text": "+49 30 23 45 67 12",
-          "label": "phone"
-        },
-        {
-          "start": 541,
-          "end": 559,
-          "text": "+49 30 23 45 67 13",
-          "label": "phone"
-        },
-        {
-          "start": 597,
-          "end": 623,
-          "text": "kontakt@branch.example.com",
-          "label": "pii"
-        }
-      ],
-      "preserve": [
-        {
-          "start": 36,
-          "end": 43,
-          "text": "123-125"
-        },
-        {
-          "start": 70,
-          "end": 75,
-          "text": "12345"
-        },
-        {
-          "start": 489,
-          "end": 498,
-          "text": "D - 12345"
-        }
-      ]
-    },
-    {
-      "name": "wikivoyage_italian_restaurant_directory",
-      "text": "Restauracje:\nLokal Alfa, ulica Testowa 12, +39 0575-234561. 19:00-23:00. 15-30 EUR.\nLokal Beta, ulica Testowa 14, ☏ + 39-0575 23456. Opis restauracji.\nLokal Gamma, ulica Testowa 16, ☏ +39 0575234567. Menu za 25 lub 20 €.\nLokal Delta, ulica Testowa 18, ☏ +39 0575 23457. Oferta lokalu.\n\nNapoje\nLokal Epsilon, ulica Testowa 20, ☏ +39 057523458. 11:30-24:00. 15-30 EUR.\nLokal Zeta, ulica Testowa 22. 06:00-20:30. Opis przykładowej oferty.\nLokal Eta, ulica Testowa 24, +39 0575 234562. Opis lokalu.\n\nFestiwale",
-      "mask": [
-        {
-          "start": 116,
-          "end": 131,
-          "text": "+ 39-0575 23456",
-          "label": "phone"
-        },
-        {
-          "start": 184,
-          "end": 198,
-          "text": "+39 0575234567",
-          "label": "phone"
-        },
-        {
-          "start": 254,
-          "end": 268,
-          "text": "+39 0575 23457",
-          "label": "phone"
-        },
-        {
-          "start": 328,
-          "end": 341,
-          "text": "+39 057523458",
-          "label": "phone"
-        },
-        {
-          "start": 465,
-          "end": 480,
-          "text": "+39 0575 234562",
-          "label": "phone"
-        }
-      ],
-      "preserve": [
-        {
-          "start": 208,
-          "end": 219,
-          "text": "25 lub 20 €"
-        },
-        {
-          "start": 343,
-          "end": 354,
-          "text": "11:30-24:00"
-        },
-        {
-          "start": 397,
-          "end": 408,
-          "text": "06:00-20:30"
-        }
-      ]
-    },
-    {
-      "name": "wikivoyage_chinese_hotel_directory",
-      "text": "Hotel Alfa, ulica Testowa 12, ☏ +86 351 2345612.\nHotel Beta, 115 ulica Testowa. Pokoje z dostępem do sieci. Cena od 188¥.\nHotel Gamma, 99 ulica Testowa, +86 351 2345613.\n\nUmiarkowanie\nHotel Delta, ulica Testowa 14, ☏ +86 351 2345614, faks: +86 351 2345615.\nHotel Epsilon, ulica Testowa 16, ☏ +86 351 2345616, faks: +86 351 2345617.\nHotel Zeta, ulica Testowa 18, ☏ +86 351 2345618, faks: +86 351 2345619.\n\nEkskluzywnie\nHotel Eta, ulica Testowa 20, ☏ +86 351 2345621.\nHotel Theta, ulica Testowa 22, +86-21-23456712 wew. 1234, rezerwacja@example.com. 5-gwiazdkowy hotel z restauracją.\n\nKontakt",
-      "mask": [
-        {
-          "start": 153,
-          "end": 168,
-          "text": "+86 351 2345613",
-          "label": "phone"
-        },
-        {
-          "start": 217,
-          "end": 232,
-          "text": "+86 351 2345614",
-          "label": "phone"
-        },
-        {
-          "start": 240,
-          "end": 255,
-          "text": "+86 351 2345615",
-          "label": "phone"
-        },
-        {
-          "start": 292,
-          "end": 307,
-          "text": "+86 351 2345616",
-          "label": "phone"
-        },
-        {
-          "start": 315,
-          "end": 330,
-          "text": "+86 351 2345617",
-          "label": "phone"
-        },
-        {
-          "start": 364,
-          "end": 379,
-          "text": "+86 351 2345618",
-          "label": "phone"
-        },
-        {
-          "start": 387,
-          "end": 402,
-          "text": "+86 351 2345619",
-          "label": "phone"
-        },
-        {
-          "start": 449,
-          "end": 464,
-          "text": "+86 351 2345621",
-          "label": "phone"
-        },
-        {
-          "start": 497,
-          "end": 522,
-          "text": "+86-21-23456712 wew. 1234",
-          "label": "phone"
-        },
-        {
-          "start": 524,
-          "end": 546,
-          "text": "rezerwacja@example.com",
-          "label": "pii"
-        }
-      ],
-      "preserve": [
-        {
-          "start": 61,
-          "end": 78,
-          "text": "115 ulica Testowa"
-        },
-        {
-          "start": 116,
-          "end": 120,
-          "text": "188¥"
-        },
-        {
-          "start": 135,
-          "end": 151,
-          "text": "99 ulica Testowa"
-        },
-        {
-          "start": 548,
-          "end": 560,
-          "text": "5-gwiazdkowy"
-        }
-      ]
-    },
-    {
-      "name": "wikivoyage_labelled_damaged_phone",
-      "text": "Wstęp na teren ośrodka:\nWejście w godz. 7.00-18.00\nNormalny – 4,00 zł\nPowierzchnia 2040 ha.\n\nGastronomia\nRestauracje, pizzerie\nLokal Alfa, ulica Testowa 12; tel. 77-234-56-712\nLokal Beta; tel. 77 234 56 71\nLokal Gamma; tel. 77-234-56-72\nLokal Delta; tel. 77-234-56-73\nLokal Epsilon; tel. 77-234-56-74\nLokal Zeta; tel: 77-234-56-75\nLokal Eta; tel: 77-234-56-76\nLokal Theta, tel. 730234567\nLokal Iota, tel. 77 2345677\nLokal Kappa, tel 602234571\nLokal Lambda, tel. 77 2345678\n\nPuby\nLokal Mu; tel. 77-234-56-79\nLokal Nu; tel. []",
-      "mask": [
-        {
-          "start": 162,
-          "end": 175,
-          "text": "77-234-56-712",
-          "label": "phone"
-        },
-        {
-          "start": 193,
-          "end": 205,
-          "text": "77 234 56 71",
-          "label": "phone"
-        },
-        {
-          "start": 224,
-          "end": 236,
-          "text": "77-234-56-72",
-          "label": "phone"
-        },
-        {
-          "start": 255,
-          "end": 267,
-          "text": "77-234-56-73",
-          "label": "phone"
-        },
-        {
-          "start": 288,
-          "end": 300,
-          "text": "77-234-56-74",
-          "label": "phone"
-        },
-        {
-          "start": 318,
-          "end": 330,
-          "text": "77-234-56-75",
-          "label": "phone"
-        },
-        {
-          "start": 347,
-          "end": 359,
-          "text": "77-234-56-76",
-          "label": "phone"
-        },
-        {
-          "start": 378,
-          "end": 387,
-          "text": "730234567",
-          "label": "phone"
-        },
-        {
-          "start": 405,
-          "end": 415,
-          "text": "77 2345677",
-          "label": "phone"
-        },
-        {
-          "start": 433,
-          "end": 442,
-          "text": "602234571",
-          "label": "phone"
-        },
-        {
-          "start": 462,
-          "end": 472,
-          "text": "77 2345678",
-          "label": "phone"
-        },
-        {
-          "start": 494,
-          "end": 506,
-          "text": "77-234-56-79",
-          "label": "phone"
-        }
-      ],
-      "preserve": [
-        {
-          "start": 40,
-          "end": 50,
-          "text": "7.00-18.00"
-        },
-        {
-          "start": 62,
-          "end": 69,
-          "text": "4,00 zł"
-        },
-        {
-          "start": 83,
-          "end": 90,
-          "text": "2040 ha"
-        }
-      ]
-    },
-    {
-      "name": "wikivoyage_hungarian_hotel_directory",
-      "text": "Hotel Alfa, ulica Testowa 12, ☏ +36 84 234561, ✉ alfa@example.com. Pokój Ft 18 000–27 000.\nHotel Beta, ulica Testowa 14, ☏ +36 30 2345671. Zameldowanie: 10:00, wymeldowanie: 14:00.\nHotel Gamma, ulica Testowa 16, ☏ +36 84 234 562, ✉ gamma@example.com. Dodatkowe łóżko Ft 4500-11500.\nHotel Delta, ulica Testowa 18, delta@example.com. Od 15 € / noc / osoba.\nHotel Epsilon, ulica Testowa 20, ✉ epsilon@example.com. 14-27 € / noc / osoba.\nHotel Zeta, restauracja i bar, ulica Testowa 22, +36 84 234 563. Oferta noclegów.",
-      "mask": [
-        {
-          "start": 123,
-          "end": 137,
-          "text": "+36 30 2345671",
-          "label": "phone"
-        },
-        {
-          "start": 214,
-          "end": 228,
-          "text": "+36 84 234 562",
-          "label": "phone"
-        },
-        {
-          "start": 232,
-          "end": 249,
-          "text": "gamma@example.com",
-          "label": "pii"
-        },
-        {
-          "start": 313,
-          "end": 330,
-          "text": "delta@example.com",
-          "label": "pii"
-        },
-        {
-          "start": 390,
-          "end": 409,
-          "text": "epsilon@example.com",
-          "label": "pii"
-        },
-        {
-          "start": 483,
-          "end": 497,
-          "text": "+36 84 234 563",
-          "label": "phone"
-        }
-      ],
-      "preserve": [
-        {
-          "start": 73,
-          "end": 89,
-          "text": "Ft 18 000–27 000"
-        },
-        {
-          "start": 267,
-          "end": 280,
-          "text": "Ft 4500-11500"
-        }
-      ]
-    },
-    {
-      "name": "wikivoyage_qualified_mobile_label",
-      "text": "Nauka\nSzkoła Przykład oferuje kursy od 1 tygodnia/20 godzin do 4 tygodni/80 godzin (~360 USD). Kontakt: nauka@example.com.\nZajęcia taneczne w szkole Testowej. Kontakt: taniec@example.com. Telefon komórkowy: (53) 05 234567123.\n\nZakupy\nPrzykładowe informacje o mieście.",
-      "mask": [
-        {
-          "start": 104,
-          "end": 121,
-          "text": "nauka@example.com",
-          "label": "pii"
-        },
-        {
-          "start": 168,
-          "end": 186,
-          "text": "taniec@example.com",
-          "label": "pii"
-        },
-        {
-          "start": 207,
-          "end": 224,
-          "text": "(53) 05 234567123",
-          "label": "phone"
-        }
-      ],
-      "preserve": [
-        {
-          "start": 39,
-          "end": 59,
-          "text": "1 tygodnia/20 godzin"
-        },
-        {
-          "start": 84,
-          "end": 92,
-          "text": "~360 USD"
-        }
-      ]
-    }
-  ]
-}

src/scrub_entities.py

@@ -1,160 +0,0 @@
-"""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

@@ -1,677 +0,0 @@
-"""Regex PII scrub for Polish web/official text.
-
-Replaces emails, phones, PESEL/NIP/REGON/KRS, electronic contact addresses 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]. Bare PESEL requires checksum and date validation; explicit identifier
-labels also redact damaged numbers (including common OCR O/I/l substitutions).
-NIP/REGON/KRS and identity documents require explicit nearby labels. Passport
-variants include one-letter and diplomatic IDs. Foreign IBANs use country
-lengths and MOD-97. ePUAP paths require a label; e-Doreczenia uses its AE:PL form.
-Wrapped email domains and small extraction gaps around @/hyphens are supported.
-Explicit phone extensions and terminal suffix ranges are included; room numbers are not. Labelled numeric
-PINs (including URL pin= values) map to [PII] before phone detection.
-Contact/helpline headings cover consecutive descriptive phone-list entries;
-unrelated lines end the list. Bounded staff/address-directory evidence also covers
-formatted phone fields. Labelled full-number ranges retain shared prefixes.
-Phones require a nearby contact cue, a Polish +48/0048 prefix, or explicit
-international country/trunk notation such as +CC (0). Short service numbers
-need strong labels; 116xxx numbers also accept nearby telephone prose. Unlabelled
-domestic numbers are left for audit because table cells have the same shapes.
-
-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", "document", "krs", "electronic_address", "pin")
-
-# 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", "26", "29",
-    "32", "33", "34", "39", "41", "42", "43", "44", "45", "46", "47", "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_DOMAIN = r"[^\W_](?:[^\W_]|-[ \t]{0,3}(?=[^\W_]))*"
-_EMAIL_START = r"\b[\w.%+&-]+[ \t]{0,3}@"
-_EMAIL_RE = re.compile(_EMAIL_START + r"[ \t]{0,3}(?:" + _EMAIL_DOMAIN + r"\.)+[^\W\d_]{2,}\b")
-_EMAIL_WRAP_RE = re.compile(_EMAIL_START + r"[ \t]{0,3}(?:" + _EMAIL_DOMAIN
-    + r"\.)+[ \t]*\r?\n[ \t]*(?:" + _EMAIL_DOMAIN + r"\.)*[^\W\d_]{2,}\b")
-# Damaged contact fields can retain only the local part and @.
-_EMAIL_FRAGMENT_RE = re.compile(_EMAIL_START + r"(?=[ \t]*\r?$)", re.M)
-_EMAIL_LABEL_RE = re.compile(r"\be[ -]?mail[ \t]*:[ \t]*\Z", re.I)
-_EDELIVERY_RE = re.compile(r"\bAE:PL-\d{5}-\d{5}-[A-Z0-9]{5}-\d{2}(?![\w-])", re.I)
-_EPUAP_RE = re.compile(r"(?<![\w/])/[\w-]+/[\w-]+(?![\w/-])")
-_EPUAP_LABEL_RE = re.compile(
-    r"\b(?:e[ -]?puap|elektroniczna[ \t]+skrzynka[ \t]+podawcza)\b[^\n/\[\]]{0,50}\Z", re.I)
-_PIN_RE = re.compile(
-    r"(?P<label>\bPIN[ \t]*[:=][ \t]*)"
-    r"(?P<number>[\u202a-\u202e\u2066-\u2069]*\d(?:[ \t]?\d){3,15}#?)"
-    r"(?!\w|[ \t]*\d)", re.I)
-# Horizontal Unicode spaces from HTML/PDF extraction; preserve paragraph breaks.
-_SPACES = str.maketrans({c: " " for c in "\u00a0\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u202f\u205f\u3000"})
-# Country lengths checked against Apache Commons Validator's IBAN registry table:
-# https://commons.apache.org/proper/commons-validator/xref/org/apache/commons/validator/routines/IBANValidator.html
-# ponytail: country/length/MOD-97 only; add national BBAN rules if false positives appear.
-_IBAN_LENGTHS = {
-    country: length for length, countries in {
-        15: "NO", 16: "BE", 18: "DK FI AX FK FO GL NL SD",
-        19: "MK SI", 20: "AT BA EE KZ LT LU MN XK",
-        21: "CH HR LI LV", 22: "BG BH CR DE GB IM JE GG GE IE ME RS VA",
-        23: "AE GI IL IQ OM SO TL", 24: "AD CZ ES MD PK RO SA SE SK TN VG",
-        25: "LY PT ST", 26: "IS TR",
-        27: "BI DJ FR GF GP MQ RE PF TF YT NC BL MF PM WF GR IT MC MR SM",
-        28: "AL AZ BY CY DO GT HN HU LB NI PL SV", 29: "BR EG PS QA UA",
-        30: "JO KW MU YE", 31: "MT SC", 32: "LC", 33: "RU",
-    }.items() for country in countries.split()
-}
-_IBAN_RE = re.compile(
-    r"\b(?:" + "|".join(
-        country + r"[ \t-]*[0-9]{2}(?:[ \t-]*[A-Z0-9]){" + str(length - 4) + "}"
-        for country, length in _IBAN_LENGTHS.items()
-    ) + r")\b", re.I,
-)
-# 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(?:PL[ \t]*)?\d{3}(?:[- \t]\d{3}[- \t]\d{2}[- \t]\d{2}|[- \t]\d{2}[- \t]\d{2}[- \t]\d{3})\b", re.I)
-_NIP_RE = re.compile(r"\b(?:PL[ \t]*)?\d{10}\b", re.I)
-_DOCUMENT_RE = re.compile(
-    r"\b(?P<label>(?:dow[oó]d(?:u|em)?[ \t]+osobist(?:y|ego|ym)|"
-    r"(?:nr|numer)[ \t]+dowodu|paszport(?:u|em)?(?:[ \t]+dyplomatyczn(?:y|ego|ym))?)"
-    r"[ \t]*(?:(?:seria[ \t]+i[ \t]+numer|serii|seria|numer|nr)\.?[ \t]*)?"
-    r"[:=-]?[ \t]*)"
-    r"(?P<number>[A-Z]{3}[ \t-]?[0-9OIl]{6}|[A-Z]{2}[ \t-]?[0-9OIl]{7}|[A-Z][ \t-]?[0-9]{6,9}|[0-9]{4,12})\b", re.I,
-)
-_LABELLED_ID_RE = re.compile(
-    r"\b(?P<label>(?P<kind>PESEL|NIP|REGON)\b"
-    r"(?:[ \t]+(?:Gminy|Powiatu|Miasta|firmy)(?:[ \t]+[^\W\d_][^\W\d_-]*){0,4})?[ \t]{0,8}"
-    r"(?:(?:nr\.?|numer)[ \t]{0,8})?[:=.\-]?[ \t]{0,8}(?:\r?\n[ \t]{0,8})?)"
-    r"(?P<number>(?:PL[ \t]*)?(?:[0-9OIl]{9,14}|\d(?:[ \t-]?\d){8,13}))"
-    r"(?!\w|[ \t-]*\d)", re.I,
-)
-_REGON9_RE = re.compile(r"\b\d{9}\b")
-_ID_LABEL_END = r"[ \t]{0,8}(?:(?:nr\.?|numer)[ \t]{0,8})?[:=.\-]?[ \t]{0,8}(?:\r?\n[ \t]{0,8})?\Z"
-_NIP_LABEL_RE = re.compile(r"\bNIP\b" + _ID_LABEL_END, re.I)
-_REGON_LABEL_RE = re.compile(r"\bREGON\b" + _ID_LABEL_END, re.I)
-_KRS_RE = re.compile(r"\b\d{6,10}(?!\w|[ \t-]*\d)")
-_KRS_LABEL_RE = re.compile(r"\bKRS\b" + _ID_LABEL_END, re.I)
-# 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)"
-_VANITY_PHONE_RE = re.compile(
-    r"(?<!\w)\+1[ \t-]+\d{3}[ \t-]+(?:\d{3}-[A-Z]{4}|[A-Z]{7})"
-    r"(?:[ \t]+\(\d{4,7}\))?(?!\w)")
-_PHONE_RE = re.compile(
-    _VANITY_PHONE_RE.pattern + r"|(?:(?<!\w)|(?<=telefon)|(?<=tel)|(?<=faks)|(?<=fax))(?:\(?\+[ \t]*)?"
-    r"(?:\((?:0|0?\d{2,4}(?:-\d{1,2})?)\)" + _SEP + r")?"
-    r"\d(?:" + _SEP + r"\d){4,}(?!\w)", re.I,
-)
-_SHORT_PHONE_LABEL_RE = re.compile(
-    r"(?:\b(?:tel(?:efon\w*)?(?:(?:\.[ \t]*|[ \t]+)(?:kom[oó]rk\w*|lokaln\w*|stacjonarn\w*))?|fax|faks(?:em)?|phone|"
-    r"toll[ -]free|numer[ \t]+bezpłatny)|[☎☏📞📱])[.: \t/]{0,8}\Z|"
-    r"\binfolini[^\W\d_]*[^\d\n]{0,80}:[ \t]*\Z", re.I)
-_PHONE_LABEL_RE = re.compile(
-    r"\b(?:tel(?:efon[^\W\d_]*)?|fax|faks(?:em)?|kom(?:[oó]rk[^\W\d_]*)?|gsm|"
-    r"infolini[^\W\d_]*|(?:za)?dzwo[ńn][^\W\d_]*|Blikiem|"
-    r"lini[ęaąie][ \t]+wsparcia)(?![^\W\d_])|"
-    r"\bkontakt(?=tel[.:])|[☎☏📞📱]", re.I,
-)
-_PHONE_BREAK_RE = re.compile(
-    r"\n|\.[ \t]+(?=\d)|[ \t]+(?=\(?(?:[01]?\d|2[0-3])[.:][0-5]\d"
-    r"|\d{1,2}[.)][ \t]+\d{1,2}[./]\d{1,2}[./](?:19|20)\d{2})")
-_PHONE_EXTENSION_RE = re.compile(r"(?:(?:[ \t]+,?[ \t]*|,[ \t]*)wew(?:n(?:ętrzny)?)?\.?[ \t]*\d{1,5}|[ \t]+do[ \t]+\d{1,3}(?=[ \t]*(?:[.;,](?!\d)|\r?\n|\Z)))(?!\w|[ \t]*\d)", re.I)
-_SERVICE_PHONE_RE = re.compile(r"(?<![\w+])[1-9]\d{2}(?![\w\d]|[ \t./()-]*\d)")
-_SERVICE_PHONE_LABEL_RE = re.compile(
-    r"(?:\b(?:tel(?:efon\w*)?|phone)[.: \t]{0,8}(?:alarmow\w*[.: \t]{0,8})?|"
-    r"\b(?:numer[ \t]+)?bezpłatny[.: \t]{0,8}|"
-    r"\b(?:bezpłatny[ \t]+)?numer[ \t]+alarmowy[.: \t]{0,8}|"
-    r"(?:^|\n)[ \t]*(?:Straż pożarna|Policja|Pogotowie|Ratunek|Lekarz pogotowia ratunkowego)"
-    r"(?:[ \t]+\([^()\n]{1,60}\))?[ \t]*:[ \t]*)"
-    r"(?:[1-9]\d{2}[ \t]*(?:[,;]|i|lub|oraz)[ \t]*)*\Z", re.I)
-_OTHER_NUMBER_LABEL_RE = re.compile(r"\b(?:NIP|REGON|PESEL|KRS|ISBN|kod)\b[^\d\n]{0,20}\Z", re.I)
-_PHONE_LIST_HEADING_RE = re.compile(
-    r"[ \t]*(?:numery[ \t]+kontaktowe|telefony(?:[ \t]+(?:kontaktowe|zaufania))?|fax|faks|zapisz[ \t]+się|"
-    r"(?:[^.!?\n]{0,40}\?[ \t]*)?(?:za)?dzwoń!?)"
-    r"(?:[ \t]*\([^()\n]{1,80}\))?[ \t]*:?[ \t]*", re.I)
-_CONTACT_INTRO_RE = re.compile(
-    r"\b(?:kontakt\b|zapisy\b|zapisz[ \t]+się\b|rejestracja\b)"
-    r"(?:nr\.|[^\n.!?;]){0,75}\Z", re.I)
-_PHONE_HEADING_RE = re.compile(
-    r"(?<!\[)\b(?:tel(?:efon[^\W\d_]*)?\b|kontakt\b|zapisy\b|zapisz[ \t]+się\b|"
-    r"(?:za)?dzwo[ńn][^\W\d_]*\b|(?:pod|na)[ \t]+numer(?:em)?)"
-    r"(?:tj\.|nr\.|[^\d\n.!?;\[\]]){0,75}:?[ \t]*(?:\n[ \t]*){1,4}\Z", re.I)
-_CONTACT_EXCLUDE_RE = re.compile(r"\b(?:spraw\w*|kod\w*|kwot\w*|statystyk\w*|taryf\w*)\b", re.I)
-_PHONE_LINE_RE = re.compile(r"(?<!\w)\d{2,3}(?:[ \t-]\d{2,4}){2,3}(?!\w)")
-_STAFF_ROLE_RE = re.compile(
-    r"\b(?:inspektor|referent|koordynator|psycholog|księgowość|księgowy|księgowa|"
-    r"pracownicy[ \t]+socjalni|łowczy|podłowczy)\b", re.I)
-
-
-def _phone_list_context(text: str, start: int) -> bool:
-    # ponytail: 2,000-character lookback and 400-character entry suffix; longer
-    # lists need repeated headings or a section parser. Never cross prose.
-    end = text.find('\n', start, start + 401)
-    if end < 0 and len(text) > start + 400:
-        return False
-    lines = text[max(0, start - 2000):end if end >= 0 else len(text)].splitlines()
-    if start > 2000:
-        lines = lines[1:]  # A truncated line cannot establish a heading.
-    for i, line in enumerate(reversed(lines)):
-        if _PHONE_LIST_HEADING_RE.fullmatch(line):
-            return i > 0
-        if not line.strip():
-            continue
-        phone = _PHONE_RE.search(line)
-        if not phone or not _phone_ok(phone[0], short=True) or _is_amount(line, *phone.span()):
-            return False
-        if i == 0 and phone.start() != start - (text.rfind('\n', 0, start) + 1):
-            return False  # Numbers in an entry's description are not list items.
-        before, after = line[:phone.start()].strip(), line[phone.end():].strip()
-        if _OTHER_NUMBER_LABEL_RE.search(before):
-            return False
-        # Either "City: number" or "number – helpline description". Bare
-        # numeric rows are ambiguous even below an earlier contact heading.
-        named = re.fullmatch(r"[^\W\d_][^\d\n:;]{0,79}[:–—-]", before)
-        described = before in ('', '•', '-', '*') and re.match(r"[–—-][ \t]+[^\W\d_]", after)
-        dialling = re.fullmatch(r"[-•*]?[ \t]*(?:dzwoniąc[ \t]+)?z[ \t]+[^\W\d_][^\d\n:;.!?]{0,100}", before, re.I)
-        if not (((named or dialling) and after in ('', ',', ';', '.')) or described):
-            return False
-    return False
-
-
-def _phone_context(text: str, start: int, raw: str) -> bool:
-    # A previous redaction is a boundary, not a fresh "Telefon" cue. Include
-    # one marker's extra width so the 75-character window cannot bisect it.
-    before = re.split(r"\n[ \t]*\n|\[Telefon\]|\[PII\]",
-                      text[max(0, start - 75 - len(PHONE_TAG)):start])[-1][-75:]
-    if _OTHER_NUMBER_LABEL_RE.search(before):
-        return False
-    intro = _CONTACT_INTRO_RE.search(before)
-    if intro and not _CONTACT_EXCLUDE_RE.search(intro[0]):
-        return True
-    # A contact email must not erase an explicit contact label for the phone
-    # following it. Other redactions still form boundaries.
-    if re.search(r'\bkontakt[ \t]*:[ \t]*\[PII\][ \t,;]*\Z',
-                 text[max(0, start-75):start], re.I):
-        return True
-    lead = re.split(r'\[Telefon\]|\[PII\]', text[max(0, start-240):start])[-1]
-    # "Pod numerem" also introduces contract/case references. Require a
-    # communication cue when the number has no explicit telephone label.
-    number_contact = bool((_PHONE_LABEL_RE.search(lead) or re.search(
-        r'\b(?:informacj[^\W\d_]*|zgłosz[^\W\d_]*|zapis[^\W\d_]*|SMS(?:-a)?|połączeni[^\W\d_]*)\b', lead, re.I))
-        and not _CONTACT_EXCLUDE_RE.search(lead)
-        and not re.search(r'\b(?:umow|faktur|dokument)[^\W\d_]*\b', lead, re.I))
-    heading = _PHONE_HEADING_RE.search(text[max(0, start-160):start])
-    if (heading and not _CONTACT_EXCLUDE_RE.search(heading[0])
-            and (not re.match(r'(?:pod|na)\b', heading[0], re.I)
-                 or _PHONE_LABEL_RE.search(heading[0]) or number_contact)):
-        return True
-    if (number_contact and re.search(r'\b(?:pod[ \t]+numerem|na[ \t]+numer)[ \t]*:?[ \t]*\Z', before, re.I)):
-        return True
-    if re.search(r'\bтелефону[ \t]*:[ \t]*\Z', before, re.I):
-        return True
-    # An international phone may precede a labelled fax in the same contact list.
-    # Keep this cue adjacent: arbitrary later contact prose is not evidence.
-    after = text[start + len(raw):start + len(raw) + 40]
-    if re.match(r'[ \t]*[–—-][ \t]+telefon\b', after, re.I):
-        return True
-    if (re.match(r"\(?(?:\+|00)", raw)
-            and re.match(r"[ \t]*[,;][ \t]*(?:fax|faks(?:em)?)[.: \t]*(?=[+(0-9])", after, re.I)):
-        return True
-    # A foreign-looking +number can also be an increment in a financial table.
-    return bool(re.match(r"\(?(?:\+|00)[ \t]*48|\+\d{1,3}[ \t]+\(0\)", raw)
-                or _PHONE_LABEL_RE.search(before))
-
-
-def _directory_context(text: str, start: int, end: int) -> bool:
-    """Recognize phones in bounded staff and named-address contact records."""
-    raw = text[start:end]
-    foreign = raw.startswith('+') and _phone_ok(raw)
-    if not foreign and (not _pl_national_ok(_digits(raw)) or not re.search(r'[ \t-]', raw)):
-        return False
-    # ponytail: local 1,600-character directory evidence; longer isolated rows
-    # need preserved upstream table structure, not an unbounded document cue.
-    left, right = max(0, start-800), min(len(text), end+800)
-    nearby = text[left:right]
-    line_start, line_end = text.rfind('\n', 0, start)+1, text.find('\n', end)
-    line_end = len(text) if line_end < 0 else line_end
-    before, after = text[line_start:start], text[end:line_end]
-    if _CONTACT_EXCLUDE_RE.search(before) or _OTHER_NUMBER_LABEL_RE.search(before):
-        return False
-    if foreign:
-        # A comma-delimited name/address entry needs a labelled phone nearby;
-        # a +number alone could be an increment in a financial table.
-        address = re.search(r'(?:^|,)[ \t]*[^\W\d_][^,\n]{1,120},'
-                            r'[^\n]{0,160}\d[^\n]{0,80},[ \t]*\Z', before)
-        return bool(address and any(
-            _SHORT_PHONE_LABEL_RE.search(nearby[max(0,m.start()-80):m.start()])
-            for m in _PHONE_RE.finditer(nearby) if m[0].startswith('+') and _phone_ok(m[0])))
-    standalone = not before.strip() and not after.strip()
-    lead = text[max(0, start-400):start]
-    if (standalone and re.search(r'\b(?:infolini[^\W\d_]*|helpline)\b', lead, re.I)
-            and not _CONTACT_EXCLUDE_RE.search(lead)):
-        return True
-    if (standalone and re.search(r'\bnr\.?[ \t]+telefonu\b', nearby, re.I)
-            and re.search(r'\b(?:pok[oó]j|pokoju)\b', nearby, re.I)
-            and re.search(r'\bnazwisko\b', nearby, re.I)):
-        return True
-    # Email/name/role records and phone-led service directories repeat formatted
-    # values. A lone staff title beside a number is insufficient evidence.
-    phones = [m for m in _PHONE_LINE_RE.finditer(nearby)
-              if _pl_national_ok(_digits(m[0])) and not _is_amount(nearby, *m.span())]
-    roles = list(_STAFF_ROLE_RE.finditer(nearby))
-    if len(phones) < 2 or len(roles) < 2:
-        return False
-    return bool((re.search(r'\[PII\]', before[-100:] + after[:100]) and
-                 re.search(r'[^\W\d_]', before[-100:]))
-                or (not before.strip() and re.match(r'[ \t]+[^\W\d_]', after))
-                or _STAFF_ROLE_RE.search(before[-100:]))
-
-
-# Amounts can look like phones or checksum-valid national IDs. Keep the
-# currency adjacent to the number, allowing a decimal, multiplier and line wrap.
-_MONEY_GAP = r"[ \t]*(?:\n[ \t]*)?"
-_CURRENCY = r"(?:PLN|z[łl](?:ot(?:ych|ego|emu|ymi|ym|y|e))?|EUR(?:O)?|USD|GBP|CHF)\b|[%€$£]"
-_MONEY_AFTER_RE = re.compile(
-    r"(?:[,.][0-9]+)?" + _MONEY_GAP
-    + r"(?:(?:tys\.?|mln|mld|bln)\b\.?" + _MONEY_GAP + r")?"
-    + r"(?:" + _CURRENCY + r")", re.I,
-)
-_MONEY_BEFORE_RE = re.compile(r"(?:\b(?:PLN|EUR|USD|GBP|CHF)|[€$£])" + _MONEY_GAP + r"$", re.I)
-
-
-def _is_amount(text: str, start: int, end: int) -> bool:
-    return bool(_MONEY_AFTER_RE.match(text, end) or _MONEY_BEFORE_RE.search(text[max(0, start - 32):start]))
-
-
-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:
-    # Do not assemble an alphanumeric account from neighbouring prose words.
-    # Compact and ordinary four-character printed groups remain supported.
-    groups = re.split(r'[ \t-]+', raw)
-    if len(groups) > 1 and any(re.search(r'[A-Za-z]{5}', group) for group in groups):
-        return False
-    compact = re.sub(r"[\s-]+", "", raw).upper()
-    if compact.isdigit() and len(compact) == 26:
-        compact = "PL" + compact
-    if not re.fullmatch(r"[A-Z]{2}[0-9]{2}[A-Z0-9]+", compact):
-        return False
-    if len(compact) != _IBAN_LENGTHS.get(compact[:2]) or not 2 <= int(compact[2:4]) <= 98:
-        return False
-    if compact.startswith("PL") and not compact[2:].isdigit():
-        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 _tag(start, end, tag):
-    return tag
-
-
-def _replace_epuap(text: str, *, mask=_tag) -> tuple[str, int]:
-    last_end, count = None, 0
-
-    def replace(m):
-        nonlocal last_end, count
-        labelled = _EPUAP_LABEL_RE.search(text, max(0, m.start()-64), m.start())
-        continued = last_end is not None and re.fullmatch(r'[ \t]*[;,][ \t]*|[ \t]+(?:lub|albo|i|oraz)[ \t]+', text[last_end:m.start()], re.I)
-        if not labelled and not continued:
-            return m[0]
-        last_end = m.end()
-        count += 1
-        return mask(m.start(), m.end(), PII_TAG)
-
-    out = _EPUAP_RE.sub(replace, text)
-    return out, count
-
-
-def _replace_documents(text: str, *, mask=_tag) -> tuple[str, int]:
-    n = 0
-
-    def replace(m):
-        nonlocal n
-        number = re.sub(r"[ \t-]", "", m["number"]).upper()
-        passport = m["label"].lower().startswith("paszport")
-        if passport:
-            short_diplomatic = ('dyplomatyczn' in m['label'].lower()
-                                and re.search(r'\b(?:nr|numer)\b', m['label'], re.I)
-                                and re.fullmatch(r'\d{4,5}', number))
-            if not short_diplomatic and not re.fullmatch(r"[A-Z]{2}[0-9OIL]{7}|[A-Z][0-9]{6,9}|[0-9]{6,12}", number):
-                return m[0]
-        elif not re.fullmatch(r"[A-Z]{3}[0-9OIL]{6}", number):
-            return m[0]
-        n += 1
-        return m["label"] + mask(m.start('number'), m.end('number'), PII_TAG)
-
-    # Passport detection is label/format based; no MRZ check digit is present here.
-    return _DOCUMENT_RE.sub(replace, text), n
-
-
-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, short: bool = False) -> bool:
-    s = raw.strip()
-    if _VANITY_PHONE_RE.fullmatch(s):
-        return short
-    if s.startswith('/') or s.endswith('/'):
-        return False
-    s = re.sub(r'^\(\+', '+', s)
-    s = re.sub(r'^\(00\)[ \t]*', '00', s)
-    if re.fullmatch(r"\d{4}[-./]\d{2}[-./]\d{2}", s):
-        return False
-    if re.fullmatch(r'\(?(?:[01]?\d|2[0-3])[.:][0-5]\d[ \t]*[–—-][ \t]*(?:[01]?\d|2[0-3])[.:][0-5]\d\)?', 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"(?<!\d)20\d{2}(?!\d)", s)):
-        return False
-    if re.search(r"(?<!\d)\d{1,2}[-./]\d{1,2}[-./](?:19|20)\d{2}(?!\d)", s):
-        return False
-    d = _digits(raw)
-    if short and re.fullmatch(r'[2-9]\d{2}-[2-9]\d{2}-\d{4}', s):
-        return True
-    if short and s.startswith('(0)'):
-        return 7 <= len(d) <= 12
-    # ponytail: label + shape + length, not a country numbering-plan validator.
-    if short and re.match(r'^\(0?\d{2,4}(?:-\d{1,2})?\)', s):
-        return 8 <= len(d) <= 15
-    if s.startswith(('+', '00')):
-        international = _digits(s.replace('(0)', ''))
-        if s.startswith('00'):
-            international = international[2:]
-        if not international.startswith('48'):
-            # ponytail: explicit prefix + length, not a global numbering-plan
-            # validator. Add country metadata if review finds false positives.
-            return (7 if '(0)' in s else 8) <= len(international) <= 15 and international[0] != '0'
-    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")) or (short and len(d) <= 12)
-    return (_pl_national_ok(d)
-            or (short and 5 <= len(d) <= 8 and d[0] != '0')
-            or (short and 9 <= len(d) <= 12 and bool(re.fullmatch(r'\d{2,4}(?:[ \t-]\d{2,4}){2,3}', s)))
-            or (short and 9 <= len(d) <= 12 and bool(re.fullmatch(r'\d{2,4}\.\d{6,8}', s)))
-            or (short and 9 <= len(d) <= 12 and d.startswith('0')))
-
-
-def _replace_checked(text: str, pattern: re.Pattern, tag: str, ok,
-                     label: re.Pattern | None = None, *, mask=_tag) -> tuple[str, int]:
-    n = 0
-
-    def _sub(m):
-        nonlocal n
-        if label is not None and not label.search(text, max(0, m.start() - 64), m.start()):
-            return m.group(0)
-        if pattern is _PESEL_RE and re.search(r'[/?&][^\s]*\Z', text[max(0, m.start()-500):m.start()]):
-            return m.group(0)  # Bare URL path/query digits are not personal identifiers.
-        if not ok(m.group(0)) or (pattern not in (_EMAIL_RE, _EMAIL_WRAP_RE, _EMAIL_FRAGMENT_RE)
-                                 and _is_amount(text, m.start(), m.end())):
-            return m.group(0)
-        n += 1
-        return mask(m.start(), m.end(), tag)
-
-    return pattern.sub(_sub, text), n
-
-
-def _replace_phones(text: str, *, mask=_tag) -> tuple[str, int]:
-    n = 0
-    out = []
-    pos = 0
-    last_phone_end = None
-    while True:
-        m = _PHONE_RE.search(text, pos)
-        if not m:
-            out.append(text[pos:])
-            break
-        raw = m[0]
-        end = m.end()
-        replacement = raw
-        line_end = text.find('\n', m.start(), end)
-        if line_end >= 0 and re.fullmatch(r'\d{1,3}', text[m.start():line_end]):
-            next_end = text.find('\n', line_end+1, end)
-            if _directory_context(text, line_end+1, next_end if next_end >= 0 else end):
-                # A flattened table's room cell is not a phone country prefix.
-                out.append(text[pos:line_end+1])
-                pos = line_end+1
-                continue
-        short = bool(_SHORT_PHONE_LABEL_RE.search(text[max(0, m.start()-100):m.start()]))
-        short = short or (re.fullmatch(r'116[ \t]?\d{3}', raw)
-                          and _phone_context(text, m.start(), raw))
-        short = short or _phone_list_context(text, m.start())
-        # A bare five-digit continuation followed by a place/name can be a
-        # postal address. It needs its own phone label to override that ambiguity.
-        postal = re.fullmatch(r'\d{5}', raw) and re.match(r'[ \t]+[^\W\d_]', text[end:])
-        if (last_phone_end is not None and not postal
-                and re.fullmatch(r"[ \t\n,;]{1,12}|[ \t]+(?:lub|albo)[ \t]+", text[last_phone_end:m.start()], re.I)):
-            short = True
-        if (last_phone_end is not None
-                and re.fullmatch(r'(?:[ \t]+(?:w sprawie\b|\((?:w godzinach|dostępny)\b)'
-                                 r'|[ \t]*[–—-][ \t]+)[^\d\n.!?]{1,200}\n[ \t\n]{0,8}',
-                                 text[last_phone_end:m.start()], re.I)
-                and _pl_national_ok(_digits(raw))):
-            short = True
-        if (short or _phone_context(text, m.start(), raw)
-                or _directory_context(text, m.start(), line_end if line_end >= 0 else end)):
-            if (_is_amount(text, m.start(), end)
-                    and re.fullmatch(r'\d{1,3}(?:\.[ \t]*\d{3})+', raw)):
-                out.extend((text[pos:m.start()], raw))
-                pos = end
-                continue
-            # Stop before a new line or opening hours, but only after a complete
-            # phone. Look past the greedy match's last digit to recognize HH:MM.
-            for gap in _PHONE_BREAK_RE.finditer(text, m.start(), end + 6):
-                if gap.start() >= end:
-                    break
-                # Foreign lengths vary: a valid-looking prefix may still be an
-                # incomplete wrapped number. Only a section marker ends it.
-                if (raw.startswith(('+', '00')) and not re.match(r'(?:\+|00)[ \t]*48', raw)
-                        and gap[0] == '\n'
-                        and not re.match(r'\d{1,2}[.)](?!\d)', text[gap.end():])):
-                    continue
-                prefix = text[m.start():gap.start()].rstrip(". \t")
-                if _phone_ok(prefix) and not _is_amount(text, m.start(), gap.start()):
-                    end = m.start() + len(prefix)
-                    raw = prefix
-                    replacement = raw
-                    break
-            if _is_amount(text, m.start(), end):
-                out.extend((text[pos:m.start()], raw))
-                pos = end
-                continue
-            # A suffix range repeats the final extension digits, not a second
-            # complete phone. Only accept it after a valid full base number.
-            extension = re.fullmatch(r"(.+?)[/-](\d{1,3})", raw)
-            parenthesized_extension = re.fullmatch(r'(.+?)[ \t]+\(\d{1,5}', raw)
-            if not (text[end:end+1] == ')' and parenthesized_extension
-                    and _phone_ok(parenthesized_extension[1])):
-                parenthesized_extension = None
-            pair = re.fullmatch(r"(.+?)[ \t]+[–—-][ \t]+(.+)", raw)
-            shared = re.match(r"\(\d{2,4}\)[ \t]*", pair[1]) if pair else None
-            full_range = (pair and _phone_ok(pair[1], short)
-                          and _phone_ok((shared[0] if shared else '') + pair[2], short))
-            if (_phone_ok(raw, short) or (extension and _phone_ok(extension[1]))
-                    or parenthesized_extension or full_range):
-                if raw.count('(') > raw.count(')') and text[end:end+1] == ')':
-                    end += 1
-                suffix = _PHONE_EXTENSION_RE.match(text, end)
-                if suffix and not _is_amount(text, suffix.start(), suffix.end()):
-                    end = suffix.end()
-                start = m.start()
-                # Parentheses enclosing prose are punctuation, not phone syntax.
-                if raw.startswith('(+') and raw.count('(') > raw.count(')') and text[end-1:end] != ')':
-                    start += 1
-                replacement = text[m.start():start] + mask(start, end, PHONE_TAG)
-                n += 1
-            # ponytail: split only pairs (<=22 digits); longer lists need label
-            # context to distinguish them from accounts. Never redact ID tails.
-            elif 18 <= len(_digits(raw)) <= 22 and "." not in raw:
-                for gap in re.finditer(r"[ \t]*/[ \t]*|[ \t\n]+", raw):
-                    if _phone_ok(raw[:gap.start()]) and _phone_ok(raw[gap.end():]):
-                        replacement = (mask(m.start(), m.start()+gap.start(), PHONE_TAG)
-                                       + gap[0] + mask(m.start()+gap.end(), end, PHONE_TAG))
-                        n += 2
-                        break
-        out.extend((text[pos:m.start()], replacement))
-        if replacement != raw:
-            last_phone_end = end
-        pos = end
-    return "".join(out), n
-
-
-def _replace_extensions(text: str, *, mask=_tag) -> tuple[str, int]:
-    count = 0
-
-    def replace(m):
-        nonlocal count
-        before = text[max(0, m.start()-500):m.start()]
-        # Only a telephone followed by extension/name entries establishes scope.
-        heading = re.search(r'\btel(?:efon)?[.: \t]*\[Telefon\]'
-                            r'(?P<entries>(?:\s*wewn?\.?[ \t]+\d{1,5}[ \t]+[^\d\n]+)*\s*)\Z', before, re.I)
-        if not heading or _is_amount(text, m.start('number'), m.end('number')):
-            return m[0]
-        count += 1
-        return m['label'] + mask(m.start('number'), m.end('number'), PHONE_TAG)
-
-    output = re.sub(r'(?P<label>(?:^|\n)[ \t]*wewn?\.?[ \t]+)(?P<number>\d{1,5})(?!\w)',
-                    replace, text, flags=re.I)
-    return output, count
-
-
-def scrub_pii(text: str, *, spans: list | None = None) -> tuple[str, dict[str, int]]:
-    """Return (scrubbed_text, counts); optionally append exact original spans.
-
-    Offset tracking is opt-in; corpus ingestion keeps its existing return type
-    and does not allocate a character map. Unicode offsets count code points.
-    """
-    counts = {k: 0 for k in COUNTS}
-    if not text:
-        return text, counts
-    original = text
-    text = text.translate(_SPACES)  # One character per character: offsets survive.
-    offsets = list(range(len(text))) if spans is not None else None
-    edits = []
-
-    def mask(start, end, tag):
-        if spans is not None:
-            a, b = offsets[start], offsets[end-1] + 1
-            spans.append(dict(start=a, end=b, text=original[a:b],
-                              label='phone' if tag == PHONE_TAG else 'pii'))
-            edits.append((start, end, tag))
-        return tag
-
-    def apply(replacer, *args):
-        nonlocal text
-        text, result = replacer(text, *args, mask=mask)
-        # Each replacement pass uses one coordinate system. Apply its edits
-        # backwards only after all regex callbacks have finished.
-        for start, end, tag in reversed(edits):
-            offsets[start:end] = [offsets[start]] * len(tag)
-        edits.clear()
-        return result
-
-    # Longest / most specific first so a 26-digit account is not sliced
-    # into REGON / PESEL / NIP / phone. Checksums live in the replace callback.
-    def pins(value, *, mask):
-        def replace(m):
-            if _is_amount(value, m.start('number'), m.end('number')):
-                return m[0]
-            counts['pin'] += 1
-            return m['label'] + mask(m.start('number'), m.end('number'), PII_TAG)
-        return _PIN_RE.sub(replace, value), None
-    apply(pins)
-    foreign = apply(_replace_checked, _IBAN_RE, PII_TAG, _iban_ok)
-    bare = apply(_replace_checked, _ACCOUNT_RE, PII_TAG, _iban_ok)
-    counts["account"] = foreign + bare
-    counts['electronic_address'] = apply(_replace_checked, _EDELIVERY_RE, PII_TAG, lambda _: True)
-    counts['electronic_address'] += apply(_replace_epuap)
-    counts['krs'] = apply(_replace_checked, _KRS_RE, PII_TAG, lambda _: True, _KRS_LABEL_RE)
-    counts["document"] = apply(_replace_documents)
-    def labelled_ids(value, *, mask):
-        def replace(m):
-            if len(_digits(m['number'])) < 7 or _is_amount(value, m.start('number'), m.end()):
-                return m[0]
-            counts[m['kind'].lower()] += 1
-            return m['label'] + mask(m.start('number'), m.end('number'), PII_TAG)
-        return _LABELLED_ID_RE.sub(replace, value), None
-    apply(labelled_ids)
-    n14 = apply(_replace_checked, _REGON14_RE, PII_TAG, _regon_ok, _REGON_LABEL_RE)
-    n9 = apply(_replace_checked, _REGON9_RE, PII_TAG, _regon_ok, _REGON_LABEL_RE)
-    counts["regon"] += n14 + n9
-    n_dash = apply(_replace_checked, _NIP_DASH_RE, PII_TAG, lambda s: _nip_ok(_digits(s)), _NIP_LABEL_RE)
-    n_plain = apply(_replace_checked, _NIP_RE, PII_TAG, lambda s: _nip_ok(_digits(s)), _NIP_LABEL_RE)
-    counts["nip"] += n_dash + n_plain
-    counts["email"] = apply(_replace_checked, _EMAIL_WRAP_RE, PII_TAG,
-        lambda s: not _EMAIL_RE.fullmatch(s.splitlines()[0].rstrip('. \t')))
-    counts["email"] += apply(_replace_checked, _EMAIL_RE, PII_TAG, lambda _: True)
-    counts["email"] += apply(_replace_checked, _EMAIL_FRAGMENT_RE, PII_TAG,
-                             lambda _: True, _EMAIL_LABEL_RE)
-    counts["phone"] = apply(_replace_phones)
-    counts["phone"] += apply(_replace_checked, _SERVICE_PHONE_RE, PHONE_TAG,
-                             lambda _: True, _SERVICE_PHONE_LABEL_RE)
-    counts['phone'] += apply(_replace_extensions)
-    # Contact context takes precedence over coincidental PESEL checksums in
-    # foreign phone numbers; explicitly labelled identifiers were handled first.
-    bare_pesel = apply(_replace_checked, _PESEL_RE, PII_TAG, _pesel_ok)
-    counts['pesel'] += bare_pesel
-    return text, counts

src/sources.py

@@ -156,7 +156,7 @@ SOURCES = {
                       "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.",
+                      "PII via SlayerLab/NERGAL, not this repo.",
         "domain": "political/written",
         "created": "2011-11-08, 2026-09-04",
         "is_ocr": False,
@@ -429,8 +429,8 @@ 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] "
-                      "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. "
+                      "PII (phones/emails/IDs, and PERSON on this web shard) was applied "
+                      "at fetch; the scrubber now lives at SlayerLab/NERGAL, not this repo. "
                       "Token counts via tiktoken cl100k.",
         "domain": "web",
         "created": "2012-01-01, 2024-12-31",

src/test_pii_mixed_regressions.py

@@ -1,49 +0,0 @@
-"""Synthetic contact-format regressions; human exports are never test inputs."""
-import json
-from pathlib import Path
-import unittest
-
-from scrub_pii import scrub_pii
-
-
-class MixedRegressionTest(unittest.TestCase):
-    pass
-
-
-def regression(case):
-    def check(self):
-        text, spans = case['text'], []
-        scrub_pii(text, spans=spans)
-        for wanted in case['mask']:
-            self.assertEqual(text[wanted['start']:wanted['end']], wanted['text'])
-            covered = {i for span in spans if span['label'] == wanted['label']
-                       for i in range(span['start'], span['end'])}
-            required = {i for i in range(wanted['start'], wanted['end']) if not text[i].isspace()}
-            self.assertFalse(required-covered, case['name'])
-            overlapping = {i for span in spans
-                           if required & set(range(span['start'], span['end']))
-                           for i in range(span['start'], span['end']) if not text[i].isspace()}
-            self.assertFalse(overlapping-set(range(wanted['start'], wanted['end'])), case['name'])
-        covered = {i for span in spans for i in range(span['start'], span['end'])}
-        for wanted in case['preserve']:
-            self.assertEqual(text[wanted['start']:wanted['end']], wanted['text'])
-            self.assertFalse(covered & set(range(wanted['start'], wanted['end'])), case['name'])
-    return check
-
-
-fixtures = [json.loads(Path(__file__).with_name(name).read_text()) for name in
-            ('pii_mixed_regression_cases.json', 'pii_wikivoyage_regression_cases.json')]
-assert all(fixture['synthetic'] is True for fixture in fixtures)
-cases = [case for fixture in fixtures for case in fixture['cases']]
-assert len({case['name'] for case in cases}) == len(cases)
-for case in cases:
-    assert set(case) == {'name', 'text', 'mask', 'preserve'}
-    assert case['mask'] or case['preserve']
-    for target in case['mask'] + case['preserve']:
-        assert 0 <= target['start'] < target['end'] <= len(case['text'])
-        assert case['text'][target['start']:target['end']] == target['text']
-    setattr(MixedRegressionTest, 'test_'+case['name'], regression(case))
-
-
-if __name__ == '__main__':
-    unittest.main()

src/test_scrub_entities.py

@@ -1,112 +0,0 @@
-"""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

@@ -1,874 +0,0 @@
-"""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
-
-# Synthetic contact/identifier fixtures; no copied directory entries.
-# Email domains use example.com; emergency/service codes retain their semantics.
-# Numeric fixtures test syntax/checksums, not whether a number is assigned.
-# The IBAN cases use published example numbers.
-PESEL = "44051401458"
-NIP = "1234563218"
-REGON9 = "123456785"
-REGON14 = "12345678512347"
-IBAN = "PL61109010140000071219812874"
-
-
-class ScrubPiiTest(unittest.TestCase):
-    def test_email_spacing_on_both_sides_of_at(self):
-        for value in ('osoba @example.com', 'osoba @ example.com', 'osoba@ example.com',
-                      'osoba\t@\texample.com', 'osoba\u00a0@\u202fexample.com',
-                      'osoba @ example.\ncom'):
-            with self.subTest(value=value):
-                text, spans = 'E-mail: '+value+'.', []
-                out, counts = scrub_pii(text, spans=spans)
-                self.assertEqual(out, 'E-mail: [PII].')
-                self.assertEqual(counts['email'], 1)
-                self.assertEqual(spans, [dict(start=8, end=8+len(value), text=value, label='pii')])
-                self.assertEqual(scrub_pii(out), (out, dict.fromkeys(counts, 0)))
-        self.assertEqual(scrub_pii('E-mail: osoba @\n')[0], 'E-mail: [PII]\n')
-        for text in ('osoba\n@example.com', 'osoba    @example.com',
-                     'osoba @example..com', 'osoba @', 'systemd-fsck@.service'):
-            self.assertEqual(scrub_pii(text)[0], text)
-
-    def test_wikivoyage_repair_guards(self):
-        for label in ('Telefon komórkowy: ', 'tel.komórkowy: ', 'tel. komórkowy: '):
-            self.assertEqual(scrub_pii(label+'(53) 05 234567123')[0], label+'[Telefon]')
-        for text in ('PO Box 11155-3489', 'Telefon: 2026-09-08',
-                     'Fax:\n- z Polski 12 345 678 PLN',
-                     'Fax:\n- z Polski 0066 2 234 5613\n\nDane statystyczne\n12 345 678',
-                     'Tabela +86 351 2345613',
-                     'Hotel Przykład, ulica Testowa 16, +36 84 234 562 EUR',
-                     'Hotel Przykład, ulica Testowa 16, kod +36 84 234 562'):
-            with self.subTest(text=text):
-                expected = text.replace('0066 2 234 5613', '[Telefon]')
-                self.assertEqual(scrub_pii(text)[0], expected)
-
-    def test_phone_continuation_preserves_postal_address(self):
-        for text, expected in (
-            ('Ulica Testowa, 108, tel: 393 234 5671, 95131 Miasto.',
-             'Ulica Testowa, 108, tel: [Telefon], 95131 Miasto.'),
-            ('tel. +39 393 234 5671, 95131 Miasto.', 'tel. [Telefon], 95131 Miasto.'),
-            ('tel. 501 234 567, 12345', 'tel. [Telefon], [Telefon]'),
-            ('tel. 501 234 567, 123 456 sekretariat', 'tel. [Telefon], [Telefon] sekretariat'),
-            ('tel. 95131 Miasto', 'tel. [Telefon] Miasto'),
-        ):
-            with self.subTest(text=text):
-                self.assertEqual(scrub_pii(text)[0], expected)
-
-    def test_mixed_repair_boundaries(self):
-        for text, expected in (
-            ('tel. kwota 500. 100. 200. 300 PLN', 'tel. kwota 500. 100. 200. 300 PLN'),
-            ('tel. 501 234 567 do 29 marca', 'tel. [Telefon] do 29 marca'),
-            ('tel. 501 234 567 do 29.12.2026', 'tel. [Telefon] do 29.12.2026'),
-            ('a@example.com.\nNext.section', '[PII].\nNext.section'),
-            ('Nakład +27 (0)13 234-5612 EUR', 'Nakład +27 (0)13 234-5612 EUR'),
-            ('tel. 501 234 567. 123,00 zł', 'tel. [Telefon]. 123,00 zł'),
-            ('Faks: +33 1 23 45 67 12\n—\nD-60322\nFrankfurt',
-             'Faks: [Telefon]\n—\nD-60322\nFrankfurt'),
-            ('☏ +1 202 555-TEST (8378), +1 202 555-0142', '☏ [Telefon], [Telefon]'),
-            ('Telefony alarmowe: 997, 112\nDyżurny KPP: 68 123 45 67',
-             'Telefony alarmowe: [Telefon], [Telefon]\nDyżurny KPP: [Telefon]'),
-            ('Infolinię uruchomiono od 22-26.04.br.', 'Infolinię uruchomiono od 22-26.04.br.'),
-            ('Tel Aviv, s. 499-515.', 'Tel Aviv, s. 499-515.'),
-            ('równoważne zapisy modelu: 70-20-10', 'równoważne zapisy modelu: 70-20-10'),
-            ('Sprzęt teleinf. i telekom.\n24 965,3\n11 145,3\n13 693,5',
-             'Sprzęt teleinf. i telekom.\n24 965,3\n11 145,3\n13 693,5'),
-        ):
-            with self.subTest(text=text):
-                self.assertEqual(scrub_pii(text)[0], expected)
-
-    def test_labelled_email_fragment_at_line_end(self):
-        for text, expected in (
-            ('adres e-mail: j.kowalski@\n\nDalszy tekst.', 'adres e-mail: [PII]\n\nDalszy tekst.'),
-            ('EMAIL:łukasz@  \r\n', 'EMAIL:[PII]  \r\n'),
-            ('e-mail: osoba@', 'e-mail: [PII]'),
-            ('osoba@', 'osoba@'),
-            ('plik: systemd-fsck@.service', 'plik: systemd-fsck@.service'),
-            ('e-mail: osoba@example..com', 'e-mail: osoba@example..com'),
-            ('e-mail: osoba@ example.com', 'e-mail: [PII]'),
-        ):
-            with self.subTest(text=text):
-                spans = []
-                out, counts = scrub_pii(text, spans=spans)
-                self.assertEqual(out, expected)
-                self.assertEqual(counts['email'], int(out != text))
-                for span in reversed(spans):
-                    self.assertEqual(text[span['start']:span['end']], span['text'])
-                    text = text[:span['start']] + '[PII]' + text[span['end']:]
-                self.assertEqual(text, out)
-                self.assertEqual(scrub_pii(out), (out, dict.fromkeys(counts, 0)))
-
-    def test_reviewed_directory_contact_and_number_boundaries(self):
-        cases = [
-            ('Kontakt: Jan Kowalski: 501 234 567', 'Kontakt: Jan Kowalski: [Telefon]'),
-            ('Kontakt: a@example.com, (22) 123 45 67', 'Kontakt: [PII], [Telefon]'),
-            ('Zapisy do piątku 14 marca pod nr 41 234 56 71', 'Zapisy do piątku 14 marca pod nr [Telefon]'),
-            # Contact headings establish phone context across blank lines.
-            ('Zapisy pod numerem:\n\n501234567', 'Zapisy pod numerem:\n\n[Telefon]'),
-            ('Nr telefonu do kontaktu:\n\n13 2345671\n\n502234571',
-             'Nr telefonu do kontaktu:\n\n[Telefon]\n\n[Telefon]'),
-            ('Wszystkie sprawy należy kierować pod numer telefonu:\n\n18 23 45 671',
-             'Wszystkie sprawy należy kierować pod numer telefonu:\n\n[Telefon]'),
-            ('Telefon: 25 23 - 456 - 71- sekretariat\n\n25 23 - 456 - 71 wew. 2 - intendent',
-             'Telefon: [Telefon]- sekretariat\n\n[Telefon] - intendent'),
-            ('Zapisz się:\n\nJan Kowalski: 501 234 567\n\nAnna Nowak: 22 123 45 67',
-             'Zapisz się:\n\nJan Kowalski: [Telefon]\n\nAnna Nowak: [Telefon]'),
-            ('tel. 132345671/699234571', 'tel. [Telefon]/[Telefon]'),
-            ('tel. 501 234 567 / 22 123 45 67', 'tel. [Telefon] / [Telefon]'),
-            ('tel. 32 234 56 71 15.00-19.00', 'tel. [Telefon] 15.00-19.00'),
-            ('tel. 510 234 571 3. 12.01.2026 r. – 18.01.2026 r.',
-             'tel. [Telefon] 3. 12.01.2026 r. – 18.01.2026 r.'),
-            ('tel. 25 2345671 (155)', 'tel. [Telefon]'),
-            ('tel. 33 2345 671, wewnętrzny 60', 'tel. [Telefon]'),
-            ('tel. 86 234 56 71\n\nwewn. 122 Jan Kowalski\n\nwewn. 123 Anna Nowak',
-             'tel. [Telefon]\n\nwewn. [Telefon] Jan Kowalski\n\nwewn. [Telefon] Anna Nowak'),
-            ('Kontakt: (32) 234-56-71 lub bezpłatny numer alarmowy: 994',
-             'Kontakt: [Telefon] lub bezpłatny numer alarmowy: [Telefon]'),
-            ('за номером телефону: 452-234-571', 'за номером телефону: [Telefon]'),
-            ('Imie i nazwisko\nNr. Pokoju\nNr. Telefonu\nJan Kowalski\n4\n501 234 567',
-             'Imie i nazwisko\nNr. Pokoju\nNr. Telefonu\nJan Kowalski\n4\n[Telefon]'),
-            ('Referent Jan Kowalski 501 234 567 a@example.com\n\nPsycholog Anna Nowak 22 123 45 67 b@example.com',
-             'Referent Jan Kowalski [Telefon] [PII]\n\nPsycholog Anna Nowak [Telefon] [PII]'),
-            ('Infolinia pomaga znaleźć odpowiednie wsparcie.\n\n800 234 571\n\nPon-pt 10.00-21.00',
-             'Infolinia pomaga znaleźć odpowiednie wsparcie.\n\n[Telefon]\n\nPon-pt 10.00-21.00'),
-            ('NIP Powiatu Przykładowego: 123-45-63-218\nREGON Powiatu Przykładowego: 123456785',
-             'NIP Powiatu Przykładowego: [PII]\nREGON Powiatu Przykładowego: [PII]'),
-        ]
-        negatives = [
-            'Kontakt: cena 500 100 200 PLN',
-            'Telefon: 15.00-19.00',
-            'tel. 501 234 567\n\nNowa tabela.\n\n502234571',
-            'Statystyki infolinii.\n\n800 234 571\n\nLiczba zgłoszeń',
-            'Referent: 501 234 567',
-            'wewn. 123 Anna Nowak',
-            'Nr. Telefonu\nKod produktu 501 234 567',
-            'Imie i nazwisko\nNr. Pokoju\nNr. Telefonu\nKwota 501 234 567 zł',
-        ]
-        cases.extend((s, s.replace('501 234 567', '[Telefon]', 1) if s.startswith('tel. ') else s)
-                     for s in negatives)
-        for text, expected in cases:
-            with self.subTest(text=text):
-                spans = []
-                out, counts = scrub_pii(text, spans=spans)
-                self.assertEqual(out, expected)
-                rebuilt = text
-                for span in sorted(spans, key=lambda s: s['start'], reverse=True):
-                    self.assertEqual(text[span['start']:span['end']], span['text'])
-                    tag = '[Telefon]' if span['label'] == 'phone' else '[PII]'
-                    rebuilt = rebuilt[:span['start']] + tag + rebuilt[span['end']:]
-                self.assertEqual(rebuilt, out)
-                self.assertEqual(self._scrub(out), (out, dict.fromkeys(counts, 0)))
-
-    def test_explicit_access_pins(self):
-        for text, expected in (
-            ('PIN: \u202a123 456 789#', 'PIN: [PII]'),
-            ('kod PIN: 1234', 'kod PIN: [PII]'),
-            ('https://example.org/meet?pin=1234567890123&lang=pl',
-             'https://example.org/meet?pin=[PII]&lang=pl'),
-        ):
-            out, counts = self._scrub(text)
-            self.assertEqual(out, expected)
-            self.assertEqual(counts['pin'], 1)
-            self.assertEqual(counts['phone'], 0)
-            self.assertEqual(self._scrub(out), (out, dict.fromkeys(counts, 0)))
-        for text in ('Kod pocztowy: 00-123', 'ISBN 978-83-60823-07-01',
-                     'spin=12345678', 'PIN: 1234 PLN', 'PIN: 12345678901234567',
-                     'PIN: 1234abc', 'PIN: [PII]'):
-            self.assertEqual(self._scrub(text)[0], text)
-
-    def test_shared_contact_lists_and_phone_ranges(self):
-        cases = [
-            ('Numery kontaktowe:\n\nMIASTO ALFA – 85 234 56 71,\n\nMIASTO BETA – 86 234 56 72,\n\nMIASTO GAMMA – 87 234 56 73.',
-             'Numery kontaktowe:\n\nMIASTO ALFA – [Telefon],\n\nMIASTO BETA – [Telefon],\n\nMIASTO GAMMA – [Telefon].'),
-            ('Telefony zaufania (Polska, numery bezpłatne):\n 116 111 – Telefon Zaufania dla Dzieci i Młodzieży (czynny codziennie, możliwość kontaktu także przez czat)\n 800 23 4567 – Centrum Wsparcia',
-             'Telefony zaufania (Polska, numery bezpłatne):\n [Telefon] – Telefon Zaufania dla Dzieci i Młodzieży (czynny codziennie, możliwość kontaktu także przez czat)\n [Telefon] – Centrum Wsparcia'),
-            ('Numery kontaktowe:\n\nGdańsk: 58 123 45 67\n\nKraków: 12 345 67 89',
-             'Numery kontaktowe:\n\nGdańsk: [Telefon]\n\nKraków: [Telefon]'),
-            ('Telefony zaufania:\n• 116 123 – Wsparcie dorosłych\n\n• 800 123 456 – Pomoc',
-             'Telefony zaufania:\n• [Telefon] – Wsparcie dorosłych\n\n• [Telefon] – Pomoc'),
-            ('Tel.: (420) 222 345 671 – 222 345 672', 'Tel.: [Telefon]'),
-            ('Tel. (420) 222 111 222 - 222 111 333 wew. 42', 'Tel. [Telefon]'),
-            ('tel. 58 123 45 67 — 58 123 45 68', 'tel. [Telefon]'),
-            ('Numery kontaktowe:\n\nGdańsk: 58 123 45 67\n\nWarunki korzystania.\n\nKraków: 12 345 67 89',
-             'Numery kontaktowe:\n\nGdańsk: [Telefon]\n\nWarunki korzystania.\n\nKraków: 12 345 67 89'),
-            ('Telefony zaufania:\n116 123 – ' + 'Opis usługi. ' * 8 + '500 123 456 zgłoszeń',
-             'Telefony zaufania:\n[Telefon] – ' + 'Opis usługi. ' * 8 + '500 123 456 zgłoszeń'),
-        ]
-        negatives = [
-            'Tabela (420) 222 111 222 – 222 111 333',
-            'tel. (420) 222 111 222 – 222 111 333 EUR',
-            'Numery kontaktowe:\n\nKody taryfowe\n250300000\n250410000',
-            'Numery kontaktowe:\n\nGdańsk: 500 123 456 zł',
-            'Numery kontaktowe:\n\nKod: 501234567',
-            'Numery kontaktowe:\n\nWarunki korzystania z usługi.\n\nGdańsk: 58 123 45 67',
-            'Telefony zaufania:\n\nStatystyki\n800 123 456 – Liczba zgłoszeń',
-            'W artykule opisano numery kontaktowe:\n\nGdańsk: 58 123 45 67',
-            'Telefony zaufania:\n\n116 123 zł – Koszt programu',
-            'Numery kontaktowe:\n\n250300000\n250410000',
-            'Numery kontaktowe (20260908):',
-        ]
-        cases.extend((text, text) for text in negatives)
-        for text, expected in cases:
-            with self.subTest(text=text):
-                spans = []
-                out, counts = scrub_pii(text, spans=spans)
-                self.assertEqual(out, expected)
-                self.assertEqual(counts['phone'], expected.count('[Telefon]'))
-                self.assertEqual((out, counts), self._scrub(text))
-                rebuilt = text
-                end = len(text)
-                for span in sorted(spans, key=lambda s: s['start'], reverse=True):
-                    self.assertLessEqual(span['end'], end)
-                    self.assertEqual(text[span['start']:span['end']], span['text'])
-                    rebuilt = rebuilt[:span['start']] + '[Telefon]' + rebuilt[span['end']:]
-                    end = span['start']
-                self.assertEqual(rebuilt, out)
-                self.assertEqual(self._scrub(out), (out, dict.fromkeys(counts, 0)))
-
-    def test_contact_values_review_regressions(self):
-        cases = [
-            ('tel. (03141) 23456', 'tel. [Telefon]'),
-            ('tel. (03143) 2-34-56', 'tel. [Telefon]'),
-            ('numer bezpłatny: +1-202-555-0142', 'numer bezpłatny: [Telefon]'),
-            ('Toll Free: 888-555-0142, Phone: 207-555-0143',
-             'Toll Free: [Telefon], Phone: [Telefon]'),
-            ('Straż pożarna (Lánglovagok/Пожежна служба): 101\n'
-             'Policja (Rendőrség/Поліція): 102\n'
-             'Pogotowie (Mentőautó/Швидка допомога): 103',
-             'Straż pożarna (Lánglovagok/Пожежна служба): [Telefon]\n'
-             'Policja (Rendőrség/Поліція): [Telefon]\n'
-             'Pogotowie (Mentőautó/Швидка допомога): [Telefon]'),
-            ('tel. 112', 'tel. [Telefon]'),
-            ('lost&found@example.com.', '[PII].'),
-            ('Lostandfound@sub.example.com.', '[PII].'),
-            ('☏ +36 20 234-5671. 08:00–21:00.', '☏ [Telefon]. 08:00–21:00.'),
-            ('☏ +33 558234567. 12:00-02:00.', '☏ [Telefon]. 12:00-02:00.'),
-            ('telefon (+4 0723456712 - +4 to kod).', 'telefon ([Telefon] - +4 to kod).'),
-            ('tel. (+32 22345671)', 'tel. [Telefon]'),
-        ]
-        negatives = ['Tabela (03141) 23456', 'Phone: 207-555-0143 USD',
-                     'Toll Free: opis produktu 207-555-0143', 'numer bezpłatny: 2020-01-15',
-                     'Policja: 102 zł', 'Policja zatrzymała 102 osoby', 'Kod: 101',
-                     'Pogotowie: budynek 103', 'Policja:\n\n102',
-                     'phonebook 207-555-0143', 'systemd-fsck@.service.8.gz']
-        cases.extend((text, text) for text in negatives)
-        for text, expected in cases:
-            with self.subTest(text=text):
-                spans = []
-                out, counts = scrub_pii(text, spans=spans)
-                self.assertEqual(out, expected)
-                self.assertEqual((out, counts), self._scrub(text))
-                rebuilt = text
-                for span in sorted(spans, key=lambda s: s['start'], reverse=True):
-                    self.assertEqual(text[span['start']:span['end']], span['text'])
-                    tag = '[Telefon]' if span['label'] == 'phone' else '[PII]'
-                    rebuilt = rebuilt[:span['start']] + tag + rebuilt[span['end']:]
-                self.assertEqual(rebuilt, out)
-                self.assertEqual(self._scrub(out), (out, dict.fromkeys(counts, 0)))
-
-    def test_contact_challenge_phone_misses(self):
-        for text, expected in (
-            ('Biuro, +39 0964 234567, faks: +39 0964 234567.',
-             'Biuro, [Telefon], faks: [Telefon].'),
-            ('Tel.+39.030.234561 · Fax+39.030.2345671.',
-             'Tel.[Telefon] · Fax[Telefon].'),
-            ('Tel: (0) 611 2345. Tel: (0) 611 2346.',
-             'Tel: [Telefon]. Tel: [Telefon].'),
-            ('Biuro, +44 20 7946 0958; fax: +44 20 7946 0959',
-             'Biuro, [Telefon]; fax: [Telefon]'),
-            ('Tel: (0) 611 2345 wew. 42', 'Tel: [Telefon]'),
-            ('Tabela +39 0964 234567', 'Tabela +39 0964 234567'),
-            ('Tabela (0) 611 2345', 'Tabela (0) 611 2345'),
-            ('Tel. 01.03.2020', 'Tel. 01.03.2020'),
-            ('Kwota +39 0964 234567 EUR, faks: wymagany',
-             'Kwota +39 0964 234567 EUR, faks: wymagany'),
-            ('Tabela +39 0964 234567\n\nfaks: +39 0964 234567',
-             'Tabela +39 0964 234567\n\nfaks: [Telefon]'),
-            ('Kod +39 0964 234567, faks: +39 0964 234567',
-             'Kod +39 0964 234567, faks: [Telefon]'),
-        ):
-            with self.subTest(text=text):
-                spans = []
-                out, counts = scrub_pii(text, spans=spans)
-                self.assertEqual(out, expected)
-                self.assertEqual((out, counts), self._scrub(text))
-                rebuilt = text
-                for span in sorted(spans, key=lambda s: s['start'], reverse=True):
-                    self.assertEqual(text[span['start']:span['end']], span['text'])
-                    rebuilt = rebuilt[:span['start']] + '[Telefon]' + rebuilt[span['end']:]
-                self.assertEqual(rebuilt, out)
-                self.assertEqual(self._scrub(out), (out, dict.fromkeys(counts, 0)))
-
-    def test_redaction_placeholders_do_not_become_phone_cues(self):
-        for padding in range(25, 40):
-            text = 'tel. 501 234 567' + ' x' * padding + ' 602 345 678'
-            once, _ = self._scrub(text)
-            twice, counts = self._scrub(once)
-            self.assertEqual(twice, once)
-            self.assertEqual(sum(counts.values()), 0)
-        for marker in ('[Telefon]', '[PII]'):
-            text = marker + ' - opis 602 345 678'
-            self.assertEqual(self._scrub(text)[0], text)
-            for gap in ('\n\n', ' - opis\n\n'):
-                text = marker + gap + '602 345 678'
-                self.assertEqual(self._scrub(text)[0], text)
-                self.assertEqual(self._scrub('Telefon: ' + text)[0], 'Telefon: ' + text)
-        self.assertEqual(self._scrub('[Telefon] nowy tel. 602345678')[0],
-                         '[Telefon] nowy tel. [Telefon]')
-
-    def test_explicit_passport_variants_and_qualified_ids(self):
-        for label, number in (
-            ('paszport dyplomatyczny nr ', '1234'),
-            ('Paszport dyplomatyczny nr ', 'D000001234'),
-            ('Nr paszportu: ', 'D9001234'),
-            ('Nr paszportu: ', 'C2001234'),
-            ('Numer paszportu: ', 'D 001234'),
-            ('NIP Gminy: ', '123-456-32-18'),
-            ('REGON Gminy: ', '123456785'),
-        ):
-            with self.subTest(label=label, number=number):
-                self.assertEqual(self._scrub(label+number+'.')[0], label+'[PII].')
-        for text in ('Paszport wydany w 2017 roku', 'Paszport 2017',
-                     'paszport dyplomatyczny 2020', 'Model D9001234',
-                     'NIP firmy jest wymagany; kod 1234563218'):
-            self.assertEqual(self._scrub(text)[0], text)
-
-    def test_foreign_phone_cues_and_parenthesized_country_codes(self):
-        for label, number in (
-            ('Faks', '+32 22345671'),
-            ('faksem ', '(+32 22345671)'),
-            ('tel. ', '(+34) 965234571'),
-            ('tel. ', '(420) 222 345 671'),
-            ('telefon ', '(32-2) 234 56 71'),
-            ('faks ', '(49-69) 23 45-671/672'),
-            ('Faks: ', '(00) 49 69 23/45 -6 71'),
-        ):
-            with self.subTest(label=label, number=number):
-                self.assertEqual(self._scrub(label+number)[0], label+'[Telefon]')
-        for text in ('Tabela (420) 222 345 671', 'Tabela +32 22345671',
-                     'tel. (420) 222 345 671 EUR'):
-            self.assertEqual(self._scrub(text)[0], text)
-
-    def test_electronic_addresses_and_krs(self):
-        for text, expected, kind in (
-            ('Adres do e-Doręczeń: AE:PL-12345-67890-ABCDE-12.',
-             'Adres do e-Doręczeń: [PII].', 'electronic_address'),
-            ('E-PUAP: /przyklad123/SkrytkaESP', 'E-PUAP: [PII]', 'electronic_address'),
-            ('EPUAP Urzędu /urzad/SkrytkaESP; /urzad/skrytka; /urzad/inna',
-             'EPUAP Urzędu [PII]; [PII]; [PII]', 'electronic_address'),
-            ('Elektroniczna Skrzynka Podawcza na platformie E-PUAP: /urzad/skrytka',
-             'Elektroniczna Skrzynka Podawcza na platformie E-PUAP: [PII]', 'electronic_address'),
-            ('KRS: 651234; KRS 0000123457.', 'KRS: [PII]; KRS [PII].', 'krs'),
-        ):
-            with self.subTest(text=text):
-                out, counts = self._scrub(text)
-                self.assertEqual(out, expected)
-                self.assertGreater(counts[kind], 0)
-                self.assertEqual(self._scrub(out), (out, dict.fromkeys(counts, 0)))
-        for text in ('Ścieżka /usr/local', 'E-PUAP: https://example.com/usr/local',
-                     'KRS wymagany, kod 651234', 'KRS 1234567890123',
-                     'KRS 123456 789012 345678', 'KRS 651234 zł',
-                     'ORCID: 0000-0001-2345-6789', 'AE:PL-12345-67890-ABCDE-120'):
-            with self.subTest(text=text):
-                self.assertEqual(self._scrub(text)[0], text)
-
-    def test_extension_and_continuation_after_confirmed_phone(self):
-        for text, expected in (
-            ('tel. 22 234 56 71 lub 234 56 72 wew. 402, pokój nr 14',
-             'tel. [Telefon] lub [Telefon], pokój nr 14'),
-            ('tel. 00966 2345671, wew. 109, fax. 00966 234 5672',
-             'tel. [Telefon], fax. [Telefon]'),
-            ('tel. 25/234 56 71 wew. 48 pokój nr 9', 'tel. [Telefon] pokój nr 9'),
-            ('tel. 501234567 albo 1234567', 'tel. [Telefon] albo [Telefon]'),
-            ('wew. 402', 'wew. 402'),
-            ('tel. 501234567 pokój nr 14', 'tel. [Telefon] pokój nr 14'),
-            ('tel. 501234567 lub kwota 1234567 zł', 'tel. [Telefon] lub kwota 1234567 zł'),
-            ('tel. 501234567 wew. 402 zł', 'tel. [Telefon] wew. 402 zł'),
-            ('tel. 501234567 wew. 1234567', 'tel. [Telefon] wew. 1234567'),
-        ):
-            with self.subTest(text=text):
-                self.assertEqual(self._scrub(text)[0], expected)
-
-    def test_email_domain_requires_nonempty_labels(self):
-        for text in ('systemd-fsck@.service.8.gz', 'x@-example.com', 'x@example-.com',
-                     'x@example..com'):
-            with self.subTest(text=text):
-                self.assertEqual(self._scrub(text)[0], text)
-        self.assertEqual(self._scrub('a@sub-domain.example.com.')[0], '[PII].')
-
-    def test_foreign_phone_line_wrapping(self):
-        self.assertEqual(self._scrub('tel. +49\n711\n234\n5671')[0], 'tel. [Telefon]')
-        self.assertEqual(self._scrub('tel. +49 711 234 5671\n2. Szkoła')[0],
-                         'tel. [Telefon]\n2. Szkoła')
-
-    def test_short_phone_lists_and_foreign_trunk_numbers(self):
-        for raw, expected in (
-            ('tel. 523-45-61, 523-45-62; 517 234', 'tel. [Telefon], [Telefon]; [Telefon]'),
-            ('Tel. 09191 234567', 'Tel. [Telefon]'),
-            ('tel. (032) 23 45 67', 'tel. [Telefon]'),
-            ('Numer telefonu: 79 234 567', 'Numer telefonu: [Telefon]'),
-            ('tel. 501234567, kod 1234567', 'tel. [Telefon], kod 1234567'),
-            ('HAL Id: tel. 01279041', 'HAL Id: tel. 01279041'),
-        ):
-            with self.subTest(raw=raw):
-                self.assertEqual(self._scrub(raw)[0], expected)
-
-    def test_extended_phone_formats(self):
-        for number in ("74/234 56 71", "095/ 23 45 671", "261-234-571",
-                       "47 234 56 71", "826-45-67", "51 23 45",
-                       "+49 (0)711 234 56 76", "+39 057123451",
-                       "+32 22345671", "+1 202-555-0144", "00966 2345671",
-                       "12 23 45 671-673", "+251 11 234 56 71/72"):
-            with self.subTest(number=number):
-                out, counts = self._scrub('tel. ' + number)
-                self.assertEqual(out, 'tel. [Telefon]')
-                self.assertEqual(counts['phone'], 1)
-                self.assertEqual(sum(counts.values()), 1)
-
-    def test_short_numbers_require_immediate_phone_label(self):
-        for text in ("Tabela 826-45-67", "tel. opis tabeli 1234567",
-                     "tel. 501234567 kwota 1234567 zł", "tel. 2020-01-15"):
-            with self.subTest(text=text):
-                self.assertIn(text.split(' ')[-1], self._scrub(text)[0])
-
-    def test_labelled_damaged_identifiers(self):
-        for label, number, kind in (("PESEL: ", "44051401457", "pesel"),
-                                    ("PESEL:\n", "44O514O1457", "pesel"),
-                                    ("NIP: ", "123-456-32-19", "nip"),
-                                    ("REGON: ", "123456786", "regon"),
-                                    ("Dowód osobisty: ", "ABA400000", "document"),
-                                    ("Numer paszportu: ", "120012345", "document")):
-            with self.subTest(label=label, number=number):
-                out, counts = self._scrub(label + number + '. Koniec.')
-                self.assertEqual(out, label + '[PII]. Koniec.')
-                self.assertEqual(counts[kind], 1)
-
-    def test_identifier_context_does_not_eat_prose_or_long_accounts(self):
-        self.assertEqual(self._scrub('PESEL: 44051401457 i coś dalej')[0],
-                         'PESEL: [PII] i coś dalej')
-        for text in ("PESEL wymagany, kod 44051401457", "NIP brak 1234563219",
-                     "REGON\n\n123456786", "PESEL 12345678901234567890",
-                     "Paszport wydany w 2017 roku", "Model ABA400000"):
-            with self.subTest(text=text):
-                self.assertEqual(self._scrub(text)[0], text)
-
-    def test_registration_contact_cues(self):
-        for label in ("Zapisy pod numerem: ", "Rejestracja: pod numerem ",
-                      "Kontakt pod nr. ", "SZYBKI KONTAKTTel. kontaktowy: "):
-            with self.subTest(label=label):
-                out, counts = self._scrub(label + "501 234 567")
-                self.assertEqual(out, label + "[Telefon]")
-                self.assertEqual(counts['phone'], 1)
-
-    def test_contact_cues_do_not_match_other_number_fields(self):
-        for text in ("Sprawa pod numerem 501234567", "Hotel: 501234567",
-                     "Umowa pod numerem 501234567", "Sprawa pod numerem:\n\n501234567",
-                     "Zapisy pod numerem: 501234567 zł",
-                     "Zapisy dotyczą sprawy pod numerem 501234567"):
-            with self.subTest(text=text):
-                self.assertEqual(self._scrub(text)[0], text)
-
-    def test_phone_stops_before_opening_hours(self):
-        for phone in ("513 234 571", "+48 513 234 571", "22 123 45 67"):
-            for hours in (" (9:00-15:00)", " 09:00–15:00", "\t(19:30-20:00)",
-                          " 15.00 - 19.00", " (9.00 – 15.00)"):
-                with self.subTest(phone=phone, hours=hours):
-                    text = f"Telefon: {phone}{hours} mail: a@example.com"
-                    out, counts = self._scrub(text)
-                    self.assertEqual(out, f"Telefon: [Telefon]{hours} mail: [PII]")
-                    self.assertEqual(counts['phone'], 1)
-
-    def test_national_ids_require_explicit_adjacent_labels(self):
-        for label, number, kind in (
-            ("REGON: ", REGON9, "regon"),
-            ("nr REGON ", REGON9, "regon"),
-            ("numer regon:\n", REGON14, "regon"),
-            ("REGON nr: ", REGON9, "regon"),
-            ("NIP = ", NIP, "nip"),
-            ("numer NIP:\n", "PL123-45-63-218", "nip"),
-        ):
-            with self.subTest(label=label):
-                out, counts = self._scrub(label + number)
-                self.assertEqual(out, label + "[PII]")
-                self.assertEqual(counts[kind], 1)
-
-    def test_tariff_codes_are_not_regons(self):
-        # Real EUR-Lex commodity codes happen to pass the REGON checksum.
-        text = "WYKAZ A\n250410000 |\n250490000 |\n250860000 |"
-        out, counts = self._scrub(text)
-        self.assertEqual(counts['regon'], 0)
-        self.assertEqual(out, text)
-
-    def test_numeric_tables_are_not_phones(self):
-        for text in ("Podatek od towarów i usług\n132 165 000\nPodatek akcyzowy\n62 600 000",
-                     "Kwota w EUR\nPrzeniesiona kwota\n+552 977 761",
-                     "CJK 𠎠 132000 203A0 0xF0 0xA0", "Kod 501234567",
-                     "Kod 123456785", "Tabela\n250.000.000\n13.853.000\n1"):
-            with self.subTest(text=text):
-                self.assertEqual(self._scrub(text)[0], text)
-
-    def test_phone_stops_before_next_section(self):
-        for phone in ("601 234 571", "222-345-671", "+48 601 234 571"):
-            text = f"tel. {phone}\n2. Szkoła oferuje zajęcia."
-            out, counts = self._scrub(text)
-            self.assertEqual(out, "tel. [Telefon]\n2. Szkoła oferuje zajęcia.")
-            self.assertEqual(counts['phone'], 1)
-
-    def test_glued_phone_label_and_international_prefix(self):
-        for text, expected in (("Telefon58 234 56 71", "Telefon[Telefon]"),
-                               ("☎ 501 234 567", "☎ [Telefon]"),
-                               ("Kontakt +48 501 234 567", "Kontakt [Telefon]"),
-                               ("Kontakt 0048 501 234 567", "Kontakt [Telefon]")):
-            self.assertEqual(self._scrub(text)[0], expected)
-
-    def test_phone_context_is_bounded(self):
-        for text in ("Telefon jest wymagany.\n\nKod 501234567",
-                     "tel. kod: 501234567",
-                     "telefon " + "tekst " * 20 + "501234567"):
-            with self.subTest(text=text):
-                self.assertEqual(self._scrub(text)[0], text)
-
-    def test_labels_do_not_reach_across_words_or_paragraphs(self):
-        for text in (f"Kod {NIP}", f"NIP wymagany, kod produktu {NIP}",
-                     f"REGON przedsiębiorcy. Kod {REGON9}",
-                     f"REGON\n\n{REGON9}", f"NIP " + " " * 80 + NIP,
-                     f"antyREGON: {REGON9}", f"REGONXYZ: {REGON9}",
-                     f"Kod {REGON14}"):
-            with self.subTest(text=text):
-                out, counts = self._scrub(text)
-                self.assertEqual(counts['nip'] + counts['regon'], 0)
-                self.assertNotIn('[PII]', out)
-
-    def test_foreign_phone_is_not_a_polish_national_id(self):
-        # Synthetic checksum-collision formats formerly became '+49 (0)[PII]' / '+39 [PII]'.
-        for text in ("faks: +49 (0)711 234 56 76", "tel. +39 057123451"):
-            with self.subTest(text=text):
-                out, counts = self._scrub(text)
-                self.assertEqual(out, 'faks: [Telefon]' if text.startswith('faks') else 'tel. [Telefon]')
-                self.assertEqual(counts['nip'] + counts['regon'], 0)
-
-    def test_polish_format_gaps(self):
-        cases = [
-            ("tel. 501\u00a0234\u00a0567", "tel. [Telefon]", "phone"),
-            ("tel. 501\u202f234\u2009567", "tel. [Telefon]", "phone"),
-            ("NIP: 123-45-63-218", "NIP: [PII]", "nip"),
-            ("NIP: PL1234563218", "NIP: [PII]", "nip"),
-            ("NIP: PL123-456-32-18", "NIP: [PII]", "nip"),
-            ("Kontakt: łukasz@example.com", "Kontakt: [PII]", "email"),
-            ("Kontakt: żaneta@żółw.example.com", "Kontakt: [PII]", "email"),
-        ]
-        for raw, expected, kind in cases:
-            with self.subTest(raw=raw):
-                out, counts = self._scrub(raw)
-                self.assertEqual(out, expected)
-                self.assertEqual(counts[kind], 1)
-                self.assertEqual(self._scrub(out), (out, dict.fromkeys(counts, 0)))
-
-    def test_adjacent_phones(self):
-        for separator in (" ", "  ", "\t", "\n"):
-            text = f"tel. 501 234 567{separator}22 123 45 67"
-            out, counts = self._scrub(text)
-            self.assertEqual(out, f"tel. [Telefon]{separator}[Telefon]")
-            self.assertEqual(counts["phone"], 2)
-
-    def test_foreign_ibans(self):
-        # Published example IBANs; numeric and alphanumeric BBANs, various lengths.
-        for iban in ("DE89370400440532013000", "GB82WEST12345698765432",
-                     "FR1420041010050500013M02606", "NO9386011117947",
-                     "UA213223130000026007233566001"):
-            for raw in (iban, iban.lower(), " ".join(iban[i:i+4] for i in range(0, len(iban), 4))):
-                with self.subTest(raw=raw):
-                    out, counts = self._scrub(f"Rachunek: {raw} do wpłat.")
-                    self.assertEqual(out, "Rachunek: [PII] do wpłat.")
-                    self.assertEqual(counts["account"], 1)
-                    self.assertEqual(sum(counts.values()), 1)
-
-    def test_invalid_ibans_are_not_accounts(self):
-        for raw in ("DE88370400440532013000", "DE8937040044053201300",
-                    "DE893704004405320130000", "ZZ89370400440532013000"):
-            with self.subTest(raw=raw):
-                out, counts = self._scrub(raw)
-                self.assertEqual(out, raw)
-                self.assertEqual(counts["account"], 0)
-
-    def test_labelled_identity_documents(self):
-        for label, number in (("Dowód osobisty: ", "ABA300000"),
-                              ("numer dowodu ", "ABA 300000"),
-                              ("dowodu osobistego nr ", "aba-300000"),
-                              ("Paszport nr: ", "AB1234567"),
-                              ("paszportu serii ", "AB 1234567")):
-            with self.subTest(label=label):
-                out, counts = self._scrub(label + number + ".")
-                self.assertEqual(out, label + "[PII].")
-                self.assertEqual(counts["document"], 1)
-
-    def test_conservative_identifier_policy(self):
-        for text in ("Model ABA300000, kod AB1234567", "jan (małpa) example.com",
-                     "Numer 12345678901234567890"):
-            with self.subTest(text=text):
-                self.assertEqual(self._scrub(text)[0], text)
-
-    def test_numeric_clusters_are_not_partially_scrubbed(self):
-        for text in ("Konto: 501 234 567 8901 2345 6789 0123",
-                     "wersja 3.79.25.482243121", "cena 500 100 200 PLN",
-                     "współrzędne 52.1234567890 N", "data 2020 - 01 - 15 rok",
-                     "faktura 1234 5678 9012 3456", "alarmowe:\n112\n997\n999"):
-            with self.subTest(text=text):
-                self.assertEqual(self._scrub(text)[0], text)
-
-    def test_monetary_amounts_survive(self):
-        # Real legal-text failures plus checksum-valid numbers that resemble IDs.
-        for text in ("grzywny do 500\u00a0000\u00a0000 złotych",
-                     "kwoty 159\u00a0179\u00a0632,2 mln zł",
-                     "grzywny do 250 000 000\n złotych",
-                     "wydatki 293.474.478 mln zł",
-                     "kwota 123456785 zł", "kwota 1234563218 PLN",
-                     "kwota 500 100 200 tys. złotych", "kwota 500 100 200,50 EUR",
-                     "kwota 500 100 200 złotego", "USD 500 100 200", "$500 100 200"):
-            with self.subTest(text=text):
-                out, counts = self._scrub(text)
-                self.assertEqual(out, text.replace('\u00a0', ' '))
-                self.assertEqual(sum(counts.values()), 0)
-
-    def test_money_context_does_not_hide_contacts(self):
-        for text, expected in (
-            ("Cena 100 zł, tel. 501 234 567", "Cena 100 zł, tel. [Telefon]"),
-            ("tel. 501 234 567, cena 100 zł", "tel. [Telefon], cena 100 zł"),
-            ("tel. 501 234 567.\nCena 100 zł", "tel. [Telefon].\nCena 100 zł"),
-            ("Kontakt euro@example.com", "Kontakt [PII]"),
-        ):
-            with self.subTest(text=text):
-                self.assertEqual(self._scrub(text)[0], expected)
-
-    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: tel. 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, tel. 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}, REGON {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@example.com 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_survives_but_labelled_krs_is_redacted(self):
-        text = "Kod 02-123 Warszawa, KRS 0000123456, kwota 500,00 zł."
-        out, counts = self._scrub(text)
-        self.assertEqual(out, 'Kod 02-123 Warszawa, KRS [PII], kwota 500,00 zł.')
-        self.assertEqual(counts["phone"], 0)
-        self.assertEqual(counts['krs'], 1)
-
-    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@example.com"
-        out, counts = self._scrub(f"Kontakt: {addr}")
-        self.assertNotIn(addr, out)
-        self.assertEqual(counts["email"], 1)
-        nested = "jan.kowalski+test@subdomain.example.com"
-        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@example.com", PESEL: "{PESEL}")')
-        self.assertNotIn("jan@example.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 234–56-71 od poniedziałku")
-        self.assertIn("[Telefon]", out)
-        self.assertNotIn("234", 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()