| |
| """Keep only official speakers in the sejm_committee_transcripts shard (October 2026 rights audit). |
| |
| Committee transcripts also hold statements by guests, experts and representatives of unions, NGOs |
| and companies, and anonymous "Głos z sali" interjections. Only statements by MPs, members of the |
| government, heads of constitutional organs and Sejm/Senate staff are official materials in the |
| sense of art. 4 pkt 2 of the Polish copyright act. The allowlist is |
| fetch_sejm_committee_transcripts.SPEAKER_RULES: a turn is kept only if its `author` label fully |
| matches one rule (or is one of the few typo labels in EXACT_LABELS), so an unrecognised label is |
| dropped. |
| |
| The pre-filter shard started a turn only at a line that began with one of a few anchor words |
| ("Poseł", "Minister", ...). Any other label ("Świadek ...", "Członek zarządu ...") never started a |
| turn, so a guest's label and speech sat inside the preceding official turn. The PDF cache of the |
| fetcher is not kept, so this script works on the pinned pre-filter release files and first re-cuts |
| every input turn with the same code that `parse_pdf()` uses on a fresh PDF: |
| |
| 1. Page-break blocks (page number + stenographer initials, "Pełny Zapis Przebiegu Posiedzenia:", |
| "Komisji ... (nr N)") are removed (`strip_page_blocks`); a word hyphenated across a block is |
| rejoined. |
| 2. The turn is cut at every label line (`split_at_labels`). Piece 0, the text before the first |
| label, keeps the row id and author. The k-th later piece (k = 1, 2, ... in the turn, counted |
| before any piece is dropped) becomes its own row: author = the label (NFC, colon stripped), |
| id = "<original id>_<k>", every other field copied from the turn, so the sidecar line is |
| the turn's line with the new `speaker` and `id`. `turn_idx` and `content_sha1` stay those of the |
| input turn; ids are unique, `turn_idx` is not. |
| 3. A piece shorter than 15 characters is dropped (rejected_too_short), then a piece equal to the |
| previous piece of its sitting (same author and text) is dropped (rejected_exact_dup, added to the |
| pinned count), as `build()` does. |
| 4. Every piece is classified by `classify_speaker`; allowlisted pieces are kept, the rest are dropped |
| without a marker (rejected_not_official_speaker). A sitting without an official piece has no rows. |
| |
| Stats: rows_split_out counts the extra rows made in step 2, so kept + rejected == rows_raw_extracted |
| + rows_split_out. A piece whose text did not change keeps its stored token_count; every other piece |
| is counted again with tiktoken cl100k_base. |
| |
| A fresh `build()` from the PDFs cuts at the same lines with the same code but does not know the |
| input turns: it numbers the cut turns consecutively ("..._<turn_idx>" without "_<k>") and hashes |
| the cut turns for `content_sha1`. The PDFs are not available here, so that equivalence of text, |
| author and order is by construction and not checked. The old indent test (a label line started within |
| 6 columns of the margin) is gone from both, because the stored text has no indentation. |
| |
| It also writes sejm_committee_transcripts.speaker-roles.csv, one row per distinct role label (the |
| speaker label with the person's name cut off), decision and rule, with piece and character counts. |
| |
| The inputs are the pre-filter release files, pinned by SHA-256. Restore them before a rerun: |
| git checkout 0bbdb0d -- data/sejm_committee_transcripts/sejm_committee_transcripts.{parquet,attribution.jsonl,stats.json} |
| python3 src/clean_sejm_committee_transcripts.py |
| """ |
| from __future__ import annotations |
|
|
| import argparse |
| import csv |
| import json |
| import re |
| from collections import Counter, defaultdict |
| from pathlib import Path |
|
|
| import pyarrow as pa |
| import pyarrow.parquet as pq |
|
|
| from fetch_sejm_committee_transcripts import ( |
| ATTRIBUTION_KEYS, FIELDS, MIN_TURN_CHARS, SOURCE, SPEAKER_RULES, classify_speaker, count_tokens, dedup_turns, |
| shard_stats, split_at_labels, strip_page_blocks, turn_text) |
| from sejm_api_common import check_pin, replace_all, write_json |
|
|
| ROOT = Path(__file__).resolve().parents[1] |
| DATA = ROOT / "data" / SOURCE |
| |
| INPUT_SHA256 = { |
| f"{SOURCE}.parquet": "03ad043249a4ac1d5cb7ab68792fa62cae53066cfd8017ffd5ca42af6ab946b5", |
| f"{SOURCE}.attribution.jsonl": "d7277bad9abae279cd5b417e6504c9bcb17c832b41281991b2038489a5453f83", |
| f"{SOURCE}.stats.json": "e24f5c0fb638b54cb6b6c4086b95f0fb771cde714a60434a769f2376252b0831", |
| } |
| ROLES_CSV = f"{SOURCE}.speaker-roles.csv" |
| ROLES_HEADER = ["role", "decision", "rule", "turns", "characters", "speaker_labels"] |
|
|
| |
| |
| |
| _CAP, _LOW = "A-ZĄĆĘŁŃÓŚŹŻ", "a-ząćęłńóśźżéüöäèç" |
| _NAME_TOKEN = re.compile(rf"[{_CAP}][{_LOW}'’.]+(?:-[{_CAP}][{_LOW}'’]+)*|[{_CAP}]\.") |
| _PARTICLES = {"de", "von", "van", "vel", "di", "du", "la", "le", "da", "ter", "den", "der", "ibn", "bin", "al", "el"} |
| _PARTY_TAIL = re.compile(r"(.+?) \([^()]{1,60}\)((?: ?[–−-] ?.*)?)") |
| _MP_LABEL = re.compile(r"(?:Przewodnicząc\w+ |Wiceprzewodnicząc\w+ )?(?:Poseł|Posłanka|poseł|posłanka) (.+?) \([^)]+\)") |
|
|
|
|
| def given_names(labels) -> set[str]: |
| """First names taken from the MP labels ("Poseł Jan Maria Kowalski (PARTY)").""" |
| names: set[str] = set() |
| for label in labels: |
| if match := _MP_LABEL.match(label): |
| names.update(match.group(1).split()[:-1]) |
| return names |
|
|
|
|
| def role_of(label: str, given: set[str]) -> str: |
| """`label` without the person's name: surname (with particles), then given names, are cut. |
| |
| A party in parentheses ends the name of an MP label; what follows it (" – spoza składu |
| Komisji") stays with the role. A label whose last token is not a name ("Głos z sali") is |
| its own role.""" |
| suffix = "" |
| if match := _PARTY_TAIL.fullmatch(label): |
| label, suffix = match.groups() |
| tokens = label.split() |
| cut = len(tokens) - 1 |
| if cut < 1 or not _NAME_TOKEN.fullmatch(tokens[-1]): |
| return label + suffix |
| while cut - 1 >= 1 and tokens[cut - 1].lower() in _PARTICLES: |
| cut -= 1 |
| if cut - 1 >= 1 and _NAME_TOKEN.fullmatch(tokens[cut - 1]): |
| cut -= 1 |
| while cut - 1 >= 1 and tokens[cut - 1] in given: |
| cut -= 1 |
| return " ".join(tokens[:cut]) + suffix |
|
|
|
|
| def roles_table(label_stats: dict, roles: dict | None = None) -> list[list]: |
| """CSV rows from {key: (turns, characters, rule or None)}, biggest first. |
| |
| `roles` maps each key to its role; without it the keys are speaker labels and the role is the |
| label without the person's name (role_of).""" |
| if roles is None: |
| given = given_names(label_stats) |
| roles = {label: role_of(label, given) for label in label_stats} |
| groups: dict[tuple[str, str, str], list[int]] = defaultdict(lambda: [0, 0, 0]) |
| for key, (turns, characters, rule) in label_stats.items(): |
| group = groups[(roles[key], "include" if rule else "exclude", rule or "")] |
| group[0] += turns |
| group[1] += characters |
| group[2] += 1 |
| rows = [[role, decision, rule, *counts] for (role, decision, rule), counts in groups.items()] |
| return sorted(rows, key=lambda row: (-row[4], row[0], row[1], row[2])) |
|
|
|
|
| def write_roles(path: Path, rows: list[list]) -> None: |
| with path.open("w", encoding="utf-8", newline="") as stream: |
| writer = csv.writer(stream, lineterminator="\n") |
| writer.writerow(ROLES_HEADER) |
| writer.writerows(rows) |
|
|
|
|
| def cut_turn(row: dict, attribution: dict) -> tuple[list[dict], dict]: |
| """(pieces, page-block counts) of one input turn (steps 1 and 2 of the module docstring). |
| |
| A piece is the row fields and the sidecar fields in one dict; `token_count` is None where the |
| text is new and has to be counted.""" |
| lines, counts = strip_page_blocks(row["text"].split("\n")) |
| pieces = [] |
| for k, (label, body) in enumerate(split_at_labels(lines)): |
| piece = {**row, **attribution, "text": turn_text(body)} |
| if k: |
| piece.update(id=f"{row['id']}_{k}", author=label, speaker=label) |
| if k or piece["text"] != row["text"]: |
| piece["token_count"] = None |
| pieces.append(piece) |
| return pieces, counts |
|
|
|
|
| def build(input_dir: Path, out_dir: Path) -> dict: |
| for name, sha in INPUT_SHA256.items(): |
| check_pin(input_dir / name, sha, f"restore it with `git checkout 0bbdb0d -- data/{SOURCE}/{name}`") |
| table = pq.read_table(input_dir / f"{SOURCE}.parquet") |
| with (input_dir / f"{SOURCE}.attribution.jsonl").open(encoding="utf-8") as stream: |
| sidecar = [json.loads(line) for line in stream] |
| stats = json.loads((input_dir / f"{SOURCE}.stats.json").read_text(encoding="utf-8")) |
| rows = table.to_pylist() |
| if [r["id"] for r in rows] != [a["id"] for a in sidecar]: |
| raise SystemExit("the attribution sidecar does not line up with the input Parquet") |
| recomputed = shard_stats(rows, sidecar) |
| if recomputed != {key: stats[key] for key in recomputed}: |
| raise SystemExit("the input stats.json does not describe the input Parquet") |
|
|
| pieces, page_blocks = [], Counter() |
| for row, attribution in zip(rows, sidecar): |
| cut, counts = cut_turn(row, attribution) |
| pieces += cut |
| page_blocks.update(counts) |
| rows_split_out = len(pieces) - len(rows) |
| if len({p["id"] for p in pieces}) != len(pieces): |
| raise SystemExit("cutting the turns made duplicate ids") |
| long_enough = [p for p in pieces if len(p["text"]) >= MIN_TURN_CHARS] |
| too_short = len(pieces) - len(long_enough) |
| pieces, joint_dup, exact_dup = dedup_turns(long_enough) |
| if joint_dup: |
| raise SystemExit("the input holds a joint-sitting duplicate; it was deduplicated before") |
| new_text = [p for p in pieces if p["token_count"] is None] |
| for piece, tokens in zip(new_text, count_tokens([p["text"] for p in new_text])): |
| piece["token_count"] = tokens |
|
|
| rule_of = {label: classify_speaker(label) for label in {p["author"] for p in pieces}} |
| label_stats: dict[str, list] = {label: [0, 0, rule] for label, rule in rule_of.items()} |
| for piece in pieces: |
| entry = label_stats[piece["author"]] |
| entry[0] += 1 |
| entry[1] += len(piece["text"]) |
| kept = [p for p in pieces if rule_of[p["author"]]] |
| dropped = [p for p in pieces if not rule_of[p["author"]]] |
| kept_rows = [{field: p[field] for field in FIELDS} for p in kept] |
| kept_sidecar = [{key: p[key] for key in ATTRIBUTION_KEYS} | {"id": p["id"]} for p in kept] |
|
|
| removed = {"turns": len(dropped), "characters": sum(len(p["text"]) for p in dropped), |
| "tokens": sum(p["token_count"] for p in dropped), |
| "speaker_labels": sum(1 for rule in rule_of.values() if rule is None)} |
| kept_by_rule = {} |
| for rule_id, _ in SPEAKER_RULES: |
| matched = [entry for entry in label_stats.values() if entry[2] == rule_id] |
| kept_by_rule[rule_id] = {"speaker_labels": len(matched), "turns": sum(e[0] for e in matched), |
| "characters": sum(e[1] for e in matched)} |
|
|
| stats.update(shard_stats(kept_rows, kept_sidecar)) |
| stats["rows_split_out"] = rows_split_out |
| stats["rejected_too_short"] = too_short |
| stats["rejected_exact_dup"] += exact_dup |
| stats["rejected_not_official_speaker"] = removed["turns"] |
| stats["rejected"] += too_short + exact_dup + removed["turns"] |
| stats["page_blocks"] = {"removed": page_blocks["blocks"], "hyphenated_words_rejoined": page_blocks["rejoined"], |
| "glued_footers_repaired": page_blocks["fused"], |
| "stray_footers_removed": page_blocks["lone_footers"]} |
| stats["speaker_allowlist"] = {"input_sha256": INPUT_SHA256, "removed": removed, "kept_by_rule": kept_by_rule} |
| if stats["kept"] + stats["rejected"] != stats["rows_raw_extracted"] + rows_split_out: |
| raise SystemExit("stats drop counts do not add up to the extracted rows") |
|
|
| replace_all({ |
| out_dir / f"{SOURCE}.parquet": lambda p: pq.write_table( |
| pa.Table.from_pylist(kept_rows, schema=table.schema), p, compression="zstd"), |
| out_dir / f"{SOURCE}.attribution.jsonl": lambda p: p.write_text( |
| "".join(json.dumps(line, ensure_ascii=False, sort_keys=True) + "\n" for line in kept_sidecar), encoding="utf-8"), |
| out_dir / f"{SOURCE}.stats.json": lambda p: write_json(p, stats), |
| out_dir / ROLES_CSV: lambda p: write_roles( |
| p, roles_table({label: tuple(entry) for label, entry in label_stats.items()})), |
| }) |
| return stats |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser(description=__doc__.split("\n")[0]) |
| parser.add_argument("--data", type=Path, default=DATA, help="directory holding the (restored) input files; outputs are written there") |
| args = parser.parse_args() |
| print(json.dumps(build(args.data, args.data), indent=2, ensure_ascii=False)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
