#!/usr/bin/env python3
"""Build an auditable corpus of UZP public-procurement rulings (KIO/SO/SA/SN).

Source: https://orzeczenia.uzp.gov.pl - the official decision search service of
the Polish Public Procurement Office (Urzad Zamowien Publicznych). Documents
are official rulings of the National Appeals Chamber (KIO), district courts
(SO), administrative courts (SA) and the Supreme Court (SN) in public
procurement matters. Legal basis: official documents are excluded from
copyright under Polish Copyright Act art. 4(2) (same basis as the SAOS slice).
"""
from __future__ import annotations

import argparse
from collections import Counter
from concurrent.futures import ThreadPoolExecutor, as_completed
from datetime import datetime, timedelta, timezone
import gzip
import hashlib
import html as html_module
import importlib.util
import io
import ipaddress
import json
from pathlib import Path
import re
import shutil
import sys
import threading
import time

import requests

from language_gate import language_vote


SOURCE = "uzp_orzeczenia_pl"
OWN_REPO = "PiotrSty/uzp-orzeczenia-pl"
TARGET = "SlayerLab/polish-dynaword"
BASE = "https://orzeczenia.uzp.gov.pl"
SEARCH_URL = BASE + "/Home/Search"
RESULTS_URL = BASE + "/Home/GetResults"
SOURCE_URL = BASE + "/"
FIELDS = ["id", "text", "source", "added", "created", "token_count", "license", "author"]
UA = "UzpOrzeczeniaCorpusResearch/0.1 (PiotrSty; open research slice)"
LICENSE_LABEL = "public-domain (official documents)"
LICENSE_SPDX = "LicenseRef-Polish-Official-Documents"
LEGAL_BASIS = ("Polish Copyright Act art. 4(2): official documents are not subject to copyright; "
               "UZP search service republishes KIO/SO/SA/SN rulings in public procurement matters")
MIN_TEXT_CHARS = 1_500
PAGE_SIZE = 10  # fixed server-side; #sp-page-size is not a serialized form field
KINDS = ("KIO", "SO", "SA", "SN")

EMAIL_RE = re.compile(r"(?i)\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b")
PHONE_RE = re.compile(r"(?i)(?:\btelefon|\btel\.|\bphone)\s*:?[ \t]*(?:\+48[ \t]*)?\d(?:[ .-]?\d){8}\b")
# Dotted quads are mostly clause numbers ("pkt 1.2.3.4"), CPV/PKWiU codes and table cells, and valid
# IPv6 forms mostly times ("18:12::18") and list colons ("Zadanie 2::"), so an address outside a longer
# dotted chain is redacted only in network context (in_ip_context).
IPV4_RE = re.compile(r"(?<![\w.])(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?!\w|\.\d)")
# Case-sensitive: pypdf reads "Lp." as "Ip."; ":" skips [REDACTED:IP]. Per family: "DHCP IPv6 ... wymaganiu 6.3.1.2".
IPV4_LABEL_RE = re.compile(r"(?<![\w:])IP(?:v4)?(?!\w)")
IPV6_LABEL_RE = re.compile(r"(?<![\w:])IP(?:v6)?(?!\w)")
IP_PREFIX_RE = re.compile(
    r"(?:(?i:\b(?:adres|serwer|host|podsie|router)\w*)\s*[:(–-]?"  # "o adresie X", "serwer: X", "podsieci X", "(router: X"
    r"|\b[a-z0-9-]+(?:\.[a-z0-9-]+)*\.[a-z]{2,6}\s*[(–-]"  # "outlook.com - X", "gessel.pl (X"
    r"|\b\d{1,2}:\d{2}(?::\d{2})?)\s*$")  # log rows "18.11.2020 10:53 X"
IP_SUFFIX_RE = re.compile(r"(?:/\d{1,2}|:\d{1,5})(?!\d)")  # CIDR "X/29", port "X:25"
CLAUSE_PREFIX_RE = re.compile(
    r"(?i)(?:\bpkt|\bppkt|\bpunk[tc]\w*|\bpodpunk\w*|\bust|§|\bnr|\bpoz|\bpozycj\w*|\bpkwiu|\bcpv|\brozdzia\w*|\brysun\w*"
    r"|\btabel\w*|\bzałącznik\w*|\bart|\bczęś\w*|\blit)\W{0,3}$")
IPV6_CANDIDATE_RE = re.compile(r"(?<![\w:])(?:[0-9a-fA-F]{0,4}:){2,}[0-9a-fA-F:.]*(?![\w:])")
NATIONAL_ID_RE = re.compile(r"(?i)\b(PESEL|NIP|REGON)\s*[:=]?\s*\d(?:[ -]?\d){8,13}\b")
BANK_ACCOUNT_RE = re.compile(r"(?<!\d)(?:PL\s*)?\d{2}(?:[ -]?\d){24}(?!\d)")
DETAILS_LINK_RE = re.compile(r'href="/Home/Details/(\d+)"')
RESULT_COUNTS_RE = re.compile(r'value="([\d,]+)"\s+id="resultCounts"')
PDF_LINK_RE = re.compile(r'href="(/Home/PdfContent/(\d+)\?Kind=([A-Z]+))"')
PDF_CREATION_DATE_RE = re.compile(rb"D:\d{14}[+-]\d\d'\d\d'")
# The shipped build's PDFs were rendered (and stamped) in this span, Warsaw summer time, in id order from FIRST_RENDER.
PINNED_RENDERS = (datetime(2026, 9, 10), datetime(2026, 9, 25))
FIRST_RENDER = datetime(2026, 9, 17, 11, 23, 56)
PINNED_RENDER_ZONE = "+02'00'"
SYGN_RE = re.compile(r"^Sygn\.\s*akt\b", re.I)
PAGE_NUM_RE = re.compile(r"^\d{1,4}$")


def now():
    return datetime.now(timezone.utc).isoformat()


def digest(value):
    if not isinstance(value, bytes):
        value = json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":")).encode("utf-8")
    return hashlib.sha256(value).hexdigest()


def save(path, value):
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(json.dumps(value, ensure_ascii=False, sort_keys=True, indent=2) + "\n", encoding="utf-8")


def write_lines(path, rows):
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text("".join(json.dumps(row, ensure_ascii=False, sort_keys=True) + "\n" for row in rows), encoding="utf-8")


def read_lines(path):
    return [json.loads(line) for line in path.read_text(encoding="utf-8").split("\n") if line]


def load(path):
    return json.loads(path.read_text(encoding="utf-8"))


def is_ipv6(value):
    try:
        return ipaddress.ip_address(value.rstrip(".")).version == 6
    except ValueError:
        return False


def in_ip_context(match, label_re=IPV4_LABEL_RE):
    """True when an IPV4_RE or IPv6 candidate match reads as an address: no clause keyword right before
    it, and a label_re match (IP/IPv4 or IP/IPv6) within 80 characters before, an address/server/host/
    subnet/router word, hostname or log-row time right before, or a CIDR suffix or port right after."""
    before = match.string[max(0, match.start() - 80):match.start()]
    if CLAUSE_PREFIX_RE.search(before[-40:]):
        return False
    return bool(label_re.search(before) or IP_PREFIX_RE.search(before[-40:])
                or IP_SUFFIX_RE.match(match.string, match.end()))


def is_ipv6_address(match):
    return is_ipv6(match.group().rstrip(".")) and in_ip_context(match, IPV6_LABEL_RE)


def has_ipv4_address(text):
    return any(in_ip_context(match) for match in IPV4_RE.finditer(text))


def has_ipv6_address(text):
    return any(is_ipv6_address(match) for match in IPV6_CANDIDATE_RE.finditer(text))


def redact_pii(text):
    counts = Counter()

    def replace_ipv6(match):
        if not is_ipv6_address(match):
            return match.group()
        counts["ipv6"] += 1
        return "[REDACTED:IP]" + match.group()[len(match.group().rstrip(".")):]

    def replace_ipv4(match):
        if not in_ip_context(match):
            return match.group()
        counts["ipv4"] += 1
        return "[REDACTED:IP]"

    text = IPV6_CANDIDATE_RE.sub(replace_ipv6, text)
    for name, pattern, replacement in (
        ("email", EMAIL_RE, "[REDACTED:EMAIL]"),
        ("labelled_phone", PHONE_RE, "[REDACTED:PHONE]"),
        ("ipv4", IPV4_RE, replace_ipv4),
        ("national_identifier", NATIONAL_ID_RE, lambda match: match.group(1) + " [REDACTED:ID]"),
        ("account_candidate", BANK_ACCOUNT_RE, "[REDACTED:ACCOUNT]"),
    ):
        text, count = pattern.subn(replacement, text)
        if replacement is not replace_ipv4:  # replace_ipv4 counts only the matches it redacts
            counts[name] += count
    return text, counts


def iso_date(text):
    match = re.match(r"(\d{2})-(\d{2})-(\d{4})", (text or "").strip())
    if match:
        day, month, year = match.groups()
        return f"{year}-{month}-{day}"
    return ""


def strip_html(fragment):
    return html_module.unescape(re.sub(r"\s+", " ", re.sub(r"<[^>]+>", " ", fragment))).strip()


def parse_result_items(page_html):
    """Parse /Home/GetResults response into per-document records."""
    records = []
    for block in re.findall(r'<div class="search-list-item".*?(?=<div class="search-list-item"|$)',
                          page_html, flags=re.S):
        link = DETAILS_LINK_RE.search(block)
        if not link:
            continue
        fields = dict()
        for label, value in re.findall(r"<label>([^<]+)</label>\s*([^<]+)", block):
            fields[label.strip().rstrip(":")] = strip_html(value)
        records.append({
            "doc_id": int(link.group(1)),
            "organ": fields.get("Organ wydający", ""),
            "doc_type": fields.get("Rodzaj dokumentu", ""),
            "signature": fields.get("Sygnatura", ""),
            "issued": fields.get("Data wydania", ""),
        })
    counts = RESULT_COUNTS_RE.search(page_html)
    totals = [int(value) for value in counts.group(1).split(",")] if counts else []
    return records, totals


def parse_counts(page_html):
    """Return dict kind -> count from the resultCounts hidden field."""
    _records, totals = parse_result_items(page_html)
    kinds = ["ALL", "KIO", "SO", "SA", "SN"]
    return {kinds[index]: value for index, value in enumerate(totals)} if totals else {}


def parse_details(page_html, doc_id):
    """Parse /Home/Details/{id} metadata page."""
    pdf = PDF_LINK_RE.search(page_html)
    body = re.sub(r"<script.*?</script>", " ", page_html, flags=re.S)
    fields = {}
    for label, value in re.findall(r"<label>([^<]+)</label>\s*([^<]+)", body):
        fields[label.strip().rstrip(":")] = strip_html(value)
    return {
        "doc_id": doc_id,
        "organ": fields.get("Organ wydający", ""),
        "doc_type": fields.get("Rodzaj dokumentu", ""),
        "issued": fields.get("Data wydania rozstrzygnięcia", ""),
        "chairman": fields.get("Przewodniczący", ""),
        "purchaser": fields.get("Zamawiający", ""),
        "city": fields.get("Miejscowość", ""),
        "signature": fields.get("Sygnatura akt / Sposób rozstrzygnięcia",
                                fields.get("Sygnatura akt / Sygnatura KIO / Sposób rozstrzygnięcia", "")),
        "provisions": fields.get("Kluczowe przepisy ustawy Pzp", ""),
        "pdf_path_url": BASE + pdf.group(1) if pdf else "",
        "pdf_kind": pdf.group(3) if pdf else "",
    }


def session():
    s = requests.Session()
    s.headers.update({"User-Agent": UA})
    s.get(SEARCH_URL, timeout=20)
    return s


def post_results(sess, kind, page, attempts=5):
    data = {"Phrase": "", "Fle": "1", "SCnt": "1", "CountStats": "true",
            "Kind": kind, "Srt": "", "Pg": str(page)}
    for attempt in range(attempts):
        try:
            r = sess.post(RESULTS_URL, data=data, timeout=30)
            if r.status_code in (429, 500, 502, 503, 504):
                time.sleep(2 ** attempt)
                continue
            r.raise_for_status()
            return r.text
        except requests.RequestException:
            if attempt == attempts - 1:
                raise
            time.sleep(2 ** attempt)
    raise RuntimeError("unreachable")


def request(url, attempts=5, timeout=(15, 90), binary=False, sess=None):
    client = sess or requests
    response = None
    for attempt in range(attempts):
        response = client.get(url, headers={"User-Agent": UA}, timeout=timeout)
        if response.status_code not in (429, 500, 502, 503, 504):
            response.raise_for_status()
            return response.content if binary else response.content.decode("utf-8", "replace")
        time.sleep(2 ** attempt)
    response.raise_for_status()


def request_json(url):
    return json.loads(request(url))


def discover(out, workers):
    """Enumerate every document via the kind-filtered result pages."""
    seen = {}
    counts = {}
    for kind in KINDS:
        body = post_results(session(), kind, 1)
        first, totals = parse_result_items(body)
        all_counts = parse_counts(body)
        counts[kind] = all_counts.get(kind, len(first))
        total = counts[kind]
        pages = max(1, -(-total // PAGE_SIZE)) if total else 1
        for record in first:
            record["kind"] = kind
            seen[record["doc_id"]] = record

        def fetch_page(page):
            return page, post_results(session(), kind, page)

        with ThreadPoolExecutor(max_workers=workers) as pool:
            futures = {pool.submit(fetch_page, p): p for p in range(2, pages + 1)}
            for index, future in enumerate(as_completed(futures), 1):
                _, body = future.result()
                for record in parse_result_items(body)[0]:
                    record["kind"] = kind
                    seen[record["doc_id"]] = record
                if index % 200 == 0:
                    print(f"  {kind} {index}/{pages - 1} pages", flush=True)
        print(f"  {kind}: {pages} pages, total {total}", flush=True)
    records = sorted(seen.values(), key=lambda record: record["doc_id"])
    write_lines(out / "source_manifest.jsonl", records)
    selection = {
        "observed_at": now(), "search_url": SEARCH_URL,
        "reported_totals": counts, "enumerated": len(records),
        "per_kind": dict(Counter(record["kind"] for record in records)),
        "selected": len(records),
        "selected_ids": [record["doc_id"] for record in records],
        "source_manifest_sha256": digest((out / "source_manifest.jsonl").read_bytes()),
    }
    save(out / "selection.json", selection)
    print(json.dumps(selection, ensure_ascii=False, indent=2))


def pdf_text(payload):
    """pypdf page texts joined by newlines, and the page count."""
    from pypdf import PdfReader
    reader = PdfReader(io.BytesIO(payload))
    return "\n".join(page.extract_text() or "" for page in reader.pages), len(reader.pages)


def acquire(out, workers):
    selection = load(out / "selection.json")
    manifest = {record["doc_id"]: record for record in read_lines(out / "source_manifest.jsonl")}
    (out / "raw_pages").mkdir(parents=True, exist_ok=True)
    (out / "raw_pdf").mkdir(parents=True, exist_ok=True)
    (out / "raw_text").mkdir(parents=True, exist_ok=True)
    results = []

    def fetch(doc_id):
        record = manifest[doc_id]
        page_path = out / "raw_pages" / f"{doc_id}.html.gz"
        pdf_path = out / "raw_pdf" / f"{doc_id}.pdf"
        text_path = out / "raw_text" / f"{doc_id}.txt"
        if pdf_path.is_file() and text_path.is_file() and page_path.is_file():
            return record, digest(pdf_path.read_bytes()), pdf_path.stat().st_size, \
                digest(text_path.read_bytes()), "cached", json.loads(
                    gzip.decompress(page_path.read_bytes()).decode("utf-8"))["details"]
        sess = session()
        body = request(BASE + f"/Home/Details/{doc_id}", sess=sess)
        details = parse_details(body, doc_id)
        if not details["pdf_path_url"]:
            raise ValueError(f"no PdfContent link on details page: {doc_id}")
        page_path.write_bytes(gzip.compress(json.dumps(
            {"doc_id": doc_id, "details": details}, ensure_ascii=False).encode("utf-8")))
        payload = request(details["pdf_path_url"], binary=True, sess=sess)
        if not payload.startswith(b"%PDF"):
            raise ValueError("not a PDF: " + str(doc_id))
        pdf_path.write_bytes(payload)
        text, pages = pdf_text(payload)
        text_path.write_text(text, encoding="utf-8")
        return record, digest(payload), len(payload), digest(text.encode("utf-8")), str(pages), details

    with ThreadPoolExecutor(max_workers=workers) as pool:
        futures = {pool.submit(fetch, doc_id): doc_id for doc_id in selection["selected_ids"]}
        for index, future in enumerate(as_completed(futures), 1):
            doc_id = futures[future]
            record = manifest[doc_id]
            try:
                record, pdf_sha, pdf_bytes, text_sha, pages, details = future.result()
                results.append({**record, "details": details, "pdf_sha256": pdf_sha,
                                "pdf_bytes": pdf_bytes, "text_sha256": text_sha, "pdf_pages": pages,
                                "pdf_path": f"raw_pdf/{doc_id}.pdf", "text_path": f"raw_text/{doc_id}.txt"})
            except Exception as error:
                results.append({**record, "error": f"{type(error).__name__}: {error}"})
            if index % 100 == 0:
                print(f"  {index}/{len(selection['selected_ids'])}", flush=True)
    results.sort(key=lambda record: record["doc_id"])
    acquisition = {
        "observed_at": now(), "target": selection["selected"],
        "acquired": sum("pdf_sha256" in record for record in results),
        "failed": [record["doc_id"] for record in results if "error" in record],
        "selected": results,
    }
    save(out / "acquisition.json", acquisition)
    print(json.dumps({key: acquisition[key] for key in ("target", "acquired", "failed")},
                     ensure_ascii=False, indent=2))


def restore_render_stamp(payload, pdf_sha256, hint):
    """`payload` with the /CreationDate stamp under which its SHA-256 is `pdf_sha256`, and that stamp's time.

    The service renders every PDF on request and stamps the request time, so an unchanged ruling downloaded
    again differs from its recorded bytes only in that stamp. Times within an hour of `hint` are tried first
    (reacquire() fetches in id order, as the shipped build did), then every second of PINNED_RENDERS."""
    stamps = list(PDF_CREATION_DATE_RE.finditer(payload))
    if len(stamps) != 1:
        raise ValueError(f"{len(stamps)} CreationDate stamps in the PDF")
    start, end = stamps[0].span()
    prefix, suffix = hashlib.sha256(payload[:start]), payload[end:]

    def moments():
        for offset in range(3600):
            yield hint + timedelta(seconds=offset)
            yield hint - timedelta(seconds=offset + 1)
        moment = PINNED_RENDERS[0]
        while moment < PINNED_RENDERS[1]:
            yield moment
            moment += timedelta(seconds=1)

    for moment in moments():
        stamp = (moment.strftime("D:%Y%m%d%H%M%S") + PINNED_RENDER_ZONE).encode("ascii")
        candidate = prefix.copy()
        candidate.update(stamp)
        candidate.update(suffix)
        if candidate.hexdigest() == pdf_sha256:
            return payload[:start] + stamp + suffix, moment
    raise ValueError("no CreationDate in PINNED_RENDERS reproduces the recorded pdf_sha256")


def write_atomic(path, payload):
    """Write through a temporary file, so an interrupted run leaves no truncated file for a resumed run to reuse."""
    part = path.with_name(path.name + ".part")
    part.write_bytes(payload)
    part.replace(path)


def reacquire(out, data, workers):
    """Download the documents of the shipped build in `data` again into `out`, as acquire() stored them then.

    Retained documents must come back as their recorded bytes (restore_render_stamp) and take their metadata
    from the attribution sidecar. Rejected documents have no recorded PDF hash, so their Details page and PDF
    are used as served now. Documents whose acquisition failed stay failed with the recorded error. Files
    already in `out` are reused, so an interrupted run resumes. Writes source_manifest.jsonl, selection.json
    and acquisition.json for build()."""
    attribution = {item["doc_id"]: item for item in read_lines(data / f"{SOURCE}.attribution.jsonl")}
    decisions = read_lines(data / f"{SOURCE}.decisions.jsonl")
    doc_ids = sorted(int(item["id"].rsplit("_", 1)[1]) for item in decisions)
    failed = {int(item["id"].rsplit("_", 1)[1]): item["error"]
              for item in decisions if item["reason"] == "acquisition_failed"}
    for name in ("raw_pages", "raw_pdf", "raw_text"):
        (out / name).mkdir(parents=True, exist_ok=True)
    started, local, hint = now(), threading.local(), [FIRST_RENDER]

    def client():
        if not hasattr(local, "session"):
            local.session = session()
        return local.session

    def fetch(doc_id):
        shipped = attribution.get(doc_id)
        if shipped:
            details = {"doc_id": doc_id, "pdf_path_url": shipped["pdf_url"], **{key: shipped[key] for key in (
                "organ", "doc_type", "issued", "chairman", "purchaser", "signature", "provisions")}}
            record = {key: shipped[key] for key in ("doc_id", "kind", "organ", "doc_type", "signature", "issued")}
        else:
            page_path = out / "raw_pages" / f"{doc_id}.json"
            if not page_path.is_file():
                details = parse_details(request(BASE + f"/Home/Details/{doc_id}", sess=client()), doc_id)
                write_atomic(page_path, json.dumps(details, ensure_ascii=False).encode("utf-8"))
            details = load(page_path)
            record = {"doc_id": doc_id, "kind": details["pdf_kind"],
                      **{key: details[key] for key in ("organ", "doc_type", "signature", "issued")}}
        if doc_id in failed:
            return {**record, "error": failed[doc_id]}
        if not details["pdf_path_url"]:
            raise ValueError(f"no PdfContent link on details page: {doc_id}")
        pdf_path, text_path = out / "raw_pdf" / f"{doc_id}.pdf", out / "raw_text" / f"{doc_id}.txt"
        if pdf_path.is_file():
            payload = pdf_path.read_bytes()
        else:
            payload = request(details["pdf_path_url"], binary=True, sess=client())
            if not payload.startswith(b"%PDF"):
                raise ValueError(f"not a PDF: {doc_id}")
            if shipped:
                if len(payload) != shipped["pdf_bytes"]:
                    raise ValueError(f"{len(payload)} bytes, {shipped['pdf_bytes']} recorded: {doc_id}")
                payload, hint[0] = restore_render_stamp(payload, shipped["pdf_sha256"], hint[0])
            write_atomic(pdf_path, payload)
        if shipped and digest(payload) != shipped["pdf_sha256"]:
            raise ValueError(f"PDF differs from the recorded pdf_sha256: {doc_id}")
        if not text_path.is_file():  # ponytail: pypdf holds the GIL, ~65 documents/min; a process pool if that matters
            write_atomic(text_path, pdf_text(payload)[0].encode("utf-8"))
        return {**record, "details": details, "pdf_sha256": digest(payload), "pdf_bytes": len(payload),
                "pdf_path": f"raw_pdf/{doc_id}.pdf", "text_path": f"raw_text/{doc_id}.txt",
                "text_sha256": digest(text_path.read_bytes())}

    results, errors = [], {}
    with ThreadPoolExecutor(max_workers=workers) as pool:
        futures = {pool.submit(fetch, doc_id): doc_id for doc_id in doc_ids}
        for index, future in enumerate(as_completed(futures), 1):
            try:
                results.append(future.result())
            except Exception as error:
                errors[futures[future]] = f"{type(error).__name__}: {error}"
            if index % 500 == 0:
                print(f"  {index}/{len(doc_ids)} errors={len(errors)}", flush=True)
    if errors:
        save(out / "reacquire_errors.json", errors)
        raise RuntimeError(f"{len(errors)} documents not re-acquired, see {out / 'reacquire_errors.json'}")
    results.sort(key=lambda record: record["doc_id"])
    write_lines(out / "source_manifest.jsonl", [{key: record[key] for key in (
        "doc_id", "kind", "organ", "doc_type", "signature", "issued")} for record in results])
    save(out / "selection.json", {
        "observed_at": started, "search_url": SEARCH_URL,
        "reported_totals": f"pinned to the shipped build ({SOURCE}.decisions.jsonl)",
        "enumerated": len(results), "per_kind": dict(Counter(record["kind"] for record in results)),
        "selected": len(results), "selected_ids": [record["doc_id"] for record in results],
        "source_manifest_sha256": digest((out / "source_manifest.jsonl").read_bytes()),
    })
    save(out / "acquisition.json", {
        "observed_at": started, "target": len(results),
        "acquired": sum("pdf_sha256" in record for record in results),
        "failed": [record["doc_id"] for record in results if "error" in record],
        "selected": results,
    })


def normalize(text):
    import unicodedata
    text = unicodedata.normalize("NFKC", text or "").replace("­", "").replace("​", "")
    text = re.sub(r"[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]", "", text)
    lines = [re.sub(r"[ \t   ]+", " ", line).strip() for line in text.splitlines()]
    # drop repeated running-head signature lines and bare page numbers
    seen_sygn = 0
    kept = []
    for line in lines:
        if SYGN_RE.match(line):
            seen_sygn += 1
            if seen_sygn > 1:
                continue
        if PAGE_NUM_RE.match(line):
            continue
        kept.append(line)
    text = "\n".join(kept)
    text = re.sub(r"(?<=\w)-\n(?=[a-ząćęłńóśźż])", "", text)
    text = re.sub(r"(?<![.!?:;\n])\n(?!\n)(?=[a-ząćęłńóśźż])", " ", text)
    return re.sub(r"\n{3,}", "\n\n", text).strip()


def shingle_sketch(text, limit=5_000):
    words = re.findall(r"\w+", text.casefold())
    hashes = set()
    for index in range(max(0, len(words) - 4)):
        value = " ".join(words[index:index + 5]).encode("utf-8")
        hashes.add(int.from_bytes(hashlib.blake2b(value, digest_size=8).digest(), "big"))
    if len(hashes) > limit:
        return set(sorted(hashes)[:limit])
    return hashes


DF_FRACTION = 0.02  # shingles in >2% of docs are boilerplate (KIO formula openings)


def shingle_document_frequencies(sketches):
    df = Counter()
    for sketch in sketches:
        df.update(sketch)
    return df


def filter_sketch(sketch, df, max_df):
    """Drop high document-frequency shingles (boilerplate) from a sketch."""
    return {h for h in sketch if df[h] <= max_df}


class NearDuplicateIndex:
    def __init__(self):
        self.postings = {}
        self.records = []
        self.comparisons = 0

    @staticmethod
    def prefix(sketch):
        return sorted(sketch)[:len(sketch) - (9 * len(sketch) + 9) // 10 + 1]

    def find(self, sketch):
        candidates = set()
        for value in self.prefix(sketch):
            candidates.update(self.postings.get(value, ()))
        for position in sorted(candidates):
            row_id, other = self.records[position]
            if 10 * min(len(sketch), len(other)) < 9 * max(len(sketch), len(other)):
                continue
            self.comparisons += 1
            intersection = len(sketch & other)
            score = intersection / max(len(sketch) + len(other) - intersection, 1)
            if score >= 0.90:
                return row_id, score
        return None, 0.0

    def add(self, row_id, sketch):
        position = len(self.records)
        self.records.append((row_id, sketch))
        for value in self.prefix(sketch):
            self.postings.setdefault(value, []).append(position)


def audit_target(out):
    info = request_json(f"https://huggingface.co/api/datasets/{TARGET}")
    revision = info["sha"]
    tree = request_json(f"https://huggingface.co/api/datasets/{TARGET}/tree/{revision}?recursive=true&expand=false")
    discussions = request_json(f"https://huggingface.co/api/datasets/{TARGET}/discussions?status=open&p=0")
    paths = sorted(item.get("path", "") for item in tree)
    open_rows = [{"num": item.get("num"), "title": item.get("title"), "status": item.get("status"),
                  "author": item.get("author", {}).get("name")} for item in discussions.get("discussions", [])]
    terms = ("uzp", "kio", "orzeczenia_uzp", "zamowienia_publiczne")
    matches = [path for path in paths if any(term in path.casefold() for term in terms)]
    discussion_matches = [row for row in open_rows if any(term in (row.get("title") or "").casefold()
                                                          for term in terms)]
    report = {
        "target": TARGET, "revision": revision, "last_modified": info.get("lastModified"),
        "tree_paths": len(paths), "source_path_matches": matches, "open_discussions": open_rows,
        "matching_open_discussions": discussion_matches, "source_absent": not matches and not discussion_matches,
        "observed_at": now(),
    }
    save(out / "target_audit.json", report)
    print(json.dumps({"revision": revision, "source_absent": report["source_absent"],
                      "tree_matches": matches, "discussion_matches": discussion_matches}, ensure_ascii=False, indent=2))


def audit_overlap(out):
    """Compare our signatures/ids against the shipped SAOS shard (closest legal corpus)."""
    import pyarrow.parquet as pq
    from huggingface_hub import HfApi, HfFileSystem

    revision = HfApi().dataset_info(TARGET).sha
    remote = f"datasets/{TARGET}@{revision}/data/saos/saos.parquet"
    try:
        with HfFileSystem().open(remote, "rb") as handle:
            table = pq.read_table(handle, columns=["id", "attribution"])
        saos_rows = table.to_pylist()
    except Exception as error:
        saos_rows = []
        print("saos shard unavailable:", error)
    saos_sigs = set()
    for row in saos_rows:
        attribution = row.get("attribution") or ""
        for sig in re.findall(r"[IVXLCDM]*\s*[A-Z][a-zA-Z]*\s*\d+/\d+", attribution):
            saos_sigs.add(sig.strip().casefold())
    manifest = read_lines(out / "source_manifest.jsonl")
    results = []
    for record in manifest:
        sig = (record.get("signature") or "").strip()
        if sig and sig.casefold() in saos_sigs:
            results.append({"doc_id": record["doc_id"], "signature": sig, "kind": record["kind"]})
    report = {
        "target": f"{TARGET}:data/saos", "target_revision": revision,
        "method": "case-normalized signature match against SAOS attribution strings",
        "saos_rows": len(saos_rows), "candidate_records": len(manifest),
        "signature_collisions": len(results),
        "text_overlap": "not tested; target-wide text dedup remains an integration gate",
        "observed_at": now(),
        "colliding_ids": [r["doc_id"] for r in results],
        "collisions": results[:500],
    }
    save(out / "overlap_audit.json", report)
    print(json.dumps({key: report[key] for key in ("target_revision", "saos_rows",
                                                    "candidate_records", "signature_collisions")},
                     ensure_ascii=False, indent=2))


def build(out, added=None):
    import pyarrow as pa
    import pyarrow.parquet as pq
    import tiktoken
    from langid.langid import LanguageIdentifier, model

    acquisition = load(out / "acquisition.json")
    selection = load(out / "selection.json")
    encoder = tiktoken.get_encoding("cl100k_base")
    identifier = LanguageIdentifier.from_modelstring(model, norm_probs=True)
    identifier.set_languages(["pl", "en", "de", "uk", "ru"])
    rows, attribution, decisions = [], [], []
    exact_seen = {}
    near = NearDuplicateIndex()

    # pass 1: document frequencies of shingles, to drop boilerplate-heavy
    # formulas (identical opening lines in ~every KIO ruling) from sketches.
    df_sketches = []
    for record in acquisition["selected"]:
        if "error" in record:
            continue
        raw = (out / record["text_path"]).read_text(encoding="utf-8")
        df_sketches.append((record["doc_id"], shingle_sketch(normalize(raw))))
    df = shingle_document_frequencies(sketch for _, sketch in df_sketches)
    max_df = max(1, int(len(df_sketches) * DF_FRACTION))
    del df_sketches
    print(f"df pass done: {len(df)} distinct shingles, max_df={max_df}", flush=True)
    pii = Counter()
    added = added or acquisition["observed_at"][:10]
    for record in acquisition["selected"]:
        row_id = f"{SOURCE}_{record['doc_id']}"
        if "error" in record:
            decisions.append({"id": row_id, "selected": False,
                              "reason": "acquisition_failed", "error": record["error"]})
            continue
        pdf_path = out / record["pdf_path"]
        text_path = out / record["text_path"]
        if digest(pdf_path.read_bytes()) != record["pdf_sha256"]:
            raise ValueError("PDF checksum mismatch: " + str(record["doc_id"]))
        raw = text_path.read_text(encoding="utf-8")
        text = normalize(raw)
        replacement_count = text.count("\ufffd")
        letters = len(re.findall(r"[A-Za-zĄĆĘŁŃÓŚŹŻąćęłńóśźż]", text))
        language, votes = language_vote(identifier, text)
        reason = ""
        if len(text) < MIN_TEXT_CHARS:
            reason = "too_little_extractable_text"
        elif letters / max(len(text), 1) < 0.55:
            reason = "low_letter_ratio"
        elif replacement_count > 100 or replacement_count / max(len(text), 1) > 0.002:
            reason = "excessive_replacement_characters"
        elif language != "pl":
            reason = "non_polish_text"
        text = text.replace("\ufffd", "[UNREADABLE_GLYPH]")
        text, counts = redact_pii(text)
        pii.update(counts)
        if not reason and len(text) < MIN_TEXT_CHARS:
            reason = "too_little_text_after_redaction"
        exact_key = digest(" ".join(text.casefold().split()).encode("utf-8"))
        duplicate_of, duplicate_score = None, 0.0
        if not reason and exact_key in exact_seen:
            reason, duplicate_of, duplicate_score = "normalized_duplicate", exact_seen[exact_key], 1.0
        if not reason:
            sketch = filter_sketch(shingle_sketch(text), df, max_df)
            if sketch:
                duplicate_of, duplicate_score = near.find(sketch)
                if duplicate_of:
                    reason = "near_duplicate"
        decision = {
            "id": row_id, "selected": not bool(reason), "reason": reason or "include",
            "characters": len(text), "letter_ratio": letters / max(len(text), 1),
            "replacement_characters": replacement_count, "language": language,
            "language_votes": [{"language": lang, "confidence": float(score)} for lang, score in votes],
        }
        if duplicate_of:
            decision.update({"duplicate_of": duplicate_of, "jaccard": duplicate_score})
        decisions.append(decision)
        if reason:
            continue
        exact_seen[exact_key] = row_id
        near.add(row_id, sketch)
        details = record.get("details") or {}
        organ = record.get("organ") or details.get("organ") or "Unknown"
        created = iso_date(record.get("issued") or details.get("issued", ""))
        row = {
            "id": row_id, "text": text, "source": SOURCE, "added": added,
            "created": created, "token_count": len(encoder.encode_ordinary(text)),
            "license": LICENSE_LABEL, "author": organ,
        }
        rows.append(row)
        attribution.append({
            "id": row_id, "doc_id": record["doc_id"], "kind": record["kind"],
            "organ": organ, "doc_type": record.get("doc_type") or details.get("doc_type", ""),
            "signature": record.get("signature") or details.get("signature", ""),
            "issued": record.get("issued") or details.get("issued", ""),
            "chairman": details.get("chairman", ""), "purchaser": details.get("purchaser", ""),
            "provisions": details.get("provisions", ""),
            "landing_url": f"{BASE}/Home/Details/{record['doc_id']}",
            "pdf_url": details.get("pdf_path_url", ""),
            "pdf_sha256": record["pdf_sha256"], "pdf_bytes": record["pdf_bytes"],
            "license": LICENSE_LABEL, "license_spdx": LICENSE_SPDX,
            "legal_basis": LEGAL_BASIS,
            "text_sha256": digest(text.encode("utf-8")),
            "transformations": ["per-document PDF via /Home/PdfContent", "pypdf text extraction",
                                "repeated signature running-head and page-number removal",
                                "Unicode/whitespace normalization", "line-wrap repair",
                                "email/labelled-phone/IP/labelled-national-ID/account-candidate pattern redaction"],
        })
    root = out / "hf_repo"
    (root / "data").mkdir(parents=True, exist_ok=True)
    (root / "artifacts").mkdir(parents=True, exist_ok=True)
    schema = pa.schema([(field, pa.int64() if field == "token_count" else pa.string()) for field in FIELDS])
    pq.write_table(pa.Table.from_pylist(rows, schema=schema), root / "data/train-00000-of-00001.parquet",
                   compression="zstd")
    write_lines(root / "artifacts/attribution.jsonl", attribution)
    write_lines(root / "artifacts/decisions.jsonl", decisions)
    write_lines(root / "artifacts/source_manifest.jsonl", read_lines(out / "source_manifest.jsonl"))
    sample = sorted(rows, key=lambda row: digest(("sample:" + row["id"]).encode("utf-8")))[:12]
    write_lines(root / "artifacts/sample.jsonl", sample)
    save(root / "artifacts/selection.json", selection)
    save(root / "artifacts/acquisition.json", acquisition)
    overlap = load(out / "overlap_audit.json") if (out / "overlap_audit.json").exists() else None
    target_audit = load(out / "target_audit.json") if (out / "target_audit.json").exists() else None
    if overlap:
        save(root / "artifacts/overlap_audit.json", overlap)
    if target_audit:
        save(root / "artifacts/target_audit.json", target_audit)
    stats = {
        "reported_totals": selection["reported_totals"],
        "enumerated": selection["enumerated"], "per_kind": selection["per_kind"],
        "acquired": acquisition["acquired"], "failed": len(acquisition["failed"]),
        "kept": len(rows), "rejected": len(decisions) - len(rows),
        "rejection_reasons": dict(Counter(d["reason"] for d in decisions if not d["selected"])),
        "tokens": sum(row["token_count"] for row in rows),
        "characters": sum(len(row["text"]) for row in rows),
        "license_counts": dict(Counter(row["license"] for row in rows)),
        "sample_count": len(sample), "added": added,
    }
    save(root / "artifacts/stats.json", stats)
    qa = {
        "scope": "all rulings enumerated via /Home/GetResults on orzeczenia.uzp.gov.pl (KIO/SO/SA/SN in public procurement matters)",
        "license_gate": "official documents excluded from copyright under Polish Copyright Act art. 4(2); no per-record license field exists",
        "language_gate": "three-window langid vote (pl/en/de/uk/ru)",
        "pii_pattern_matches": dict(pii),
        "exact_dedup": True,
        "near_dedup": "deterministic prefix-indexed capped 5-word-shingle Jaccard >= 0.90 within source; high document-frequency shingles (>2% of docs, i.e. KIO opening-formula boilerplate) excluded from sketches",
        "near_dedup_comparisons": near.comparisons,
        "saos_overlap": overlap or "pending",
        "cross_source_text_dedup": "pending target integration",
        "limitations": [
            "pypdf extraction may retain layout artifacts; tables may be flattened",
            "pattern checks are not comprehensive de-identification; natural-person names of parties and adjudicators remain part of the official record",
            "official-document status does not cover third-party material quoted inside rulings",
            "sequential IDs contain gaps; enumeration follows the server-side result list, not the ID range",
        ],
    }
    save(root / "artifacts/qa.json", qa)
    protocol_id = "protocol:uzp-orzeczenia-v1"
    run = {
        "id": "run:" + digest({"script": digest(Path(__file__).read_bytes()), "selection": selection,
                               "acquisition": digest(acquisition)}),
        "protocol": protocol_id, "started_at": selection["observed_at"], "finished_at": now(),
        "success": True, "actor": "actor:devin", "stats": stats,
    }
    save(root / "artifacts/run.json", run)
    excluded = {"README.md", "NOTICE.md", "artifacts/checksums.json", "artifacts/ontology.json"}
    checks = {path.relative_to(root).as_posix(): digest(path.read_bytes()) for path in sorted(root.rglob("*"))
              if path.is_file()
              and path.relative_to(root).as_posix() not in excluded
              and not path.relative_to(root).as_posix().startswith("src/")}
    save(root / "artifacts/checksums.json", checks)
    source_version = "version:source:" + digest({"manifest": selection["source_manifest_sha256"]})
    dataset_version = "version:dataset:" + digest(checks)
    selection_evidence = "evidence:selection:" + digest(selection)
    acquisition_evidence = "evidence:acquisition:" + digest(acquisition)
    qa_evidence = "evidence:qa:" + digest(qa)
    evidence = [
        {"id": selection_evidence, "observation_type": "source_inventory_and_selection",
         "artifact": "artifacts/selection.json", "content_address": digest(selection), "produced_by": run["id"]},
        {"id": acquisition_evidence, "observation_type": "pdf_acquisition_and_extraction",
         "artifact": "artifacts/acquisition.json", "content_address": digest(acquisition), "produced_by": run["id"]},
        {"id": qa_evidence, "observation_type": "source_qa", "artifact": "artifacts/qa.json",
         "content_address": digest(qa), "produced_by": run["id"]},
    ]
    overlap_evidence = None
    if overlap:
        overlap_evidence = "evidence:overlap:" + digest(overlap)
        evidence.append({"id": overlap_evidence, "observation_type": "metadata_overlap_audit",
                         "artifact": "artifacts/overlap_audit.json", "content_address": digest(overlap),
                         "produced_by": run["id"]})
    target_evidence = None
    if target_audit:
        target_evidence = "evidence:target:" + digest(target_audit)
        evidence.append({"id": target_evidence, "observation_type": "target_registry_audit",
                         "artifact": "artifacts/target_audit.json", "content_address": digest(target_audit),
                         "produced_by": run["id"]})
    ontology = {
        "schema": "slayer-research-ontology-profile-v1",
        "objects": [{"id": "object:source:uzp-orzeczenia", "type": "Source"},
                    {"id": "object:dataset:uzp-orzeczenia-pl", "type": "Dataset"}],
        "versions": [{"id": source_version, "object": "object:source:uzp-orzeczenia",
                      "content_address": source_version.rsplit(":", 1)[-1]},
                     {"id": dataset_version, "object": "object:dataset:uzp-orzeczenia-pl",
                      "content_address": dataset_version.rsplit(":", 1)[-1]}],
        "protocols": [{"id": protocol_id,
                       "procedure": "enumerate /Home/GetResults per kind; fetch /Home/Details metadata and /Home/PdfContent PDF; pypdf extraction; running-head/page-number removal; normalization; PII patterns; exact and near dedup"}],
        "runs": [run], "evidence": evidence,
        "claims": [
            {"id": "claim:enumeration-complete",
             "statement": f"The result-list enumeration observed {selection['enumerated']} documents across kinds {selection['per_kind']} matching server-reported totals {selection['reported_totals']}.",
             "supported_by": [selection_evidence],
             "falsification_condition": "The preserved manifest does not reproduce the counts or the server totals differ."},
            {"id": "claim:official-documents",
             "statement": "Retained records are official rulings of KIO, district courts, administrative courts and the Supreme Court in public procurement matters, excluded from copyright under Polish Copyright Act art. 4(2).",
             "supported_by": [selection_evidence, qa_evidence],
             "falsification_condition": "A retained record is shown to be a non-official or non-ruling document."},
            {"id": "claim:slice-retention",
             "statement": f"The slice retained {stats['kept']} records after text QA and within-source deduplication.",
             "supported_by": [acquisition_evidence, qa_evidence],
             "falsification_condition": "The decisions, Parquet rows, or checksums do not reproduce the retention count."},
            {"id": "claim:training-value-untested",
             "statement": "Net corpus novelty and training benefit remain untested hypotheses.",
             "supported_by": [qa_evidence] + ([overlap_evidence] if overlap_evidence else []),
             "falsification_condition": "Target-wide text deduplication and controlled ablations establish those properties."},
        ],
        "actors": [{"id": "actor:piotrsty", "type": "Contributor"},
                   {"id": "actor:uzp", "type": "Organization"}, {"id": "actor:devin", "type": "Agent"}],
        "relations": [{"source": dataset_version, "predicate": "DERIVED_FROM", "target": source_version},
                      {"source": dataset_version, "predicate": "GENERATED_BY", "target": run["id"]}] +
                     ([{"source": dataset_version, "predicate": "VALIDATED_AGAINST",
                        "target": f"hf:dataset:{TARGET}@{target_audit['revision']}"}] if target_audit else []),
        "pending": ["cross-source text deduplication", "benchmark contamination check",
                    "third-party quoted material review",
                    "controlled training ablation"],
    }
    save(root / "artifacts/ontology.json", ontology)
    card = f"""---
license: other
language:
- pl
task_categories:
- text-generation
configs:
- config_name: default
  data_files:
  - split: train
    path: data/train-00000-of-00001.parquet
---

# UZP Orzeczenia - Polish public-procurement rulings (KIO/SO/SA/SN)

Polish-language rulings from the official decision search service of the Public
Procurement Office (https://orzeczenia.uzp.gov.pl/): the National Appeals Chamber
(KIO), district courts (SO), administrative courts (SA) and the Supreme Court
(SN) in public procurement matters.

- Enumerated documents: {stats['enumerated']:,} (per kind: {stats['per_kind']})
- Acquired PDFs: {stats['acquired']:,} (failed: {stats['failed']})
- Retained after text QA and within-source deduplication: {stats['kept']:,}
- Characters: {stats['characters']:,}
- Tokens: {stats['tokens']:,} (`cl100k_base` proxy)
- License label: `{LICENSE_LABEL}`

## Provenance and rights

Rulings are official documents excluded from copyright under Polish Copyright
Act art. 4(2) (LicenseRef-Polish-Official-Documents). No Creative Commons grant
is asserted. Each row links to its `/Home/Details` landing URL, PDF URL and
checksum; `artifacts/attribution.jsonl` carries organ, document type,
signature, issue date, chairman, purchaser and key provisions per record.

## Processing and limitations

Text was extracted from the service PDFs with pypdf, then normalized:
repeated signature running-heads and page numbers removed, Unicode/whitespace
normalization, line-wrap repair, and limited email/phone/IP/identifier/account
pattern redaction. Language is checked independently across three text windows;
exact and deterministic near deduplication run within the source.

Pattern checks are not comprehensive de-identification: names of parties,
adjudicators and quoted natural persons remain part of the official record.
PDF-derived text may retain layout artifacts and flattened tables.

## Review artifacts

See `artifacts/sample.jsonl`, `attribution.jsonl`, `decisions.jsonl`,
`source_manifest.jsonl`, `overlap_audit.json`, `stats.json`, `qa.json`,
`checksums.json`, `run.json` and `ontology.json`.
"""
    (root / "README.md").write_text(card, encoding="utf-8")
    (root / "NOTICE.md").write_text(
        "# Attribution and legal basis\n\n"
        "Source: UZP decision search service, https://orzeczenia.uzp.gov.pl/ "
        "(Urzad Zamowien Publicznych / Public Procurement Office).\n\n"
        "Records are official rulings (KIO, district courts, administrative courts, Supreme Court) in public "
        "procurement matters. Working basis: Polish Copyright Act art. 4(2) excludes official documents from "
        "copyright; no per-record license field exists on the service. This is our assessment, not legal advice. "
        "Consult `artifacts/attribution.jsonl` for per-record provenance (organ, signature, issue date, URLs, checksums).\n\n"
        "Preparation: Piotr Styla with Devin (Cognition). Changes: service-PDF text extraction, running-head and "
        "page-number removal, Unicode/whitespace normalization, line-wrap repair, limited email/phone/IP/"
        "identifier/account pattern redaction, language/quality filtering and within-source deduplication. "
        "Names of parties and adjudicators remain as part of the official record. No endorsement by UZP, KIO "
        "or the courts is implied.\n",
        encoding="utf-8",
    )
    print(json.dumps(stats, ensure_ascii=False, indent=2))


def verify(out):
    import pyarrow.parquet as pq
    import tiktoken

    root = out / "hf_repo"
    table = pq.read_table(root / "data/train-00000-of-00001.parquet")
    rows = table.to_pylist()
    stats = load(root / "artifacts/stats.json")
    decisions = read_lines(root / "artifacts/decisions.jsonl")
    attribution = read_lines(root / "artifacts/attribution.jsonl")
    sample = read_lines(root / "artifacts/sample.jsonl")
    assert table.column_names == FIELDS
    assert len(rows) == stats["kept"] == len(attribution)
    assert sum(item["selected"] for item in decisions) == len(rows)
    encoder = tiktoken.get_encoding("cl100k_base")
    assert sum(row["token_count"] for row in rows) == stats["tokens"]
    for row in rows:
        assert len(encoder.encode_ordinary(row["text"])) == row["token_count"]
    assert all(row["source"] == SOURCE and row["license"] == LICENSE_LABEL for row in rows)
    assert all(EMAIL_RE.search(row["text"]) is None for row in rows)
    assert all(len(row["text"]) >= MIN_TEXT_CHARS for row in rows)
    by_id = {row["id"]: row for row in rows}
    assert len(sample) == stats["sample_count"] and all(by_id[row["id"]] == row for row in sample)
    # reconstruct every retained text from the extracted source
    for att in attribution:
        doc_id = att["doc_id"]
        raw = (out / "raw_text" / f"{doc_id}.txt").read_text(encoding="utf-8")
        text = normalize(raw).replace("\ufffd", "[UNREADABLE_GLYPH]")
        text, _ = redact_pii(text)
        assert text == by_id[att["id"]]["text"], f"text mismatch: {doc_id}"
        assert digest(text.encode("utf-8")) == att["text_sha256"]
    ontology = load(root / "artifacts/ontology.json")
    evidence = {item["id"] for item in ontology["evidence"]}
    assert all(item["falsification_condition"] and set(item["supported_by"]) <= evidence for item in ontology["claims"])
    checks = load(root / "artifacts/checksums.json")
    assert all((root / path).is_file() and digest((root / path).read_bytes()) == checksum
               for path, checksum in checks.items())
    for item in ontology["evidence"]:
        artifact = root / item["artifact"]
        assert artifact.is_file() and digest(load(artifact)) == item["content_address"]
    # residual PII pattern scan
    residual = {
        name: sum(bool(scan(row["text"])) for row in rows)
        for name, scan in {"email": EMAIL_RE.search, "labelled_phone": PHONE_RE.search,
                           "ipv4": has_ipv4_address, "ipv6": has_ipv6_address}.items()
    }
    report = {"verified": True, "residual_patterns": residual, **stats}
    save(out / "validation_report.json", report)
    print(json.dumps(report, ensure_ascii=False, indent=2))


# G1 personal-data pass (polish-dynaword-v2#112). NERGAL with person names masks every person; this ruling's bench
# and clerk act in an official capacity and stay. Sole traders and civil partnerships trade under their own names, so
# their firm names and street addresses are masked too, and a sentence linking a person to a criminal or health fact
# is replaced whole. Run `g1` on the shard before the release upload, which must then pass mask_names=false so the
# pipeline does not mask the bench again.
NERGAL_VERSION = "2.0.6"
NERGAL_REVISION = "ce25bc0c3b8fb36e1f2c88dfc2a01750bc742efc"
G1_BATCH = 64  # texts per NERGAL call, as in dynaword-pipeline's pii_mask stage
G1_TRANSFORMATION = (f"G1 personal-data pass: NERGAL {NERGAL_VERSION} with person names, this ruling's bench and "
                     "clerk kept; sole-trader and civil-partnership firm names and street addresses masked; "
                     "sentences linking a person to criminal or health data replaced")
FIRM_TAG, ADDRESS_TAG, SPECIAL_TAG = "[FIRM]", "[ADDRESS]", "[REDACTED:SPECIAL]"
UP, LO = "A-ZĄĆĘŁŃÓŚŹŻ", "a-ząćęłńóśźż"
TAG_RE = re.compile(r"\[(?:PERSON|PII|PHONE|FIRM|ADDRESS|UNREADABLE_GLYPH|REDACTED:[A-Z_]+)\]")
SPLIT_LETTER_RE = re.compile(r"(?<=\w) ([ąćęłńóśźżĄĆĘŁŃÓŚŹŻ]) (?=\w)")  # pypdf output such as "Kowa ń czyk"
NAME_WORD_RE = re.compile(rf"[{UP}][{LO}]+(?:-[{UP}][{LO}]+)*")
ROLE_RE = re.compile(r"\b(?:Przewodnicząc[ya]|Członkowie|Członek|Członkini|Sędziowie|Sędzia|Protokolant\w*)\b")
HEADER_END_RE = re.compile(r"\bpo\s+rozpoznaniu|\bpo\s+rozpatrzeniu|\brozpoznawszy|\bna\s+(?:rozprawie|posiedzeniu)\b"
                           r"|\borzeka\b|\bpostanawia\b")
# pypdf often puts a court's role labels apart from the names ("Przewodniczący\nSędziowie:\nProtokolant:" first, the
# names later): a judge's or court secretary's title is then the only label. "SO", "SA" and "SR" only at a line start.
# Up to three name words on the title's line; the line's lower-case words end them ("Nowak aplikant radcowski"). name_key
# joins a split capital to the word before it ("Agnieszka Ł ozińska" -> "AgnieszkaŁozińska"), so the space is optional.
BENCH_TITLE_RE = re.compile(rf"(?:\bSS[AONR]|^[ \t]*S[AOR])\b\.?(?:[ \t]*\(?del\.?\)?)?[ \t]+"
                            rf"|\b(?:st\.[ \t]*|starsz\w*[ \t]+)?sekr(?:\.|etarz\w*)[ \t]*[sS]ąd(?:\.|ow\w*)?[ \t]*"
                            rf"(?=[{UP}])", re.M)
BENCH_TITLE_NAMES_RE = re.compile(rf"{NAME_WORD_RE.pattern}(?: ?{NAME_WORD_RE.pattern}){{0,2}}")
# A court's covering letter is signed by a secretary who is not this ruling's clerk ("Z upoważnienia Kierownika
# Sekretariatu sekretarz sądowy ...", "Na zarządzenie Sędziego st. sekr. sąd. ...").
LETTER_SIGNATURE_RE = re.compile(r"(?i:zarządzen\w*\s+sędziego|kierownika\s+sekretariatu)\W*$")
SOLE_TRADER_RE = re.compile(r"(?i)działalnoś\w*\s+(?:gospodarcz\w*(?:\s+\S+){0,6}?\s+)?(?:pod\s+(?:firmą|nazwą)|p\.\s?n\.|pn\.)"
                            r"|wspólni\w*\s+spółki\s+cywilnej(?:\s+pod\s+(?:firmą|nazwą)|\s+p\.\s?n\.)?")
SC_RE = re.compile(r"\b[sS]\.\s?[cC]\.(?!\w)|\bSpółka\s+Cywilna\b")
QUOTE_RE = re.compile(r"(?:[„\"“]|,,)[^„”\"“\n]{0,120}[”\"“]")
# A firm name ends at a comma, a colon ("K-BUD:\n„W związku", "TRAK LINE i:\n2.1."), a bracketed alias ("[dalej:"), a
# blank line, a numbered point, a postcode, a street, its seat ("w Poznaniu"), the next clause, a lower-case word after
# the owner's initials or name ("A.D. na podstawie", "[PERSON] od") and a sentence end (firm_after). A dash ends it
# only before a lower-case word or a role ("– dalej", "– Odwołujący"): "ZAT - BUD", "Firma Geodezyjna - Jan Nowak"
# and "Usługi Leśne – W.Z." are names.
FIRM_END_RE = re.compile(rf"[,;(]|(?:\s+i)?:\s|\s[\[{{](?=dalej|zwan)"
                         rf"|\s[–—-]\s+(?=[{LO}]|(?:Odwołując|Zamawiając|Przystępując|Wykonawc|Izb|Sąd)\w*)"
                         rf"|\n\s*\n|\n\s*\d+[.)]\s|\s\d{{2}}[^\S\n]?[-–]\s?\d{{3}}\b|\s(?:ul|al|Al|pl|os)\.|\swe?\s+(?=[{UP}])"
                         rf"|(?<=[{UP}]\.)\s+(?=[{LO}])|(?<=\[PERSON\])\s+(?=[{LO}])"
                         r"|\s(?:z\s+siedzib\w*|z/s|w\s+postępowaniu|przy\s+udziale|orzeka|postanawia|zgłaszając\w*"
                         r"|wni(?:ósł|osł\w*|esion\w*)|przeciwko|NIP|REGON|KRS|reprezentowan\w*|zwan\w*|dalej|oraz|przy)\b")
# not a firm name's last word before its seat ("X.Y. Consulting z siedzibą", "A.B. Transport w Kielcach")
SENTENCE_START_RE = re.compile(rf"\s*[{UP}][{LO}]+\s+(?!z\s+siedzib|z/s\b|we?\s+[{UP}])[{LO}]")
# A firm name before "s.c." starts after a comma, a dash, a blank line, a sentence end or a lower-case word ("w
# ofercie", "przez", "oraz").
FIRM_START_RE = re.compile(rf"[,;:()]|\s[–—-]\s|\n\s*\n|[.!?]\s+(?=[{UP}][{LO}]{{2,}}\s)|(?<![\w.])(?:[{LO}]{{2,}}|i|z)\s")
# Where the parties' list moves on to the next party or the contracting authority: addresses past it are not the firm's
# ("obciąża Gminę X, ul. ..., na rzecz [PERSON] prowadzącego działalność"). A semicolon before a postcode is inside one
# address ("ul. Długa 98; 46-099 Ozimek").
ADDRESS_STOP_RE = re.compile(r";(?!\s*\d{2}[^\S\n]?[-–]?\s?\d{3}\s)|\n\s*\d+[.)]\s"
                             r"|\b(?:w\s+postępowaniu|zamawiając\w*|przeciwko|przystępując\w*|na\s+rzecz|przy\s+udziale)\b")
QUOTED_BEFORE_RE = re.compile(r"[„\"“][^„”\"“\n]{1,120}[”\"“]\s*$")
# A house number may carry letters ("B1/g27", "17i/37", "12 B/1") and a flat ("/lok. 25", "m. 4"). A street name may run onto
# the next line, but not past a blank one.
NUMBER = r"[A-Z]?\d+(?:[a-zA-Z]|[^\S\n][A-Z](?=\s?/))?(?:\s?/\s?[a-zA-Z]?\d+[a-zA-Z]?)?(?:(?:,?\s*|\s?/\s?)(?:lok\.|m\.)\s*\d+[a-zA-Z]?)?(?!\d)"
STREET = (r"(?:\b(?:ul|Ul|al|Al|pl|Pl|os)\.|\b(?:ulica|ulicy|aleja|alei|plac|placu|osiedle|Ulica|Ulicy|Aleja|Alei|Aleje"
          rf"|Osiedle)\b)\s*(?:[^,;\n]|\n(?![^\S\n]*\n)){{1,50}}?\s{NUMBER}")
# a town may be hyphenated ("Kamień-Zdrój", "Polanica-\nZdrój", "Nowa Wieś - Las", not "Kraków - Wykonawca") and its
# second word may start the next line before a comma ("Zielona\nGóra,"); a postcode's hyphen may be spaced, an en dash
# or followed by a line break ("41 - 499", "32 – 499", "05-\n899")
NOT_ROLE = r"(?!(?:Odwołując|Zamawiając|Przystępując|Wykonawc|Izb|Sąd|Spółk|Gmin|Powiat|Skarb|Konsorcj|Pełnomocni)\w*)"
TOWN = rf"{NOT_ROLE}[{UP}][{LO}]+(?:-\n?[{UP}]?[{LO}]+|[^\S\n]?[–-][^\S\n]?{NOT_ROLE}[{UP}][{LO}]+)*"
TOWNS = rf"{TOWN}(?:[^\S\n]+{TOWN}|\n[^\S\n]*{TOWN}(?=[,.;)]))?"
POSTCODE_DIGITS = r"\d{2}[^\S\n]?[-–]\s?\d{3}"
POSTCODE = rf"\b{POSTCODE_DIGITS}\s+{TOWNS}"
# after a street the postcode may follow a semicolon, a bracket or the village it serves, or lack its hyphen ("ul.
# Kwiatowa 4c, 42798 Olszówko", "ul. Polna 92, Jeżówko 06-499 Ciechanów"); a town may follow with no postcode ("ul.
# Polna 2, Kraków w postępowaniu")
STREET_POSTCODE = rf"\s*[,;(]?\s*(?:{TOWN}[^\S\n]+)?(?:{POSTCODE}|\b\d{{5}}\s+{TOWNS})"
STREET_TOWN = rf",[^\S\n]*{TOWNS}(?=[^\S\n]*(?:[,.;)\n]|$)|[^\S\n]+[{LO}])"
# after a postcode, a street may lack its number ("62-099 Grodzisk, ul. Zdrój")
STREET_NAME = rf"\b(?:ul|al|pl|os)\.[^\S\n]*[{UP}][\w.-]*(?:[^\S\n]+[{UP}][\w.-]*){{0,3}}"
# a village has no street: "Dąbrowa 7a", "Dąbrowa nr 7", "Dąbrowa pod numerem 7", "Nowa Wieś\n12", before or after its
# postcode
LINE_SPACE = r"(?:[^\S\n]+|[^\S\n]*\n[^\S\n]*)"
VILLAGE = rf"{TOWN}(?:[^\S\n]+{TOWN})?(?:[^\S\n]+(?:nr\.?|pod\s+numerem))?{LINE_SPACE}{NUMBER}"
ADDRESS_RE = re.compile(rf"{STREET}(?:{STREET_POSTCODE}|{STREET_TOWN})?"
                        rf"|{POSTCODE}(?:\s*,?\s*(?:{STREET}|{VILLAGE}|{STREET_NAME})|[^\S\n]+(?:nr\.?[^\S\n]*)?{NUMBER})"
                        rf"|{VILLAGE}\s*[,.;]?\s*\(?\s*{POSTCODE}")
# a person's own address right after their name ("[PERSON], ul. Polna 1, 00-001 X", "[PERSON] (zam. ...")
PERSON_ADDRESS_RE = re.compile(rf"\[PERSON\]\s*[,(]\s*(?:(?:zam\.|zamieszkał\w*|adres\w*(?:\s+do\s+doręczeń)?:?)\s*)?"
                               rf"({ADDRESS_RE.pattern})")
# A trading name directly followed by its owner's initials, with no cue, as in party and consortium lists
# ("Wykonawcę EDUWAVE N.M., ul. ...", "1)\nAgro-Bór M.P. (ul. ..."). Two initials, the second may be hyphenated
# ("M. K.-W."), not a company form (S.A., S.C., S.K., S.J., B.V., N.V., A.S.) and not part of a longer letter run
# ("P.H.U."). The name is the run of name tokens before them:
# capitalised or quoted words, dotted letter runs, "&" and dashes, back to the first other token, a role word or a
# blank line. It must hold a quote, a trade noun, an upper-case word other than an official acronym, or start a
# numbered list item.
INITIAL_PAIR = rf"[{UP}]\.[^\S\n]?(?:[–-][^\S\n]?)?[{UP}]\.(?:[–-][{UP}]\.)?"
INITIALS_RE = re.compile(rf"(?<![\w.])(?<![{UP}]\.\s){INITIAL_PAIR}(?![\w.]|\s?[{UP}]\.)")
NEXT_INITIALS_RE = re.compile(rf"\s+{INITIAL_PAIR}(?!\w)")
# initials followed by a surname and a company form are a partnership's name ("F. Ź. Sp.J.", "K. S. Wrzosowscy Sp. j.")
COMPANY_AFTER_RE = re.compile(rf"[”\"“]?,?\s*(?:(?:[{UP}]\.\s?){{1,3}},?\s*|[{UP}][\w-]*,?\s*){{0,4}}"
                              r"(?i:sp\.|spółk|s\.\s?a\.|s\.\s?k\.)")
COMPANY_FORMS = frozenset("SA SC SK SJ BV NV AS".split())
NAME_TOKEN_RE = re.compile(rf"(?:[„\"“”'–-]|,,)*[{UP}][\w'’&+-]*[„\"“”']*|(?:[{UP}]\.){{1,4}}|&|[–—-]|\[PERSON\]")
NAME_STOP_RE = re.compile(r"(?i:(?:wykonawc|odwołując|zamawiając|przystępując|uczestni|konsorcj|pełnomocni|członk"
                          r"|przewodnicząc|sędzi|protokolant|prezes|dyrektor|kierowni|właściciel|wspólni|lider|oferent|radc|adwokat"
                          r"|mecenas|prokurator|świad|biegł|skarżąc|wnosząc)\w*|pan(?:a|u|em|ie|i|ią|owie)?)"
                          r"|SS[AONR]|KIO|UZP|SIWZ|SWZ|PZP|NIP|REGON|KRS|CEIDG|VAT|ZUS|KRUS|PLN|JEDZ|ESPD|OPZ|PFU|BZP|TED"
                          r"|UE|RP|NSA|WSA|TSUE|SN|SA|SO|UZASADNIENIE|WYROK|POSTANOWIENIE|SENTENCJA")
TRADE_NOUN_RE = re.compile(r"(?i)(?:firm|przedsiębiorstw|zakład|usług|gospodarstw|biur|agencj|pracowni|hurtowni|sklep"
                           r"|studi|warsztat|kancelari)\w*")
LIST_ITEM_END_RE = re.compile(r"(?:^|\s)(?:\d{1,2}[.)]|\[\d{1,2}\])\s*$")
# a party-role word or an owner's name with a bracket right before a trading name ("wykonawcy\nX A.B.", "[PERSON] (X A.B.")
PARTY_BEFORE_RE = re.compile(r"(?i:(?:wykonawc|odwołując|przystępując|oferent|uczestni|konsorcj|lider|partner|firm)\w*"
                             r"|z\s+udziałem|przy\s+udziale)\s*:?\s*$|\[PERSON\]\s*\($")
# An owner's name with a trading name before it ("„X” [PERSON]", "Zakład Usług X [PERSON]") or after it ("[PERSON]
# Przedsiębiorstwo X", "[PERSON] „X”")
PERSON_RUN_RE = re.compile(r"\[PERSON\](?:[^\S\n]*\[PERSON\])*")
# After a sole trader's firm name, initials may come after a comma or "w" and a few words ("X, handel drewnem A.B.",
# "X w Sprzedaży Drewna A.B.")
TAIL_STOP = r"(?:przez|reprezentowan|zwan|dalej|wspóln|oraz|prowadząc|działaj|zam|zamieszkał|siedzib|adres)"
FIRM_TAIL_RE = re.compile(rf"(?:,|\s+we?)\s+(?:(?:(?!{TAIL_STOP})[{UP}{LO}][{LO}]*\s+){{0,4}}{INITIAL_PAIR}(?![\w.])"
                          rf"|(?:[{UP}][{LO}]+\s+){{1,4}}\[PERSON\])")
# one initial left after a name that ends with the other ("X F.\n\nŚ."), and an estate ("X A.B. w spadku")
SECOND_INITIAL_RE = re.compile(rf"(?<![\w.])[{UP}]\.(\s+[{UP}]\.)(?![\w.])")
IN_ESTATE_RE = re.compile(r"[^\S\n]+w[^\S\n]+spadku\b")
# A later mention may use an alias given after the firm ("KROBUD ... T.G. (dalej: Krobud)", "zwana dalej: „X” albo
# „Odwołującym”") or a distinctive part of its name alone: a quoted part or an upper-case word or run of words. A role
# word ("Wykonawca", "Odwołujący") is not an alias, and a part made of trade words only ("PPHU", "SERVICE") is not
# distinctive.
DALEJ_RE = re.compile(r"\b(?:zwan\w*\s+)?dalej(?:\s+(?:również|także|też|łącznie))?(?:\s+jako)?\s*[:–-]?\s*")
ALIAS_RE = re.compile(rf"(?:[„\"“]|,,)\s*([^„”\"“\n]{{1,80}}?)\s*[”\"“]|([{UP}][^()\[\]{{}},;:„”\"“\n]{{0,60}}?)"
                      r"(?=\s*[)\]},;]|\s+(?:lub|albo|bądź)\s|\n)")
ALIAS_JOIN_RE = re.compile(r"\s*(?:,|/|\b(?:lub|albo|bądź|względnie|oraz|i)\b)\s*")
# The "dalej" clause must follow the firm name, its seat and its address: one after other words names another party.
SEAT_RE = re.compile(rf"(?:z\s+siedzibą|z\s+s\.|zam\.|zamieszkał\w*)?\s*(?:w|we)\s+[{UP}][\w-]+(?:\s+[{UP}][\w-]+)?")
ALIAS_ROLE_RE = re.compile(r"(?i)(?:wykonawc|odwołuj|przystępuj|zamawiając|uczestni|konsorcj|firm|spółk|przedsiębiorc"
                           r"|oferent|lider|partner|pełnomocni|stron|wnosząc|skarżąc|pozwan|powod|powód|zainteresowan)\w*\s*")
CAPS_RUN_RE = re.compile(rf"(?<![\w.])[{UP}][{UP}0-9]+(?:(?:\s*[&–-]\s*|[ \t]+|\n)[{UP}][{UP}0-9]+)*(?![\w.])")
QUOTED_PART_RE = re.compile(r"(?:[„\"“]|,,)\s*([^„”\"“\n]{2,80}?)\s*[”\"“]")
TRADE_WORD_RE = re.compile(r"(?:firm|przedsiębiorstw|zakład|usług|handl|transport|produkc|budowl|ogólnobudowl|wielobranż"
                           r"|budownictw|spółk|cywiln|konsorcj|gospodarstw|hurtowni|sklep|warsztat|pracowni|biur|agencj"
                           r"|ochron|centrum|studi|odwołując|zamawiając|przystępując|wykonawc|uczestni|polsk|grup|serwis"
                           r"|servic|securit|consult|system|solution|international|holding|partner|lider|leśn|ogrod)\w*"
                           r"|pphu|phu|fhu|fphu|pph|puh|fuh|ppuh|phup|zphu|zuh|zul|pw|ph|fh|pu|fu|group|company|team"
                           r"|design|invest|export|import|trans|bud|eko|eco|med|auto|tech|plus|max|poland|euro|pol")
TRAILING_INITIALS_RE = re.compile(rf"(?:[\s,]*(?:[{UP}]\.|[–-]|\[PERSON\]))+$")
LEADING_INITIALS_RE = re.compile(rf"^(?:(?:[{UP}]\.|\[PERSON\])[\s,–-]*)+")
ENDINGS = "(?:u|a|em|ie|owi|ą|ę|y|i|om|ów|ach|ami)?"
PERSON_REF_RE = re.compile(rf"\[PERSON\]|(?<!\w)[{UP}]\.\s?[{UP}]\.(?<!S\.A\.)(?<!S\. A\.)(?<!S\.C\.)(?<!S\.K\.)(?<!S\. K\.)|\b[Pp]a(?:n|na|nu|nem|ni|nią)\b")
CRIMINAL_RE = re.compile(
    r"(?i:wyrok\w*\s+(?:nakazow|skazując)\w*|\bskaza(?:ny|na|ni|nego|nej|nych|nym|nemu|no|nie|nia|niu|niem)\b"
    r"|\bskazując\w*|akt\w*\s+oskarżenia|\boskarż(?:on|en)\w*|postępowa\w*\s+przygotowawcz\w*|\bśledztw\w*"
    r"|\b(?:nie)?karaln\w*|krajow\w*\s+rejestr\w*\s+karn\w*|\bprzestęp(?!uj)\w*|\bpodejrzan\w*"
    r"|\bprokurat(?!\w*\s+(?:krajow|regionaln|okręgow|rejonow|generaln))\w*"
    r"|kodeks\w*\s+karn\w*)|(?<!\w)k\.\s?k\.|\bKRK\b|\bDs\.\s*\d|\b[IVX]+\s+(?:K|Ka|AKa|Kp|Kz|AKz)\s+\d+/\d+")
# "k.k." in lower case only: "K. K." is a person's initials. "przestępując-" is OCR for "przystępując-". A named
# prosecutor's office ("Prokuratura Okręgowa w ...") is a contracting authority, not a criminal matter. The one-word
# health cues are lower case only: capitalised ("Centrum Leczenia Chorób Płuc") they are almost always an institution's
# name, about 920 of the shard's 1,000 capitalised uses.
HEALTH_RE = re.compile(
    r"(?i:(?<!osób\s)(?<!dla\s)niepełnospraw\w*|zwolnieni\w*\s+lekarsk\w*|zaświadczeni\w*\s+lekarsk\w*|orzeczeni\w*\s+lekarsk\w*"
    r"|stan\w*\s+zdrowia|niezdolnoś\w*\s+do\s+pracy|\buzależnieni\w*|\bniepoczytaln\w*)"
    r"|\bchorob(?!ow)\w*|\bchorób\b|\bchor(?:y|ego|emu|ym|ej|zy|ował\w*|uje\w*|ując\w*)\b|\bleczeni(?:e|a|u|em)\b|\bhospitaliz\w*")
SENTENCE_END_RE = re.compile(rf"[.!?;](?=\s+[\"„(\[]?[0-9{UP}])")
SPECIAL_MAX = 1000  # characters; the longest special sentence labelled in the sample has 863
# Where a ruling's layout starts a new unit although no sentence ends: a numbered, lettered or dashed point at the start
# of a line, a blank line before a capital, digit or bracket, and the "orzeka" / "postanawia" / "UZASADNIENIE" lines.
# Only units longer than SPECIAL_MAX are cut there (headers and operative parts have no full stops); pypdf also puts
# blank lines inside sentences ("oświadczył,\n\nże"), so shorter units stay whole. A part still too long is cut at
# its commas, semicolons and colons.
LAYOUT_BREAK_RE = re.compile(rf"\n(?=[ \t]*(?:\d{{1,2}}[.)]|\(\d{{1,2}}\)|[a-z]\)|[-–•])\s)|\n[ \t]*\n(?=\s*[\[(0-9{UP}])"
                             r"|\n(?=[ \t]*(?:orzeka|postanawia|UZASADNIENIE|Uzasadnienie)\b)|(?<=orzeka)[ \t]*\n"
                             r"|(?<=postanawia)[ \t]*\n")
CLAUSE_BREAK_RE = re.compile(r"(?<=[,;:])\s")  # the last resort for a part still longer than SPECIAL_MAX
ABBREVIATIONS = frozenset("r ust pkt art nr poz sygn dz u lit tj tzw tzn ok ul al pl os zm prof dr mgr inż ws sp o.o p "
                          "s.a s.c p.n pn k ds zł gr godz tel ww jw np m.in itd itp wg lok str zob por cyt red sekr "
                          "sso ssa ssn apl adw im św".split())


def name_key(text):
    return SPLIT_LETTER_RE.sub(r"\1", " ".join(text.split()))


def name_words(text):
    return {word.casefold() for word in NAME_WORD_RE.findall(name_key(text))}


def bench_names(text):
    """Name words of this ruling's judges and clerk: the role entries of the header, which ends at the hearing clause,
    and the names after a judge's or court secretary's title in the first 3,000 characters."""
    return role_names(text) | title_names(text)


def role_names(text):
    header = name_key(text[:3000])
    first = ROLE_RE.search(header, 0, 1200)
    if first is None:
        return set()
    end = HEADER_END_RE.search(header, first.end())
    header = header[first.start():end.start() if end else first.end() + 600]
    roles = list(ROLE_RE.finditer(header))
    names = set()
    for role, following in zip(roles, roles[1:] + [None]):
        names |= name_words(header[role.end():following.start() if following else len(header)][:120])
    return names


def title_names(text):
    head = "\n".join(name_key(line) for line in text[:3000].splitlines())
    names = set()
    for title in BENCH_TITLE_RE.finditer(head):
        if LETTER_SIGNATURE_RE.search(head, max(0, title.start() - 80), title.start()):
            continue
        found = BENCH_TITLE_NAMES_RE.match(head, title.end())
        if found:
            names |= {word.casefold() for word in NAME_WORD_RE.findall(found[0]) if not ROLE_RE.fullmatch(word)}
    return names


def private_names(text, spans, bench):
    """NERGAL person spans minus the bench (every name word on it) and minus spans over a placeholder."""
    tags = [match.span() for match in TAG_RE.finditer(text)]
    private, kept = [], 0
    for span in spans:
        if any(span["start"] < b and a < span["end"] for a, b in tags):
            continue
        words = name_words(text[span["start"]:span["end"]])
        if words and words <= bench:
            kept += 1
        else:
            private.append(span)
    return private, kept


def unquoted(pattern, window):
    quoted = [match.span() for match in QUOTE_RE.finditer(window)]
    return [match for match in pattern.finditer(window) if not any(a <= match.start() < b for a, b in quoted)]


def firm_after(text, start, limit=200):
    """Firm name from `start` to the first terminator outside quotes (comma, seat, street, postcode, next clause) or
    sentence end; none (an empty span) unless it starts with a capital, a digit, a quote or the owner's name
    ("pod nazwą [PERSON] Zakład Usługowy")."""
    while start < len(text) and (text[start].isspace() or text[start] in ":–—-"):
        start += 1
    window = text[start:start + limit]
    if not re.match(rf"[{UP}0-9„\"“']|,,|\[PERSON\]", window):
        return start, start
    ends = [match.start() for match in unquoted(FIRM_END_RE, window)]
    # before the full stop of a sentence. One right after a capital ("P.P.H.U. „ZORVEX”", "B.M. Happy Catering") or in a
    # run of dots (a name anonymised as "G........ K.......") is part of the name, unless a sentence follows ("QVD. Za
    # bezzasadny", "A.B. Odwołujący wniósł").
    ends += [end - 1 for _, end in sentences(window)[:-1]
             if not re.search(rf"(?:[{UP}]|\.\.)$", window[:end - 1]) or SENTENCE_START_RE.match(window, end)]
    stop = min(ends) if ends else (window.rfind(" ") if len(window) == limit else len(window))
    return start, start + len(window[:stop].rstrip())


def firm_before(text, marker, end, limit=120):
    """Firm name ending with the "s.c." marker at text[marker:end]: a quoted name right before it, else back to the
    last boundary outside quotes."""
    window = text[max(0, end - limit):end]
    before = window[:len(window) - (end - marker)]
    quoted = QUOTED_BEFORE_RE.search(before)  # „ABC-BUD” s.c.: the quoted name alone
    starts = unquoted(FIRM_START_RE, window)
    start = end - len(window) + (quoted.start() if quoted else starts[-1].end() if starts else 0)
    while start < end and text[start].isspace():
        start += 1
    return start, end


def has_words(value):
    return len(re.sub(r"\W", "", TAG_RE.sub("", value))) >= 3


def letters(value):
    return len(re.findall(r"[^\W\d_]", TAG_RE.sub("", value)))


def address_window(text, start, end):
    """The part around a firm name that describes the same party: back to 200 and on to 250 characters, cut where the
    text moves on to another party or the contracting authority."""
    stops = list(ADDRESS_STOP_RE.finditer(text, max(0, start - 200), start))
    after = ADDRESS_STOP_RE.search(text, end, min(len(text), end + 250))
    return stops[-1].end() if stops else max(0, start - 200), after.start() if after else min(len(text), end + 250)


def name_before(text, end, limit=160):
    """Start of the run of NAME_TOKEN_RE tokens that ends at `end` (`end` itself if there is none)."""
    start, offset = end, max(0, end - limit)
    for token in reversed(list(re.finditer(r"[^\s()]+", text[offset:end]))):
        word = token.group()
        if word == "i" and start < end:  # inside a name ("Hydraulika i Ogrzewnictwo"), not at its start
            continue
        if (not NAME_TOKEN_RE.fullmatch(word) or NAME_STOP_RE.fullmatch(word.strip("„\"“”',"))
                or re.search(r"\n[ \t]*\n|[()]", text[offset + token.end():start])):
            break
        start = offset + token.start()
    return start


def initials_firms(text):
    """(start, end) of each trading name directly followed by its owner's initials (INITIALS_RE)."""
    found = []
    for match in INITIALS_RE.finditer(text):
        if re.sub(r"\W", "", match.group()) in COMPANY_FORMS or COMPANY_AFTER_RE.match(text, match.end()):
            continue
        start = name_before(text, match.start())
        name = TAG_RE.sub("", text[start:match.start()])
        if has_words(name) and (LIST_ITEM_END_RE.search(text[max(0, start - 12):start])
                                or PARTY_BEFORE_RE.search(text, max(0, start - 40), start) or trading_name(name)):
            found.append((start, initials_end(text, match)))
        # initials first in a numbered list of parties ("2)\nA.B. Zakład Usług Leśnych (ul. ...")
        elif LIST_ITEM_END_RE.search(text[max(0, match.start() - 12):match.start()]):
            after, end = firm_after(text, match.end())
            if has_words(text[after:end]) and trading_name(text[after:end]):
                found.append((match.start(), end))
    return found


def trading_name(name):
    """A quote, a trade noun or an upper-case word other than an official acronym."""
    words = [word.strip("„\"“”',") for word in name.split()]
    return bool(re.search(r"[„\"“”]|,,", name) or any(TRADE_NOUN_RE.fullmatch(word) for word in words)
                or any(word.isupper() and len(re.sub(r"\W", "", word)) >= 3 and not NAME_STOP_RE.fullmatch(word)
                       for word in words))


def person_firms(text):
    """(start, end) of each trading name right before an owner's name (to its end) or right after it: one before must
    hold a quote, start with a trade noun and have two words, or follow a party word and have two words or be one
    upper-case word; one after must start with a trade noun and have two words, or be quoted and not a role word."""
    found = []
    for run in PERSON_RUN_RE.finditer(text):
        start = name_before(text, run.start())
        name = TAG_RE.sub("", text[start:run.start()])
        words = [word.strip("„\"“”',") for word in name.split()]
        # after a party word, two capitalised words or one upper-case word are a firm with its owner ("firmy XYZ
        # [PERSON]"); one capitalised word alone is too often something else
        if has_words(name) and (re.search(r"[„\"“”]|,,", name) or len(words) >= 2 and TRADE_NOUN_RE.fullmatch(words[0])
                                or PARTY_BEFORE_RE.search(text, max(0, start - 40), start)
                                and (len(words) >= 2 or words[0].isupper())):
            found.append((start, run.end()))
        after, end = firm_after(text, run.end())
        name = text[after:end]
        words = name.split()
        quoted = QUOTED_PART_RE.match(name)
        if (len(words) >= 2 and TRADE_NOUN_RE.fullmatch(words[0])
                or quoted and has_words(quoted.group(1)) and not ALIAS_ROLE_RE.match(quoted.group(1))):
            found.append((after, end))
    return found


def with_tail(text, end):
    """`end` moved past FIRM_TAIL_RE."""
    tail = FIRM_TAIL_RE.match(text, end)
    return tail.end() if tail else end


def initials_end(text, match):
    """End of initials matched in `text`, before their last dot when a sentence follows ("A.B. Odwołujący wniósł")."""
    return match.end() - 1 if SENTENCE_START_RE.match(text, match.end()) else match.end()


def with_initials(text, end):
    """`end` moved past initials that directly follow a firm name ("Lingwa Studio s.c. M.R. W.T.")."""
    while (match := NEXT_INITIALS_RE.match(text, end)) is not None:
        end = initials_end(text, match)
        if end < match.end():
            break
    if (second := SECOND_INITIAL_RE.match(text, end - 2)) and second.start(1) == end:
        end = initials_end(text, second)
    estate = IN_ESTATE_RE.match(text, end)
    return estate.end() if estate else end


def aliases(text, start, end, stop):
    """Aliases given in a "dalej" clause that follows a firm name's `end` before `stop`, minus role words."""
    clause = DALEJ_RE.search(text, end, stop)
    if clause is None or re.search(r"[^\W\d_]", re.sub(r"\b(?:NIP|REGON|KRS)\b", "", SEAT_RE.sub(
            "", ADDRESS_RE.sub("", TAG_RE.sub("", text[end:clause.start()]))))):
        return []
    found, at = [], clause.end()
    while at is not None and (match := ALIAS_RE.match(text, at)):
        found.append(match.group(1) or match.group(2))
        join = ALIAS_JOIN_RE.match(text, match.end())
        at = join.end() if join and join.end() > match.end() else None
    names = []
    for alias in found:
        bare = alias
        while (role := ALIAS_ROLE_RE.match(bare)) and role.end() > 0:
            bare = bare[role.end():]
        # "konsorcjum Zdzimar", "wykonawcą X": the party's name, which need not be this firm's
        if bare != alias and not re.search(loose(bare), text[start:end], re.IGNORECASE):
            continue
        alias = bare
        if has_words(alias) and re.match(rf"[{UP}0-9]", alias):
            names.append(alias.strip())
    return names


def name_units(value):
    """Parts of a firm name that a later mention may use alone: quoted parts, upper-case runs and their upper-case
    words of five or more letters, unless made of trade words only or shorter than four letters."""
    value = TAG_RE.sub(" ", value)
    units = {match.group(1) for match in QUOTED_PART_RE.finditer(value)}
    for run in CAPS_RUN_RE.finditer(value):
        units.add(run.group())
        units |= {word for word in re.findall(rf"[{UP}]{{5,}}", run.group())}
    return {unit for unit in units if distinctive(unit)}


def distinctive(value):
    """At least four letters and not made of trade words only ("Zakład Usług Leśnych")."""
    return len(re.sub(r"\W", "", TAG_RE.sub("", value))) >= 4 and not trade_words_only(value)


def trade_words_only(value):
    return all(TRADE_WORD_RE.fullmatch(word.casefold()) for word in re.findall(r"\w+", TAG_RE.sub(" ", value)))


def loose(value):
    """Pattern for `value` with any whitespace, a dash spaced or not, and any or no quote marks; a single word of five
    or more characters also with a case ending ("Krobud" -> "Krobudem")."""
    tokens = re.findall(r",,|[„”\"“]|[–—-]|[^\s„”\"“–—-]+", value)
    parts = ["(?:[„”\"“]|,,)?" if token in {",,", "„", "”", "\"", "“"} else "[–—-]" if token in "–—-"
             else re.escape(token) for token in tokens]
    pattern = r"\s*".join(parts)
    if len(tokens) == 1 and len(value) >= 5:
        pattern = re.escape(value) + ENDINGS
    return rf"(?<!\w){pattern}(?!\w)"


def firm_spans(text):
    """(start, end, tag): [FIRM] for a sole trader's or civil partnership's firm name, with initials that follow it, and
    for a trading name followed by initials (initials_firms); [ADDRESS] for street addresses of the same party
    (address_window); then every other occurrence of those strings in the ruling, of the aliases given after a firm
    name, of the distinctive parts of its name (name_units) and of the name without its initials, unless a company
    form follows."""
    spans, found = [], []
    for cue in SOLE_TRADER_RE.finditer(text):
        start, end = firm_after(text, cue.end())
        found.append((start, with_tail(text, end) if end > start else end, cue.start()))
    found += [firm_before(text, *marker.span()) + (marker.start(),) for marker in SC_RE.finditer(text)]
    found += [(start, end, None) for start, end in initials_firms(text) + person_firms(text)]
    names = set()
    for start, end, cue in found:
        # no cue: the addresses before a trading name are another party's
        window = address_window(text, cue, end) if cue is not None else (start, address_window(text, start, end)[1])
        # after a cue, any letter is the firm's name ("pod firmą D.M.", "pod firmą „C.”")
        if has_words(text[start:end]) or (cue is not None and letters(text[start:end])):
            end = with_initials(text, end)
            spans.append((start, end, FIRM_TAG))
            names |= set(aliases(text, start, end, window[1])) | name_units(text[start:end])
            # the name without its initials or its owner, as a later mention may give it
            bare = TRAILING_INITIALS_RE.sub("", text[start:end])
            names |= {name for name in (bare, LEADING_INITIALS_RE.sub("", bare))
                      if name != text[start:end] and distinctive(name)}
        spans += [(*match.span(), ADDRESS_TAG) for match in ADDRESS_RE.finditer(text, *window)]
    spans += [(*match.span(1), ADDRESS_TAG) for match in PERSON_ADDRESS_RE.finditer(text)]
    values = {(text[a:b], tag) for a, b, tag in spans} | {(name, FIRM_TAG) for name in names}
    for value, tag in values:
        # "[PERSON]", "„C.”", "Zakład": every person, letter C or other firm
        if tag == FIRM_TAG and (letters(value) < 2 or trade_words_only(value)):
            continue
        # a mention followed by a company form names a company of the same name ("X Polska Sp. z o.o."); one followed
        # by initials takes them ("XYZ M. R.")
        pattern = loose(value) if tag == FIRM_TAG else rf"(?<!\w){re.escape(value)}(?!\w)"
        spans += [(match.start(), with_initials(text, match.end()) if tag == FIRM_TAG else match.end(), tag)
                  for match in re.finditer(pattern, text)
                  if tag != FIRM_TAG or not COMPANY_AFTER_RE.match(text, match.end())]
    return spans


def replace_regions(text, regions):
    """Each (start, end, tag) of `regions` (in text order, not overlapping) -> its tag."""
    out, last = [], 0
    for start, end, tag in regions:
        out += [text[last:start], tag]
        last = end
    return "".join(out) + text[last:]


def firm_regions(text):
    """firm_spans in text order; a span inside a longer one that starts earlier goes with it."""
    regions, last = [], 0
    for start, end, tag in sorted(firm_spans(text), key=lambda span: (span[0], -span[1])):
        if start >= last:
            regions.append((start, end, tag))
            last = end
    return regions


def mask_firms(text):
    """firm_regions -> their tags."""
    regions = firm_regions(text)
    tags = Counter(tag for _, _, tag in regions)
    return replace_regions(text, regions), tags[FIRM_TAG], tags[ADDRESS_TAG]


def sentences(text):
    """(start, end) of each sentence. A full stop after an abbreviation, an initial or a number does not end one."""
    spans, start = [], 0
    for match in SENTENCE_END_RE.finditer(text):
        before = text[start:match.start()].split()
        word = before[-1].lstrip("(„\"") if before else ""
        if match.group() == "." and (word.casefold() in ABBREVIATIONS or word.isdigit() or re.fullmatch(f"[{UP}]", word)):
            continue
        spans.append((start, match.end()))
        start = match.end()
    return spans + [(start, len(text))]


def short_parts(text, start, end, breaks=(LAYOUT_BREAK_RE, CLAUSE_BREAK_RE)):
    """text[start:end] as one part if it has at most SPECIAL_MAX characters, else cut at the first of `breaks`, and
    each piece still too long at the next one."""
    if end - start <= SPECIAL_MAX or not breaks:
        return [(start, end)]
    cuts = [start] + [match.start() for match in breaks[0].finditer(text, start, end) if match.start() > start]
    return [part for a, b in zip(cuts, cuts[1:] + [end]) for part in short_parts(text, a, b, breaks[1:])]


def special_spans(text):
    """(start, end) of each unit that names a person ([PERSON], initials, pan/pani) next to a criminal or health cue.
    A sentence longer than SPECIAL_MAX is cut into short_parts first, and a part with the cue goes together with a
    neighbouring part that names the person ("informacji z KRK w zakresie:\na) M.W. ...")."""
    spans = []
    for start, end in sentences(text):
        parts = short_parts(text, start, end)
        person = [bool(PERSON_REF_RE.search(text, a, b)) for a, b in parts]
        cue = [bool(CRIMINAL_RE.search(text, a, b) or HEALTH_RE.search(text, a, b)) for a, b in parts]
        hit = [p and c for p, c in zip(person, cue, strict=True)]
        for i in range(len(parts) - 1):
            if (person[i] and cue[i + 1]) or (cue[i] and person[i + 1]):
                hit[i] = hit[i + 1] = True
        spans += [part for part, h in zip(parts, hit, strict=True) if h]
    return spans


def special_regions(text):
    """special_spans units as (start, end, SPECIAL_TAG), each without its leading whitespace."""
    return [(end - len(text[start:end].lstrip()), end, SPECIAL_TAG) for start, end in special_spans(text)]


def mask_special(text):
    """Each special_spans unit -> SPECIAL_TAG (with the unit's leading whitespace kept)."""
    regions = special_regions(text)
    return replace_regions(text, regions), len(regions), sum(end - start for start, end, _ in regions)


def g1_rules(text):
    """The G1 rules applied after NERGAL: firms and addresses, and special-category sentences. Both are found on the
    same text, so initials that a firm tag takes still name the person for the special rule; a firm or address that
    overlaps a special unit goes into it."""
    regions = []
    for start, end, tag in sorted(firm_regions(text) + special_regions(text)):
        if regions and start < regions[-1][1]:
            # firm regions do not overlap each other, nor do special units: one of the two is special
            previous_start, previous_end, _ = regions.pop()
            regions.append((previous_start, max(previous_end, end), SPECIAL_TAG))
        else:
            regions.append((start, end, tag))
    tags = Counter(tag for _, _, tag in regions)
    special_chars = sum(end - start for start, end, tag in regions if tag == SPECIAL_TAG)
    return replace_regions(text, regions), {"firm": tags[FIRM_TAG], "address": tags[ADDRESS_TAG],
                                            "special_sentences": tags[SPECIAL_TAG], "special_chars": special_chars}


def load_nergal(path, device=None, dtype="float32"):
    """(module, model) for NERGAL from a local snapshot directory of the pinned revision, with the person-name model."""
    path = Path(path).resolve()
    if path.name != NERGAL_REVISION or not (path / "nergal.py").is_file():
        raise SystemExit(f"--nergal must be the SlayerLab/NERGAL snapshot directory of revision {NERGAL_REVISION}")
    sys.path.insert(0, str(path))  # nergal.py imports scrub_pii from its own directory
    spec = importlib.util.spec_from_file_location("nergal", path / "nergal.py")
    module = importlib.util.module_from_spec(spec)
    sys.modules["nergal"] = module
    spec.loader.exec_module(module)
    if module.VERSION != NERGAL_VERSION:
        raise SystemExit(f"NERGAL {module.VERSION} found, {NERGAL_VERSION} expected")
    return module, module.Nergal.from_pretrained(str(path), device=device, dtype=dtype, local_files_only=True, names=True)


def g1_names(module, nergal, texts):
    """(text, counts) per text: NERGAL's scrub_many with the bench taken out of the person spans. scrub_many has no
    keep-list, so this repeats its three steps and filters the names in between."""
    rows = []
    for text, model_spans, name_spans in zip(texts, nergal.predict_many(texts), nergal.names.spans_many(texts),
                                             strict=True):
        private, kept = private_names(text, name_spans, bench_names(text))
        masked, info = module.scrub_spans(text, nergal.rule_spans(text), model_spans, threshold=nergal.threshold,
                                          module=nergal._scrub, name_spans=private)
        rows.append((masked, {"person": info["person"], "pii": info["pii"], "phone": info["phone"],
                              "bench_kept": kept}))
    return rows


def write_as_before(path, text):
    """Write `text` with the line endings `path` has now (the committed shard uses CRLF)."""
    path.write_text(text, encoding="utf-8", newline="\r\n" if b"\r\n" in path.read_bytes() else "\n")


def json_text(value):
    return json.dumps(value, ensure_ascii=False, sort_keys=True, indent=2) + "\n"


def jsonl_text(rows):
    return "".join(json.dumps(row, ensure_ascii=False, sort_keys=True) + "\n" for row in rows)


def shard_paths(data):
    """The committed shard files in `data` (data/uzp_orzeczenia_pl) by suffix."""
    return {name: data / f"{SOURCE}.{name}" for name in ("parquet", "attribution.jsonl", "decisions.jsonl",
                                                          "sample.jsonl", "stats.json", "qa.json", "md", "checksums.json")}


def refresh_sidecars(path, rows, transformation=None):
    """Point the text-derived sidecars of the shard at `rows`, the rows now in its parquet: attribution text hashes
    (recording `transformation` when given), sample rows, and the token and character counts in stats.json and the
    datasheet. Nothing is written unless every datasheet count is found. Returns the stats before and after."""
    by_id = {row["id"]: row for row in rows}
    attribution = read_lines(path["attribution.jsonl"])
    for item in attribution:
        item["text_sha256"] = digest(by_id[item["id"]]["text"].encode("utf-8"))
        if transformation:
            item["transformations"].append(transformation)
    sample = [by_id[item["id"]] for item in read_lines(path["sample.jsonl"])]
    old = load(path["stats.json"])
    stats = {**old, "characters": sum(len(row["text"]) for row in rows), "tokens": sum(row["token_count"] for row in rows)}
    md = path["md"].read_text(encoding="utf-8")
    for label, key in (("Proposed tokens", "tokens"), ("Characters", "characters")):
        # the lookahead keeps "1,234" from matching the start of "1,234,567"
        md, found = re.subn(rf"^- {label}: {old[key]:,}(?![\d,])", f"- {label}: {stats[key]:,}", md, flags=re.MULTILINE)
        if found != 1:
            raise SystemExit(f"{path['md'].name}: expected one '- {label}: {old[key]:,}' line")
    write_as_before(path["attribution.jsonl"], jsonl_text(attribution))
    write_as_before(path["sample.jsonl"], jsonl_text(sample))
    write_as_before(path["stats.json"], json_text(stats))
    write_as_before(path["md"], md)
    return old, stats


def refresh_checksums(checksums):
    """Recompute every entry of the shard's checksums.json from the files next to it."""
    write_as_before(checksums, json_text({name: digest((checksums.parent / name).read_bytes()) for name in load(checksums)}))


def read_cache(cache, rows):
    """Finished g1_names results by id; a partial last line (an interrupted run) is dropped, and a result for a
    different input text stops the run."""
    if not cache.exists():
        return {}
    content = cache.read_text(encoding="utf-8")
    lines = content.split("\n")[:-1]
    if not content.endswith("\n"):
        cache.write_text("".join(line + "\n" for line in lines), encoding="utf-8")
    done = {item["id"]: item for item in map(json.loads, lines)}
    source = {row["id"]: digest(row["text"].encode("utf-8")) for row in rows}
    stale = [key for key, item in done.items() if source.get(key) != item["source_sha256"]]
    if stale:
        raise SystemExit(f"{cache} holds results for other texts, e.g. {stale[0]}; use a new --cache")
    return done


def g1(out, nergal_path, cache, device=None, dtype="float32", batch=G1_BATCH, load=load_nergal, model_spans=None):
    """Apply G1 in place to the committed shard directory `out` (data/uzp_orzeczenia_pl), refresh every sidecar
    that depends on the text and record the new slice version in the ontology manifest. NERGAL's results (g1_names)
    go to `cache` as they are made, so an interrupted run resumes; g1_rules runs when the shard is assembled, so a
    change to the rules needs no new NERGAL run.
    `model_spans` describes where the model's spans came from when `load` serves a stored pass instead of running
    NERGAL; qa.json records it."""
    import pyarrow as pa
    import pyarrow.parquet as pq
    import tiktoken

    path = shard_paths(out)
    qa = json.loads(path["qa.json"].read_text(encoding="utf-8"))
    if "g1" in qa:
        raise SystemExit(f"G1 already applied at {qa['g1']['ran_at']}")
    started, shipped = now(), shipped_version(out, digest(path["parquet"].read_bytes()))
    table = pq.read_table(path["parquet"])
    rows = table.to_pylist()
    done = read_cache(cache, rows)
    todo = [row for row in rows if row["id"] not in done]
    if todo:
        module, nergal = load(nergal_path, device, dtype)
        with cache.open("a", encoding="utf-8") as handle:
            for i in range(0, len(todo), batch):
                part = todo[i:i + batch]
                for row, (text, counts) in zip(part, g1_names(module, nergal, [r["text"] for r in part]), strict=True):
                    done[row["id"]] = {"id": row["id"], "source_sha256": digest(row["text"].encode("utf-8")),
                                       "text": text, "counts": counts}
                    handle.write(json.dumps(done[row["id"]], ensure_ascii=False) + "\n")
                handle.flush()
                print(f"g1 {len(done)}/{len(rows)}", flush=True)
    encoder = tiktoken.get_encoding("cl100k_base")
    totals, changed = Counter(), 0
    for row in rows:
        text, rule_counts = g1_rules(done[row["id"]]["text"])
        changed += text != row["text"]
        row["text"], row["token_count"] = text, len(encoder.encode_ordinary(text))
        totals.update({**done[row["id"]]["counts"], **rule_counts})
    pq.write_table(pa.Table.from_pylist(rows, schema=table.schema), path["parquet"], compression="zstd")
    _, stats = refresh_sidecars(path, rows, G1_TRANSFORMATION)
    qa["g1"] = {"nergal": NERGAL_VERSION, "nergal_revision": NERGAL_REVISION, "device": device or "auto",
                "dtype": dtype, "ran_at": now(), "cache_step": "g1_names", "documents_changed": changed,
                "counts": dict(sorted(totals.items())), **({"model_spans": model_spans} if model_spans else {})}
    write_as_before(path["qa.json"], json_text(qa))
    record_version(shipped, digest(path["parquet"].read_bytes()), G1_PROTOCOL, "run:uzp-orzeczenia-g1", started, stats)
    refresh_checksums(path["checksums.json"])
    print(json.dumps(qa["g1"], ensure_ascii=False, indent=2))


SLICE_OBJECT = "object:dataset:uzp-orzeczenia-pl-dynaword-slice"
G1_PROTOCOL = {
    "id": "protocol:uzp-orzeczenia-g1-v1",
    "procedure": "src/build_uzp_orzeczenia_pl.py g1: the G1 personal-data pass (NERGAL's person names with the "
                 "bench and clerk kept, then the firm, address and special-category rules) applied in place to every "
                 "text of the shipped slice, with the document set, decisions and metadata unchanged",
}
REBUILD_PROTOCOL = {
    "id": "protocol:uzp-orzeczenia-rebuild-v1",
    "procedure": "src/build_uzp_orzeczenia_pl.py rebuild: the shipped documents downloaded again (retained PDFs "
                 "restored to their recorded pdf_sha256), built with the current redact_pii and installed over the "
                 "shipped slice with the document set, decisions and metadata unchanged",
}


def shipped_version(data, sha):
    """The ontology manifest of the shard in `data` and what a new version of it builds on: (manifest path, manifest,
    the version of the shipped parquet `sha`, the slice-counts evidence its claims cite, the targets that version was
    validated against). Read before anything is written, so a manifest without them stops a run untouched."""
    manifest_path = data.parents[1] / "artifacts" / f"{SOURCE}_ontology_manifest.json"
    manifest = load(manifest_path)
    cited = {item for claim in manifest["claims"] for item in claim["supported_by"]}
    version = next((item["id"] for item in manifest["versions"]
                    if item["object"] == SLICE_OBJECT and item["content_address"] == sha), None)
    stats_evidence = next((item["id"] for item in manifest["evidence"]
                           if item["observation_type"] == "target_slice_counts" and item["id"] in cited), None)
    if not (version and stats_evidence):
        raise ValueError(f"{manifest_path.name} has no version for the shipped parquet or no cited slice counts")
    validated = [relation["target"] for relation in manifest["relations"]
                 if relation["source"] == version and relation["predicate"] == "VALIDATED_AGAINST"]
    return manifest_path, manifest, version, stats_evidence, validated


def record_version(shipped, new_sha, protocol, run_prefix, started_at, stats):
    """Add the slice version `new_sha` to the manifest read by shipped_version: made by a run of `protocol` with the
    new slice counts `stats`, derived from the shipped version, and cited in place of the shipped slice counts."""
    manifest_path, manifest, old_version, old_stats_evidence, validated = shipped
    version = f"version:dataset:uzp-orzeczenia-pl-dynaword:{new_sha}"
    run = {"id": f"{run_prefix}:" + digest({"script": digest(Path(__file__).read_bytes()), "parquet": new_sha}),
           "protocol": protocol["id"], "started_at": started_at, "finished_at": now(), "success": True, "stats": stats}
    stats_evidence = f"evidence:uzp-target-stats:{digest(stats)}"
    manifest.update(
        protocols=manifest["protocols"] + [protocol],
        runs=manifest["runs"] + [run],
        versions=manifest["versions"] + [{"id": version, "object": SLICE_OBJECT, "content_address": new_sha}],
        evidence=manifest["evidence"] + [{"id": stats_evidence, "observation_type": "target_slice_counts",
                                          "artifact": f"data/{SOURCE}/{SOURCE}.stats.json",
                                          "content_address": digest(stats), "produced_by": run["id"]}],
        claims=[{**claim, "supported_by": [stats_evidence if item == old_stats_evidence else item
                                           for item in claim["supported_by"]]} for claim in manifest["claims"]],
        relations=manifest["relations"] + [
            {"source": version, "predicate": "DERIVED_FROM", "target": old_version},
            {"source": version, "predicate": "GENERATED_BY", "target": run["id"]},
            # only texts change (row metadata and signatures are the shipped ones), so the metadata overlap audit
            # against the target still holds
            *({"source": version, "predicate": "VALIDATED_AGAINST", "target": target} for target in validated)])
    write_as_before(manifest_path, json_text(manifest))


def install(out, data):
    """Replace the parquet and sidecars in `data` with the rebuild in `out` and record it in the ontology manifest.

    The rebuild may change texts and what follows from them (token counts, text hashes, decision character
    counts) only: the document set, row metadata, decisions and PDF hashes must be the shipped ones. Every check
    runs before the first write."""
    import pyarrow.parquet as pq
    built, path = out / "hf_repo", shard_paths(data)
    built_parquet = built / "data/train-00000-of-00001.parquet"
    old_rows, rows = pq.read_table(path["parquet"]).to_pylist(), pq.read_table(built_parquet).to_pylist()
    if [row["id"] for row in rows] != [row["id"] for row in old_rows]:
        raise ValueError("rebuilt document set differs from the shipped one")
    fixed = [field for field in FIELDS if field not in ("text", "token_count")]
    for new, old in zip(rows, old_rows):
        if any(new[field] != old[field] for field in fixed):
            raise ValueError("metadata changed for " + new["id"])
    decisions = read_lines(built / "artifacts/decisions.jsonl")
    for new, old in zip(decisions, read_lines(path["decisions.jsonl"]), strict=True):
        if any(new.get(key) != old.get(key) for key in ("id", "selected", "reason", "duplicate_of")):
            raise ValueError("decision changed for " + old["id"])
    attribution = read_lines(built / "artifacts/attribution.jsonl")
    old_attribution = read_lines(path["attribution.jsonl"])
    if [{**item, "text_sha256": ""} for item in attribution] != [{**item, "text_sha256": ""} for item in old_attribution]:
        raise ValueError("attribution metadata or PDF hashes changed since the shipped build")
    old_sha, new_sha = digest(path["parquet"].read_bytes()), digest(built_parquet.read_bytes())
    if new_sha == old_sha:
        raise ValueError("the rebuild reproduces the shipped parquet; nothing to install")
    shipped = shipped_version(data, old_sha)

    shutil.copy2(built_parquet, path["parquet"])
    write_as_before(path["decisions.jsonl"], jsonl_text(decisions))
    old_stats, stats = refresh_sidecars(path, rows)
    record_version(shipped, new_sha, REBUILD_PROTOCOL, "run:uzp-orzeczenia-rebuild",
                   load(out / "acquisition.json")["observed_at"], stats)
    refresh_checksums(path["checksums.json"])
    report = {"documents_changed": sum(new["text"] != old["text"] for new, old in zip(rows, old_rows)),
              "ip_tags_before": sum(row["text"].count("[REDACTED:IP]") for row in old_rows),
              "ip_tags_after": sum(row["text"].count("[REDACTED:IP]") for row in rows),
              "tokens_before": old_stats["tokens"], "tokens_after": stats["tokens"],
              "characters_before": old_stats["characters"], "characters_after": stats["characters"]}
    print(json.dumps(report, ensure_ascii=False, indent=2), flush=True)
    return report


def rebuild(out, data, workers):
    """Re-acquire the shipped documents, build them with the current redact_pii, verify, and install in `data`."""
    reacquire(out, data, workers)
    build(out, added=load(data / f"{SOURCE}.stats.json")["added"])
    verify(out)
    return install(out, data)


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--output", type=Path, required=True)
    parser.add_argument("--workers", type=int, default=8)
    parser.add_argument("--nergal", type=Path, help="g1: local SlayerLab/NERGAL snapshot directory")
    parser.add_argument("--cache", type=Path, help="g1: JSONL of NERGAL's results (before g1_rules); an interrupted "
                                                   "run resumes, and a rerun after a rules change needs no NERGAL")
    parser.add_argument("--device", help="g1: torch device (default: NERGAL's choice)")
    parser.add_argument("--dtype", default="float32", choices=["float32", "float16"])
    parser.add_argument("--data", type=Path, default=Path(__file__).resolve().parents[1] / "data" / SOURCE,
                        help="shipped shard for reacquire/install/rebuild")
    parser.add_argument("command", choices=["discover", "acquire", "audit_target", "audit_overlap",
                                            "build", "verify", "g1", "reacquire", "install", "rebuild"])
    args = parser.parse_args()
    if args.command == "g1" and not (args.nergal and args.cache):
        parser.error("g1 needs --nergal and --cache; --output is the shard directory data/uzp_orzeczenia_pl")
    if args.command == "reacquire":
        return reacquire(args.output, args.data, args.workers)
    if args.command == "install":
        return install(args.output, args.data)
    if args.command == "rebuild":
        return rebuild(args.output, args.data, args.workers)
    if args.command == "discover":
        discover(args.output, args.workers)
    elif args.command == "acquire":
        acquire(args.output, args.workers)
    elif args.command == "audit_target":
        audit_target(args.output)
    elif args.command == "audit_overlap":
        audit_overlap(args.output)
    elif args.command == "build":
        build(args.output)
    elif args.command == "g1":
        g1(args.output, args.nergal, args.cache, args.device, args.dtype)
    else:
        verify(args.output)


if __name__ == "__main__":
    main()