Add source: sejm_committee_transcripts - full Sejm committee zapis coverage (terms 9-10) (#37)

- Add source: sejm_committee_transcripts (terms 9-10 committee zapis) (667d9e7f1a64b9cc452c233ef838c1e36df03071)

artifacts/source_findings.md

@@ -880,3 +880,34 @@ dedup (the 13 exclusions were metadata-level title/DOI matches only).
 **Lesson** — the per-article license line kept verbatim in the record text makes
 the grant self-evidencing in the corpus itself — worth copying for other
 publishers that stamp each article.
+
+---
+
+## sejm_committee_transcripts — Sejm committee full transcripts (terms 9–10)
+
+**Investigated** — 2026-09-18 (review round 2026-09-28).
+
+**Verdict** — `added` (proposed with `release: None`). 653,411 speaker turns /
+166.3M `cl100k_base` tokens of spoken multi-party committee discussion — a
+working register the plenary-only political sources do not cover.
+
+**Enumeration** — api.sejm.gov.pl: `GET /sejm/term{n}/committees` and
+`.../sittings`, then `.../sittings/{num}/pdf` for the "pelny zapis" transcripts.
+9,175 term-9/10 sittings known; 8,658 have a zapis PDF upstream, 455 have none,
+62 failed after retries; 7,746 sittings survive joint-sitting dedup.
+
+**License evidence** — official parliamentary materials: Copyright Act art. 4(2)
+(<https://eli.gov.pl/api/acts/DU/2025/24/text/O/D20250024.pdf>) + Open Data/PSI
+Act arts. 2(12), 5, 6, 14, 15, 17
+(<https://eli.gov.pl/api/acts/DU/2023/1524/text.html>). No CC grant claimed;
+evidence snapshot in `sejm_committee_transcripts.license-evidence.json`.
+
+**Blockers** — none to merge with `release: None`. Before release: NERGAL pass
+(454 pattern redactions cover only e-mail/PESEL/NIP/REGON/labelled phone/IBAN;
+quoted citizens' statements remain), near-dedup vs `dziennik_ustaw`/`eurlex`
+(embedded statute/print quotations), benchmark-overlap check.
+
+**Lesson** — `pdftotext -layout` + role-anchored speaker labels reconstruct
+turns well (98.9% of the ASW pilot's audited corrected characters), but it is
+the pilot comparison that makes the reconstruction auditable — keep that step
+for future spoken sources.

data/sejm_committee_transcripts/NOTICE.md

@@ -0,0 +1,21 @@
+# Attribution and license notice
+
+Source: Sejm committee full transcripts ("pelny zapis przebiegu posiedzenia"),
+Kancelaria Sejmu RP, https://api.sejm.gov.pl/ -
+`GET /sejm/term{n}/committees/{code}/sittings/{num}/pdf`, terms 9-10.
+
+Official parliamentary materials are excluded from copyright by art. 4(2) of the
+Polish Copyright Act (https://eli.gov.pl/api/acts/DU/2025/24/text/O/D20250024.pdf);
+reuse is governed by the Polish Open Data and Reuse of PSI Act, arts. 2(12), 5, 6,
+14, 15, 17 (https://eli.gov.pl/api/acts/DU/2023/1524/text.html). No upstream
+Creative Commons grant is claimed. Per-record `source_url` and `content_sha1` in
+`sejm_committee_transcripts.attribution.jsonl` pin the exact API PDF endpoint and
+transcript fingerprint.
+
+Preparation: Piotr Styla with AI assistance. Changes: `pdftotext -layout`
+extraction, page-furniture removal, role-anchored speaker-turn reconstruction,
+soft-hyphenation joining, whitespace normalization, joint-sitting and exact-turn
+deduplication, pattern-based PII redaction (e-mail, checksum-valid
+PESEL/NIP/REGON, labelled phone/fax, IBAN). Not complete anonymization - a
+SlayerLab/NERGAL pass is required before release. No endorsement by the
+Kancelaria Sejmu RP is implied.

data/sejm_committee_transcripts/sejm_committee_transcripts.attribution.jsonl

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

data/sejm_committee_transcripts/sejm_committee_transcripts.license-evidence.json

@@ -0,0 +1,27 @@
+{
+  "copyright_basis": {
+    "article": "4(2)",
+    "url": "https://eli.gov.pl/api/acts/DU/2025/24/text/O/D20250024.pdf"
+  },
+  "license_name": "polish-public-sector-open-statutory-reuse",
+  "limitations": [
+    "privacy and personal-data exceptions",
+    "third-party rights",
+    "no Creative Commons grant is asserted"
+  ],
+  "official_source": "https://api.sejm.gov.pl/",
+  "provider": "Kancelaria Sejmu RP",
+  "reuse_basis": {
+    "articles": [
+      "2(12)",
+      "5",
+      "6",
+      "14",
+      "15",
+      "17"
+    ],
+    "url": "https://eli.gov.pl/api/acts/DU/2023/1524/text.html"
+  },
+  "source_revision": "sejm-committee-transcripts v2 (terms 9+10, full API zapis PDF coverage)",
+  "status": "verified 2026-09-18; per-row source_url pins the exact API PDF endpoint"
+}

data/sejm_committee_transcripts/sejm_committee_transcripts.md

@@ -0,0 +1,88 @@
+# Sejm committee transcripts (terms 9–10) - official parliamentary materials
+
+Official committee transcripts ("pelny zapis przebiegu posiedzenia") from the
+Sejm of the Republic of Poland, parsed into attributed speaker turns:
+**653,411 records / 166,310,754 `cl100k_base` tokens / 443,928,915 characters**,
+70 committees, 7,746 sittings, terms 9 and 10.
+
+## Origin and license
+
+- Origin: Kancelaria Sejmu RP, <https://api.sejm.gov.pl/> -
+  `GET /sejm/term{n}/committees/{code}/sittings/{num}/pdf`. Each record pins its
+  exact source PDF endpoint in `sejm_committee_transcripts.attribution.jsonl`
+  (`source_url`); the per-sitting `content_sha1` fingerprints the transcript body.
+- License: official parliamentary materials are excluded from copyright by
+  [art. 4(2) of the Polish Copyright Act](https://eli.gov.pl/api/acts/DU/2025/24/text/O/D20250024.pdf);
+  reuse is governed by the
+  [Polish Open Data and Reuse of PSI Act, arts. 2(12), 5, 6, 14, 15, 17](https://eli.gov.pl/api/acts/DU/2023/1524/text.html).
+  No upstream Creative Commons grant is claimed. Evidence snapshot:
+  `sejm_committee_transcripts.license-evidence.json` (verified 2026-09-18;
+  limitations: privacy and personal-data exceptions, third-party rights).
+
+## What the texts are
+
+- **Genre**: official stenographic transcripts of standing-committee sittings -
+  bill examinations, ministry and expert Q&A, chair announcements, votes and
+  interjections ("Glos z sali"). One record per speaker turn (the whole turn, not
+  split further).
+- **Register**: prepared official transcript of spoken Polish - multi-party
+  discussion with questions, answers and interruptions, formal address formulas,
+  occasional read-out quotations of documents. Not plenary speeches: this is the
+  committee working register that the plenary-only `parliamentary` / `sejm_api`
+  sources do not contain. Not OCR'd (born-digital PDFs), not machine-translated.
+- **Time span**: sitting dates `2019-11-14` - `2026-09-03` (term 9: 331,411
+  records; term 10: 322,000). 11,261 distinct speaker labels
+  (role + name as printed in the transcript).
+
+## Collection and normalization
+
+Every step lives in `src/fetch_sejm_committee_transcripts.py` (assembled from the
+pinned `PiotrSty/sejm-committee-transcripts` pipeline @9efc4e2), so the shard is
+reproducible from the script alone. Requires `pdftotext` (poppler).
+
+- **Acquire**: committee and sitting listings cached from the API; zapis PDFs
+  downloaded with a per-term manifest. Coverage: 8,658 of 9,175 term-9/10
+  sittings have a zapis PDF at source; 455 have none upstream, 62 failed after
+  retries.
+- **Extract**: `pdftotext -layout`; page furniture removed (running headers
+  "KANCELARIA SEJMU" / "Biuro Komisji Sejmowych" / "PEŁNY ZAPIS ...", page
+  numbers and footers); speaker turns reconstructed from role-anchored speaker
+  labels (`Poseł`, `Przewodniczący`, `Sekretarz stanu`, `Legislator`,
+  `Głos z sali`, ...); body soft-hyphenation joined across line breaks;
+  whitespace runs collapsed; turns under 15 characters dropped. Parser validated
+  against the earlier ASW-only pilot: recovers 98.9% of the pilot's audited
+  corrected character count with per-turn attribution.
+- **PII (which scrubber ran)**: the pattern pass `redact()` in the committed
+  script - e-mail -> `[ADRES_EMAIL]`, checksum-valid PESEL/NIP/REGON and IBAN
+  candidates -> `[DANE_NUMERY]`, labelled phone/fax -> `[DANE_KONTAKTOWE]`.
+  Counted in the shipped shard: **415 redactions** (406 `[ADRES_EMAIL]`, 6
+  `[DANE_NUMERY]`, 3 `[DANE_KONTAKTOWE]`; the pipeline's pre-dedup counter read
+  454 because it also counted rows later dropped as joint-sitting duplicates).
+  This is **not**
+  [SlayerLab/NERGAL](https://huggingface.co/SlayerLab/NERGAL): the shard must be
+  re-run through NERGAL before it is admitted to a release (it quotes citizens'
+  statements and documents). Merge with `release: None` is fine meanwhile.
+- **Dedup**: joint sittings listed under two committee codes are kept once
+  (74,117 rows / 912 sittings dropped by per-sitting `content_sha1`); adjacent
+  exact duplicate turns (same sitting, speaker and text) dropped (42). No
+  cross-source dedup yet (see caveats).
+
+## Inclusion argument and caveats
+
+What this adds: spoken multi-party committee discussion - questions, answers,
+interjections - a working-register complement to the corpus's plenary and
+written political sources. 166M tokens of it.
+
+Caveats: transcripts are the Sejm's official cleaned stenograms, not raw audio;
+quotations of statutes, print and citizen statements are embedded (near-dedup vs
+`dziennik_ustaw` / `eurlex` remains a target integration gate, as does a
+benchmark-overlap check); PII treatment is pattern-based (see above) and quoted
+citizens warrant a NERGAL pass and a spot check before release; 517 sittings are
+missing (455 without an upstream PDF, 62 fetch failures). Training benefit is an
+untested hypothesis.
+
+Limitations: speaker labels and role attribution follow the printed transcript
+(preamble fragments are dropped by the turn reconstruction; the pilot comparison
+quantifies the residual loss). Records are whole turns; sitting-level context
+order is preserved via `term`/`committee_code`/`sitting_num`/`turn_idx` in the
+attribution sidecar.

data/sejm_committee_transcripts/sejm_committee_transcripts.parquet

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

data/sejm_committee_transcripts/sejm_committee_transcripts.stats.json

@@ -0,0 +1,19 @@
+{
+  "added": "2026-09-18",
+  "characters": 443928915,
+  "committees": 70,
+  "date_max": "2026-09-03",
+  "date_min": "2019-11-14",
+  "discovered_sittings": 9175,
+  "kept": 653411,
+  "rejected": 74159,
+  "rejected_exact_dup": 42,
+  "rejected_joint_sitting_dup": 74117,
+  "rows_raw_extracted": 727570,
+  "sittings": 7746,
+  "sittings_fetch_failed": 62,
+  "sittings_no_pdf_upstream": 455,
+  "sittings_with_pdf": 8658,
+  "tokens": 166310754,
+  "unique_speaker_labels": 11261
+}

src/fetch_sejm_committee_transcripts.py

@@ -0,0 +1,464 @@
+"""Fetch, parse and build Sejm committee full-transcript speaker turns.
+
+Assembled from the pinned pipeline of PiotrSty/sejm-committee-transcripts @9efc4e2
+(scripts/probe_sittings.py, bulk_download.py, parse_zapis.py, extract_all.py,
+build_dataset.py - their function bodies are preserved) plus the canonical
+DynaWord schema build. Normalization and PII redaction live HERE so the shard is
+reproducible from this script alone.
+
+Source: Kancelaria Sejmu RP, https://api.sejm.gov.pl/
+(`GET /sejm/term{n}/committees/{code}/sittings/{num}/pdf`, the
+"pelny zapis przebiegu posiedzenia" transcripts), terms 9 and 10.
+
+Requirements: Python 3.10+, `pdftotext` (poppler-utils) on PATH, `tiktoken`,
+`pyarrow`. Working cache: ./sejm_cache (API cache, PDFs, parsed turns).
+
+Usage:
+  python3 src/fetch_sejm_committee_transcripts.py probe 9 10
+  python3 src/fetch_sejm_committee_transcripts.py download 9 10
+  python3 src/fetch_sejm_committee_transcripts.py extract 9 10
+  python3 src/fetch_sejm_committee_transcripts.py build
+  python3 src/fetch_sejm_committee_transcripts.py all 9 10
+"""
+import concurrent.futures as cf
+import hashlib
+import json
+import pathlib
+import re
+import subprocess
+import sys
+import urllib.error
+import urllib.request
+
+BASE = "https://api.sejm.gov.pl/sejm"
+CACHE = pathlib.Path("sejm_cache")
+SOURCE = "sejm_committee_transcripts"
+ADDED = "2026-09-18"
+LICENSE = "public-domain (official documents)"
+FIELDS = ["id", "text", "source", "added", "created", "token_count", "license", "author"]
+
+# ---------------------------------------------------------------- parse_zapis
+HEADER_PAT = re.compile(
+    r"^\s*(X{0,2}I?X kadencja|KANCELARIA SEJMU|Biuro Komisji Sejmowych|"
+    r"PEŁNY ZAPIS PRZEBIEGU POSIEDZENIA|Pełny zapis przebiegu posiedzenia|¢.*)\s*$"
+)
+PAGEFOOT_PAT = re.compile(r"^\s*[a-z]{1,3}\.?\s+\d{1,4}\s*$")
+PAGENUM_PAT = re.compile(r"^\s*\d{1,4}\s*$")
+
+SPEAKER_ANCHOR = re.compile(
+    r"^(?:Przewodnicząc\w*|Wiceprzewodnicząc\w*|Poseł|Posłanka|poseł|posłanka|"
+    r"Wicemarszałek|Marszałek|Sekretarz stanu|sekretarz stanu|podsekretarz stanu|"
+    r"Podsekretarz stanu|minister|Minister|Wiceminister|Legislator|legislator|"
+    r"Protokolant|protokolant|Głos z sali|Głos z gości|Prezes|prezes|Wiceprezes|"
+    r"wiceprezes|p\.o\. ?\S*|dyrektor|Dyrektor|wicedyrektor|Wicedyrektor|"
+    r"Przedstawiciel\w*|przedstawiciel\w*|Sprawozdawca|sprawozdawca|Komendant|"
+    r"komendant|Naczelnik|naczelnik|Rzecznik|rzecznik|Prokurator|Sędzia|Doradca|"
+    r"doradca|Ekspert|ekspert|Mecenas|gen\.|nadinsp\.|insp\.|st\. bryg\.|płk|ppłk|"
+    r"Pełnomocnik|pełnomocnik|Szef|szef|Wojskowy|Pracownik|pracownik|Profesor|"
+    r"prof\.|Komisarz|komisarz)\b"
+)
+
+
+def is_speaker_line(content: str) -> bool:
+    c = content.strip()
+    if not (3 <= len(c) <= 120):
+        return False
+    if re.search(r"https?://|www\.|druk nr|\barts?\b", c, re.I):
+        return False
+    # wrapped preamble fragments: lowercase start with commas ("... poseł X (KO), przewodniczącej ..., rozpatrzyła")
+    if c[0].islower() and ("," in c or " rozpatrz" in c or "uznała" in c or "przyjęła" in c):
+        return False
+    return bool(SPEAKER_ANCHOR.match(c))
+
+
+def dehyphenate(text: str) -> str:
+    # soft hyphenation join: "Kon-\nrada" -> "Konrada"
+    return re.sub(r"([a-ząćęłńóśźż])-\s*\n\s*([a-ząćęłńóśźż])", r"\1\2", text)
+
+
+def pdf_text(path: str) -> str:
+    r = subprocess.run(
+        ["pdftotext", "-layout", "-enc", "UTF-8", path, "-"],
+        capture_output=True, text=True, encoding="utf-8", errors="replace", check=True)
+    return r.stdout
+
+
+def parse_pdf(path: str):
+    """Return (transcript_type, header_text, turns) where turns = [(speaker, text)]."""
+    raw = pdf_text(path)
+    if "PEŁNY ZAPIS" not in raw and "pełny zapis" not in raw.lower()[:2000]:
+        return "other", None, []
+    lines = raw.splitlines()
+    # locate start: first speaker line
+    start = None
+    for i, ln in enumerate(lines):
+        s = ln.rstrip()
+        if not s.strip():
+            continue
+        if len(s) - len(s.lstrip()) <= 6 and s.strip().endswith(":") and is_speaker_line(s.strip()[:-1]):
+            start = i
+            break
+    if start is None:
+        return "nospeaker", None, []
+    preamble = []
+    # collect preamble (between title and first speaker), cleaned
+    for ln in lines[:start]:
+        if HEADER_PAT.match(ln) or PAGEFOOT_PAT.match(ln) or PAGENUM_PAT.match(ln) or not ln.strip():
+            continue
+        preamble.append(ln.strip())
+    turns = []
+    speaker = None
+    body = []
+
+    def flush():
+        nonlocal speaker, body
+        if speaker and body:
+            txt = dehyphenate("\n".join(body))
+            txt = re.sub(r"[ \t]+", " ", txt).strip()
+            if len(txt) >= 15:
+                turns.append((speaker, txt))
+        speaker, body = None, []
+
+    i = start
+    while i < len(lines):
+        ln = lines[i].rstrip()
+        indent = len(ln) - len(ln.lstrip())
+        s = ln.strip()
+        if not s:
+            i += 1
+            continue
+        if HEADER_PAT.match(ln) or PAGEFOOT_PAT.match(ln) or PAGENUM_PAT.match(ln):
+            i += 1
+            continue
+        if indent <= 6 and s.endswith(":") and s[:-1] and is_speaker_line(s[:-1]):
+            flush()
+            speaker = s[:-1].strip()
+            i += 1
+            continue
+        if speaker is not None:
+            body.append(s)
+        else:
+            # unexpected col-0 text after transcript start; treat as preamble footer noise
+            preamble.append(s)
+        i += 1
+    flush()
+    return "pelny_zapis", " ".join(preamble), turns
+
+
+def doc_id(term, code, num, text):
+    return hashlib.sha1(f"{term}/{code}/{num}/{text}".encode()).hexdigest()[:16]
+
+
+def row_id(r):
+    return f"{SOURCE}_{r['term']}_{r['committee_code']}_{r['sitting_num']}_{r['turn_idx']}"
+
+
+def dedup_turns(rows):
+    """Sitting-level joint-sitting dedup (term + content sha1) and adjacent exact-turn dedup.
+
+    Joint sittings of two or more committees appear in each committee's sittings
+    list; identical content (per-sitting sha1) is kept once.
+    """
+    sittings = {}
+    for r in rows:
+        sittings.setdefault((r["term"], r["committee_code"], r["sitting_num"]), []).append(r)
+    keep, seen_keys, dropped = [], set(), 0
+    for key in sorted(sittings):
+        group = sittings[key]
+        content_key = (group[0]["term"], group[0]["content_sha1"])
+        if content_key in seen_keys:
+            dropped += len(group)
+            continue
+        seen_keys.add(content_key)
+        keep.extend(sorted(group, key=lambda r: r["turn_idx"]))
+    final, exact_dup, prev = [], 0, None
+    for r in keep:
+        if prev and prev["term"] == r["term"] and prev["committee_code"] == r["committee_code"] \
+           and prev["sitting_num"] == r["sitting_num"] and prev["speaker"] == r["speaker"] and prev["text"] == r["text"]:
+            exact_dup += 1
+            continue
+        final.append(r)
+        prev = r
+    return final, dropped, exact_dup
+
+
+# ------------------------------------------------------------------ extract_all
+EMAIL = re.compile(r"[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}")
+PESEL = re.compile(r"(?<!\d)(\d{11})(?!\d)")
+NIP = re.compile(r"(?<!\d)(\d{10})(?!\d)")
+REGON = re.compile(r"(?<!\d)(\d{9}|\d{14})(?!\d)")
+PHONE = re.compile(r"(?i)\b(tel\.?|telefon|fax)\b[:. ]*\+?\d[\d ()-]{6,}")
+IBAN = re.compile(r"\b[A-Z]{2}\d{2}[ ]?(?:[ ]?\d{4}){4,7}\b")
+
+
+def pesel_ok(d: str) -> bool:
+    w = [1, 3, 7, 9, 1, 3, 7, 9, 1, 3]
+    s = sum(int(a) * b for a, b in zip(d[:10], w)) % 10
+    return (10 - s) % 10 == int(d[10])
+
+
+def nip_ok(d: str) -> bool:
+    w = [6, 5, 7, 2, 3, 4, 5, 6, 7]
+    s = sum(int(a) * b for a, b in zip(d[:9], w)) % 11
+    return s % 10 == int(d[9])
+
+
+def regon_ok(d: str) -> bool:
+    if len(d) == 9:
+        w = [8, 9, 2, 3, 4, 5, 6, 7]
+        s = sum(int(a) * b for a, b in zip(d[:8], w)) % 11
+        return s % 10 == int(d[8])
+    w = [8, 9, 2, 3, 4, 5, 6, 7, -1, 2, 3, 4, 5, 6, 7]
+    s = sum(int(a) * b for a, b in zip(d[:14], w)) % 11
+    return s % 10 == int(d[14])
+
+
+def redact(text: str) -> tuple[str, int]:
+    n = 0
+
+    def sub(replacement):
+        def repl(m):
+            nonlocal n
+            n += 1
+            return replacement if isinstance(replacement, str) else replacement(m)
+        return repl
+
+    text = EMAIL.sub(sub(lambda m: "[ADRES_EMAIL]" if "@" in m.group(0) else "[DANE_NUMERY]"), text)
+    text = PESEL.sub(sub(lambda m: "[DANE_NUMERY]" if pesel_ok(m.group(1)) else m.group(0)), text)
+    text = NIP.sub(sub(lambda m: "[DANE_NUMERY]" if nip_ok(m.group(1)) else m.group(0)), text)
+    text = REGON.sub(sub(lambda m: "[DANE_NUMERY]" if regon_ok(m.group(1)) else m.group(0)), text)
+    text = PHONE.sub(sub("[DANE_KONTAKTOWE]"), text)
+    text = IBAN.sub(sub("[DANE_NUMERY]"), text)
+    return text, n
+
+
+def fetch_json(url, retries=3, timeout=30):
+    req = urllib.request.Request(url, headers={"User-Agent": "committee-corpus/0.1"})
+    last = None
+    for _ in range(retries):
+        try:
+            with urllib.request.urlopen(req, timeout=timeout) as r:
+                return json.loads(r.read())
+        except Exception as e:  # noqa: BLE001 - retry any transport failure
+            last = e
+    raise last
+
+
+def probe(terms):
+    """Enumerate committees and sittings per term into sejm_cache/api."""
+    api = CACHE / "api"
+    api.mkdir(parents=True, exist_ok=True)
+    for term in terms:
+        committees = fetch_json(f"{BASE}/term{term}/committees")
+        (api / f"committees_term{term}.json").write_text(
+            json.dumps(committees, ensure_ascii=False), encoding="utf-8")
+        total = 0
+        for c in committees:
+            code = c["code"]
+            dest = api / f"sittings_{term}_{code}.json"
+            if dest.exists():
+                sittings = json.loads(dest.read_text(encoding="utf-8"))
+            else:
+                sittings = fetch_json(f"{BASE}/term{term}/committees/{code}/sittings")
+                dest.write_text(json.dumps(sittings, ensure_ascii=False), encoding="utf-8")
+            total += sum(1 for s in sittings if s.get("num"))
+        print(f"term {term}: {len(committees)} committees, {total} sittings", flush=True)
+
+
+def download(terms):
+    """Download zapis PDFs with cache and per-term manifest."""
+    pdfdir = CACHE / "pdf"
+    pdfdir.mkdir(parents=True, exist_ok=True)
+    api = CACHE / "api"
+    for term in terms:
+        tasks = []
+        for f in sorted(api.glob(f"sittings_{term}_*.json")):
+            code = f.stem.split("_", 2)[2]
+            for s in json.loads(f.read_text(encoding="utf-8")):
+                if s.get("num"):
+                    tasks.append((code, s["num"]))
+
+        def fetch(t):
+            code, num = t
+            dest = pdfdir / f"t{term}_{code}_{num}.pdf"
+            if dest.exists() and dest.stat().st_size > 100:
+                return {"code": code, "num": num, "status": "cached", "bytes": dest.stat().st_size}
+            url = f"{BASE}/term{term}/committees/{code}/sittings/{num}/pdf"
+            for a in range(2):
+                try:
+                    req = urllib.request.Request(url, headers={"User-Agent": "committee-corpus/0.1"})
+                    with urllib.request.urlopen(req, timeout=60) as r:
+                        data = r.read()
+                    if data[:5] == b"%PDF-":
+                        dest.write_bytes(data)
+                        return {"code": code, "num": num, "status": "ok", "bytes": len(data)}
+                    return {"code": code, "num": num, "status": "notpdf", "bytes": len(data)}
+                except urllib.error.HTTPError as e:
+                    return {"code": code, "num": num, "status": f"http{e.code}", "bytes": 0}
+                except Exception as e:  # noqa: BLE001
+                    if a == 1:
+                        return {"code": code, "num": num, "status": "error", "bytes": 0, "err": repr(e)[:80]}
+
+        manifest = api / f"dl_manifest_{term}.jsonl"
+        done = set()
+        if manifest.exists():
+            for line in open(manifest, encoding="utf-8"):
+                try:
+                    r = json.loads(line)
+                    if r["status"] not in ("error",):
+                        done.add((r["code"], r["num"]))
+                except Exception:  # noqa: BLE001
+                    pass
+        todo = [t for t in tasks if t not in done]
+        print(f"term {term}: downloading {len(todo)} ({len(done)} already done)", flush=True)
+        with open(manifest, "a", encoding="utf-8") as fh, cf.ThreadPoolExecutor(48) as ex:
+            for i, fut in enumerate(cf.as_completed([ex.submit(fetch, t) for t in todo])):
+                fh.write(json.dumps(fut.result()) + "\n")
+                if (i + 1) % 250 == 0:
+                    print(f"{i + 1}/{len(todo)}", flush=True)
+
+
+def extract(terms):
+    """Parse downloaded PDFs into redacted speaker turns (sejm_cache/parsed)."""
+    outdir = CACHE / "parsed"
+    outdir.mkdir(parents=True, exist_ok=True)
+    api = CACHE / "api"
+    for term in terms:
+        names = {}
+        for c in json.loads((api / f"committees_term{term}.json").read_text(encoding="utf-8")):
+            names[c["code"]] = c.get("name") or c.get("prettyName") or c["code"]
+        dates = {}
+        for f in sorted(api.glob(f"sittings_{term}_*.json")):
+            code = f.stem.split("_", 2)[2]
+            for s in json.loads(f.read_text(encoding="utf-8")):
+                if s.get("num"):
+                    dates[(code, s["num"])] = s.get("date")
+
+        jobs = []
+        for line in open(api / f"dl_manifest_{term}.jsonl", encoding="utf-8"):
+            r = json.loads(line)
+            if r["status"] in ("ok", "cached"):
+                p = CACHE / "pdf" / f"t{term}_{r['code']}_{r['num']}.pdf"
+                if p.exists():
+                    jobs.append((r["code"], r["num"], p))
+        stats = {"pdfs": len(jobs), "type": {}, "turns": 0, "chars": 0, "pii": 0, "parse_fail": []}
+
+        def do_parse(job):
+            code, num, p = job
+            try:
+                return job, parse_pdf(str(p))
+            except Exception as e:  # noqa: BLE001
+                return job, ("__fail__", None, repr(e)[:100])
+
+        with open(outdir / f"turns_{term}.jsonl", "w", encoding="utf-8") as fh, cf.ThreadPoolExecutor(10) as ex:
+            for i, ((code, num, p), (ttype, preamble, turns)) in enumerate(ex.map(do_parse, jobs)):
+                if ttype == "__fail__":
+                    stats["parse_fail"].append({"code": code, "num": num, "err": turns})
+                    continue
+                stats["type"][ttype] = stats["type"].get(ttype, 0) + 1
+                if ttype != "pelny_zapis" or not turns:
+                    continue
+                content = hashlib.sha1("␟".join(t for _, t in turns).encode()).hexdigest()[:16]
+                for ti, (sp, tx) in enumerate(turns):
+                    tx, n = redact(re.sub(r"[ \t]+", " ", tx).strip())
+                    if len(tx) < 15:
+                        continue
+                    row = {
+                        "term": str(term),
+                        "committee_code": code,
+                        "committee_name": names.get(code, code),
+                        "sitting_num": num,
+                        "date": dates.get((code, num)),
+                        "turn_idx": ti,
+                        "speaker": sp.strip(),
+                        "text": tx,
+                        "content_sha1": content,
+                        "source_url": f"{BASE}/term{term}/committees/{code}/sittings/{num}/pdf",
+                    }
+                    fh.write(json.dumps(row, ensure_ascii=False) + "\n")
+                    stats["turns"] += 1
+                    stats["chars"] += len(tx)
+                    stats["pii"] += n
+                if (i + 1) % 500 == 0:
+                    print(f"parsed {i + 1}/{len(jobs)}", flush=True)
+        print(json.dumps(stats, ensure_ascii=False)[:600], flush=True)
+
+
+# ------------------------------------------------------------------ build_dataset
+def build(terms=(9, 10), outdir="."):
+    """Dedup parsed turns and write the canonical DynaWord artifacts."""
+    import pyarrow as pa
+    import pyarrow.parquet as pq
+    import tiktoken
+
+    rows = []
+    for term in terms:
+        f = CACHE / "parsed" / f"turns_{term}.jsonl"
+        if f.exists():
+            rows += [json.loads(l) for l in open(f, encoding="utf-8")]
+
+    n_raw = len(rows)
+    rows, dedup_dropped, exact_dup = dedup_turns(rows)
+
+    encoder = tiktoken.get_encoding("cl100k_base")
+    out_rows, attrs = [], []
+    for r in rows:
+        rid = row_id(r)
+        out_rows.append({
+            "id": rid, "text": r["text"], "source": SOURCE, "added": ADDED,
+            "created": r["date"] or "",
+            "token_count": len(encoder.encode_ordinary(r["text"])),
+            "license": LICENSE, "author": r["speaker"],
+        })
+        attrs.append({k: r[k] for k in ("term", "committee_code", "committee_name", "sitting_num",
+                                        "date", "turn_idx", "speaker", "content_sha1", "source_url")} | {"id": rid})
+
+    root = pathlib.Path(outdir) / "data" / SOURCE
+    root.mkdir(parents=True, exist_ok=True)
+    schema = pa.schema([(f, pa.int64() if f == "token_count" else pa.string()) for f in FIELDS])
+    pq.write_table(pa.Table.from_pylist(out_rows, schema=schema),
+                   root / f"{SOURCE}.parquet", compression="zstd")
+    with open(root / f"{SOURCE}.attribution.jsonl", "w", encoding="utf-8") as fh:
+        for a in attrs:
+            fh.write(json.dumps(a, ensure_ascii=False, sort_keys=True) + "\n")
+
+    sittings_n = {(a["term"], a["committee_code"], a["sitting_num"]) for a in attrs}
+    committees_n = {(a["term"], a["committee_code"]) for a in attrs}
+    dates = [a["date"] for a in attrs if a["date"]]
+    stats = {
+        "discovered_sittings": 9175, "sittings_with_pdf": 8658,
+        "sittings_no_pdf_upstream": 455, "sittings_fetch_failed": 62,
+        "rows_raw_extracted": n_raw, "rejected": dedup_dropped + exact_dup,
+        "rejected_joint_sitting_dup": dedup_dropped, "rejected_exact_dup": exact_dup,
+        "kept": len(out_rows), "sittings": len(sittings_n), "committees": len(committees_n),
+        "unique_speaker_labels": len({a["speaker"] for a in attrs}),
+        "tokens": sum(r["token_count"] for r in out_rows),
+        "characters": sum(len(r["text"]) for r in out_rows),
+        "date_min": min(dates), "date_max": max(dates), "added": ADDED,
+    }
+    (root / f"{SOURCE}.stats.json").write_text(
+        json.dumps(stats, ensure_ascii=False, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    print(json.dumps(stats, ensure_ascii=False, indent=1))
+
+
+def main(argv):
+    cmd, terms = argv[1], [int(t) for t in argv[2:]]
+    if cmd == "probe":
+        probe(terms)
+    elif cmd == "download":
+        download(terms)
+    elif cmd == "extract":
+        extract(terms)
+    elif cmd == "build":
+        build()
+    elif cmd == "all":
+        probe(terms)
+        download(terms)
+        extract(terms)
+        build()
+    else:
+        raise SystemExit(__doc__)
+
+
+if __name__ == "__main__":
+    main(sys.argv)

src/sources.py

@@ -214,6 +214,31 @@ SOURCES = {
         "is_ocr": False,
         "custom_datasheet": True,
     },
+    "sejm_committee_transcripts": {
+        "added": "2026-09-18",
+        "release": None,
+        "file_key": "sejm_committee_transcripts",
+        "pretty": "Sejm committee transcripts (terms 9-10)",
+        "license": "public-domain (official documents)",
+        "license_spdx": "LicenseRef-Polish-Official-Documents",
+        "traceable": "Official parliamentary materials excluded from copyright "
+                     "under Polish Copyright Act art. 4(2); reusable under "
+                     "the Polish Open Data Act arts. 2(12), 5, 6, 14, 15, 17. "
+                     "Per-record source_url pins the exact api.sejm.gov.pl PDF "
+                     "endpoint; content_sha1 fingerprints the transcript body.",
+        "upstream": "https://api.sejm.gov.pl/",
+        "provenance": "Committee 'pelny zapis' PDFs fetched and parsed by "
+                      "src/fetch_sejm_committee_transcripts.py (pdftotext -layout, "
+                      "page-furniture removal, role-anchored speaker turns, "
+                      "soft-hyphenation joining, joint-sitting dedup, PII pattern "
+                      "redaction with checksum-validated national IDs). Pattern "
+                      "redaction only - re-run through SlayerLab/NERGAL before "
+                      "release.",
+        "domain": "political/spoken-committee",
+        "created": "2019-11-14, 2026-09-03",
+        "is_ocr": False,
+        "custom_datasheet": True,
+    },
     "parlamint_pl": {
         "added": "2026-07-19",
         "release": None,

src/test_sejm_committee_transcripts_contract.py

@@ -0,0 +1,131 @@
+"""Contract for Sejm committee transcript ingestion and the shipped shard."""
+import json
+import sys
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from fetch_sejm_committee_transcripts import (
+    FIELDS,
+    LICENSE,
+    SOURCE,
+    dehyphenate,
+    dedup_turns,
+    is_speaker_line,
+    redact,
+    row_id,
+)
+
+ROOT = Path(__file__).resolve().parents[1]
+DATA = ROOT / "data" / SOURCE
+
+
+def turn(code, num, idx, speaker, text, sha):
+    return {"term": "10", "committee_code": code, "committee_name": "Komisja Testowa",
+            "sitting_num": num, "date": "2024-01-10", "turn_idx": idx, "speaker": speaker,
+            "text": text, "content_sha1": sha, "source_url": "https://api.sejm.gov.pl/x/pdf"}
+
+
+class SpeakerLineTest(unittest.TestCase):
+    def test_role_anchored_speaker_lines(self):
+        for line in ["Poseł Daniel Milewski (KO)", "Przewodnicząca Anna Sobolewska",
+                     "Sekretarz stanu Władysław Teofil Bartoszewski", "Głos z sali",
+                     "Legislator Marek Nowak", "Minister rozwoju", "Wicemarszałek Sejmu Krzysztof Bosak"]:
+            self.assertTrue(is_speaker_line(line), line)
+
+    def test_wrapped_preamble_and_noise_rejected(self):
+        for line in ["poseł sprawozdawca, w imieniu klubu, przedstawił sprawozdanie",
+                     "rozpatrzyła projekt ustawy i uznała go za zasadny",
+                     "szczegóły na https://api.sejm.gov.pl/sejm/term10",
+                     "druk nr 1234 w sprawie zmiany ustawy",
+                     "Pani przewodnicząca, bardzo dziękuję za głos w tej sprawie, która budzi"]:
+            self.assertFalse(is_speaker_line(line), line)
+
+    def test_length_bounds(self):
+        self.assertFalse(is_speaker_line("Po"))
+        self.assertFalse(is_speaker_line("Poseł " + "x" * 200))
+        self.assertTrue(is_speaker_line("Poseł"))
+
+
+class NormalizeTest(unittest.TestCase):
+    def test_soft_hyphenation_joined(self):
+        self.assertEqual(dehyphenate("zabezpie-\nczenia"), "zabezpieczenia")
+        self.assertEqual(dehyphenate("Kon-  \n rada"), "Konrada")
+
+    def test_hyphen_kept_before_uppercase(self):
+        self.assertEqual(dehyphenate("Współ-\nPraca"), "Współ-\nPraca")
+
+
+class RedactionTest(unittest.TestCase):
+    def test_checksum_valid_ids_masked(self):
+        text, n = redact("PESEL 44040501356 i NIP 1234567890 oraz REGON 123456785.")
+        self.assertGreaterEqual(n, 3)
+        self.assertNotIn("44040501356", text)
+        self.assertNotIn("1234567890", text)
+        self.assertNotIn("123456785", text)
+        self.assertIn("[DANE_NUMERY]", text)
+
+    def test_invalid_ids_left_alone(self):
+        text, _ = redact("PESEL 44040501357 nie przechodzi sumy kontrolnej.")
+        self.assertIn("44040501357", text)
+
+    def test_email_phone_iban_masked(self):
+        text, n = redact("pisać na jan.kowalski@sejm.gov.pl, tel. 22 694 12 34, IBAN PL61109010140000071219812874")
+        self.assertGreaterEqual(n, 3)
+        self.assertNotIn("jan.kowalski", text)
+        self.assertIn("[ADRES_EMAIL]", text)
+        self.assertIn("[DANE_KONTAKTOWE]", text)
+        self.assertNotIn("61109010140000071219812874", text)
+
+
+class DedupTest(unittest.TestCase):
+    def test_joint_sitting_content_kept_once(self):
+        rows = [turn("ASW", 5, 0, "Poseł A", "wypowiedź pierwsza", "aaa"),
+                turn("ŁAC", 5, 0, "Poseł A", "wypowiedź pierwsza", "aaa")]
+        out, dropped, exact = dedup_turns(rows)
+        self.assertEqual(len(out), 1)
+        self.assertEqual(dropped, 1)
+        self.assertEqual(exact, 0)
+
+    def test_adjacent_exact_turn_dropped(self):
+        rows = [turn("ASW", 5, 0, "Poseł A", "powtarzam to samo", "aaa"),
+                turn("ASW", 5, 1, "Poseł A", "powtarzam to samo", "aaa"),
+                turn("ASW", 5, 2, "Poseł B", "inne zdanie", "aaa")]
+        out, dropped, exact = dedup_turns(rows)
+        self.assertEqual([r["turn_idx"] for r in out], [0, 2])
+        self.assertEqual(exact, 1)
+        self.assertEqual(dropped, 0)
+
+    def test_row_id_is_deterministic(self):
+        r = turn("ASW", 5, 7, "Poseł A", "x", "aaa")
+        self.assertEqual(row_id(r), "sejm_committee_transcripts_10_ASW_5_7")
+        self.assertEqual(row_id(r), row_id(dict(r)))
+
+
+class ShippedShardTest(unittest.TestCase):
+    def test_canonical_schema_and_stats_consistency(self):
+        import pyarrow.parquet as pq
+
+        table = pq.read_table(DATA / f"{SOURCE}.parquet")
+        self.assertEqual(table.column_names, FIELDS)
+        rows = table.to_pylist()
+        stats = json.loads((DATA / f"{SOURCE}.stats.json").read_text(encoding="utf-8"))
+        attribution = [json.loads(line) for line in
+                       (DATA / f"{SOURCE}.attribution.jsonl").read_text(encoding="utf-8").splitlines() if line]
+        self.assertEqual(len(rows), stats["kept"])
+        self.assertEqual(sum(r["token_count"] for r in rows), stats["tokens"])
+        self.assertEqual(sum(len(r["text"]) for r in rows), stats["characters"])
+        self.assertEqual(stats["kept"] + stats["rejected"], stats["rows_raw_extracted"])
+        self.assertTrue(all(r["token_count"] > 0 and r["text"].strip() for r in rows))
+        self.assertTrue(all(r["source"] == SOURCE and r["license"] == LICENSE and r["author"] for r in rows))
+        self.assertTrue(all(r["created"] == "" or len(r["created"]) == 10 for r in rows))
+        self.assertEqual(len(attribution), stats["kept"])
+        self.assertEqual({r["id"] for r in rows}, {a["id"] for a in attribution})
+        self.assertTrue(all(a["source_url"].endswith("/pdf") for a in attribution))
+        self.assertEqual(stats["date_min"], min(a["date"] for a in attribution if a["date"]))
+        self.assertEqual(stats["date_max"], max(a["date"] for a in attribution if a["date"]))
+
+
+if __name__ == "__main__":
+    unittest.main()