turn block, or a lone ): a komentarz continues the speaker before it in the same block only.""" system, house = meta["system"], meta["house"] kept, labels, dropped = [], {}, 0 body = ET.fromstring(z.read(d + "text_structure.xml")).find(f".//{T}body") def count(label, role, rule, text, keep): nonlocal dropped stat = acc["labels"][(role, label, rule if keep else None)] stat[0] += 1 stat[1] += len(text) if keep: kept.append(text) labels.setdefault(label, None) acc["stats"]["kept_chars_by_rule"][rule] += len(text) else: dropped += len(text) for block in body: current = None # (label, role, rule) of the turn going on switch = None # (who, label, role, rule) of a speaker line inside a turn for u in ([block] if block.tag == f"{T}u" else block.iter(f"{T}u")): who = (u.get("who") or "").lstrip("#") text = collapse("".join(u.itertext())) if not text: continue if switch and who not in (COMMENTARY, switch[0]): switch = None line = text[:-1].strip() if text.endswith(":") and (is_label(line) or classify_label(line, system, house)[0]): rule, reason = speakers.free(line, system, house) acc["stats"]["inline_labels"][reason] += 1 current = (line, role_of(line, set()), rule) switch = (who, *current) acc["stats"]["dropped_chars"]["inline_label_line"] += len(text) dropped += len(text) continue if who == COMMENTARY: if ": " in text: kind, keep = "komentarz_colon", False elif STAGE_DIRECTION.fullmatch(text): kind, keep = "stage_direction", True elif current is None: kind, keep = "komentarz_unattributed", False else: kind, keep = ("komentarz_continuation", True) if current[2] else ("komentarz_continuation_dropped", False) acc["stats"]["komentarz"][kind] += len(text) if not keep: acc["stats"]["dropped_chars"][kind] += len(text) count(COMMENTARY, COMMENTARY, kind, text, keep) continue if switch: speaker = switch[1:] elif who in persons: speaker = persons[who][:3] else: speaker = ("", "(unknown who)", None) acc["stats"]["dropped_chars"]["unknown_who"] += len(text) current = speaker label, role, rule = speaker if not rule and who in persons and not switch: acc["stats"]["dropped_chars"]["speaker:" + persons[who][3]] += len(text) elif not rule and switch: acc["stats"]["dropped_chars"]["inline_speaker"] += len(text) count(label, role, rule, text, bool(rule)) return kept, list(labels), dropped def scan_headers(z, docs, speakers, stats): """Pass 1: the verdict on every person of the zip's sittings, and the zip's member set. Headers of docs under DROP_PREFIXES count too: a chair of 2019-2023 is checked against that term's MPs. A member rule makes its person a member; with a name _NAME refuses only in a plenary sitting, where a "Poseł" is an MP, and only for a _LONG_NAME (a committee's "Poseł ... z Litwy" is a foreign guest).""" raw = {} for d in docs: if "/interpelacje/" in d: continue header, meta = doc_meta(z, d) persons = {} for person in header.iter(f"{T}person"): label, role, rule, reason, key = speakers.structured(person, meta["system"], meta["house"]) persons[person.get(XID)] = [label, role, rule, reason, key] if rule in MEMBER_RULES and (reason == "structured" or ( reason == "bad_name" and "/posiedzenia/" in d and _LONG_NAME.fullmatch(" ".join(key[0] + key[1])))): speakers.members.add(name_key(key)) raw[d] = (meta, persons) for d, (meta, persons) in raw.items(): for record in persons.values(): label, role, rule, reason, key = record if rule and reason == "bad_name": if is_member(key, speakers.members): record[3] = "bad_name_member" else: record[2] = rule = None if rule and not chair_is_member(rule, key, speakers.members): record[2], record[3] = None, "chair_not_member" if record[2]: speakers.kept_labels.add(label) if key: speakers.kept_names.add(" ".join(key[0] + key[1])) for d, (meta, persons) in raw.items(): for record in persons.values(): if record[3] == "free": record[2], record[3] = speakers.free(record[0], meta["system"], meta["house"]) record[1] = role_of(record[0], set()) if not d.startswith(DROP_PREFIXES): stats["persons"][record[3]] += 1 return raw def process_zip(job): """Pass 1 + pass 2 over one zip; writes /parts/.parquet and .jsonl, returns the tallies.""" term, size, sha, dump, out = job import pyarrow as pa import pyarrow.parquet as pq path = Path(dump) / f"{term}-tei.zip" if path.stat().st_size != size or sha256_file(path) != sha: raise SystemExit(f"{path} does not match the pinned size/SHA-256; rerun with --download") stats = {k: Counter() for k in ("dropped_docs", "dropped_chars", "kept_chars_by_rule", "komentarz", "inline_labels", "persons")} stats |= {"persons_p_strip": 0, "persons_p2_fallback": 0} # the row tallies are merge()'s, after the dedup acc = {"stats": stats, "labels": defaultdict(lambda: [0, 0])} speakers = Speakers(stats) schema = pa.schema([(f, pa.int64() if f == "token_count" else pa.string()) for f in FIELDS]) parts = Path(out) / "parts" with zipfile.ZipFile(path) as z: names = set(z.namelist()) docs = sorted(n[:-len("header.xml")] for n in names if n.endswith("/header.xml")) raw = scan_headers(z, docs, speakers, stats) writer = pq.ParquetWriter(parts / f"{term}.parquet", schema, compression="zstd") attribution = open(parts / f"{term}.jsonl", "w", encoding="utf-8") batch = [] def flush(): for (row, _), tokens in zip(batch, count_tokens([row["text"] for row, _ in batch])): row["token_count"] = tokens if batch: writer.write_table(pa.Table.from_pylist([r for r, _ in batch], schema=schema)) for _, line in batch: attribution.write(json.dumps(line, ensure_ascii=False, sort_keys=True) + "\n") batch.clear() for d in docs: if d.startswith(DROP_PREFIXES): stats["dropped_docs"]["prefix_sejm_2019_2027"] += 1 continue if d + "text_structure.xml" not in names: stats["dropped_docs"]["no_text_structure"] += 1 continue kind = "interpellation" if "/interpelacje/" in d else "sitting" if kind == "interpellation": _, meta = doc_meta(z, d) text, speakers_kept, dropped = interpellation_text(z, d), [], 0 else: meta, persons = raw[d] lines, speakers_kept, dropped = sitting_text(z, d, meta, persons, speakers, acc) text = "\n".join(lines) if not text: stats["dropped_docs"][f"empty_{kind}"] += 1 continue text, repair = fix_encoding(text) text, _ = redact(text) if len(text) < MIN_CHARS: # its turns stay counted under their rule: dropped_chars is the allowlist's stats["dropped_docs"][f"short_{kind}"] += 1 continue docid = d.rstrip("/").rsplit("/", 1)[1] row = {"id": f"{SOURCE}_{docid}", "text": text, "source": SOURCE, "added": ADDED, "created": meta["created"], "token_count": 0, "license": LICENSE, "author": meta["author"]} line = {"id": row["id"], "ppc_path": d.rstrip("/"), "term": term, "system": meta["system"], "house": meta["house"], "type": meta["type"], "term_no": meta["termNo"], "date": meta["date"], "created": meta["created"], "speakers": speakers_kept, "kept_characters": len(text), "dropped_characters": dropped, "author": meta["author"], "encoding_repair": repair} batch.append((row, line)) if len(batch) >= 500: flush() flush() writer.close() attribution.close() return term, stats, dict(acc["labels"]) # ------------------------------------------------------------------ download, merge def download(dump): """Fetch any zip that is missing or the wrong size; a fresh download must match its SHA-256.""" dump.mkdir(parents=True, exist_ok=True) for term, size, sha in MANIFEST: path = dump / f"{term}-tei.zip" if path.exists() and path.stat().st_size == size: continue part = path.with_name(path.name + ".part") request = urllib.request.Request(DUMP_URL.format(term=term), headers={"User-Agent": "polish-dynaword"}) with urllib.request.urlopen(request, timeout=120) as response, open(part, "wb") as fh: shutil.copyfileobj(response, fh, 1 << 20) if part.stat().st_size != size or sha256_file(part) != sha: raise SystemExit(f"{part}: size or SHA-256 differs from the 2025-05-21 dump") os.replace(part, path) def merge(out, results): """Concatenate the per-zip parts in MANIFEST order, keeping the first copy of each text; sum the tallies.""" import pyarrow.parquet as pq root, parts = Path(out) / "data" / SOURCE, Path(out) / "parts" root.mkdir(parents=True, exist_ok=True) tally = {k: Counter() for k in ("docs_by_category", "chars_by_category", "encoding_repair")} tally |= dict.fromkeys(("kept", "chars", "tokens", "authors_with_value", "redactions"), 0) extremes = {k: {} for k in ("date_min", "date_max", "created_min", "created_max")} ids, first, duplicates, writer = set(), {}, 0, None with open(root / f"{SOURCE}.attribution.jsonl", "w", encoding="utf-8") as attribution, \ open(root / f"{SOURCE}.decisions.jsonl", "w", encoding="utf-8") as decisions: for term, _, _ in MANIFEST: table = pq.read_table(parts / f"{term}.parquet") with open(parts / f"{term}.jsonl", encoding="utf-8") as fh: lines = [json.loads(line) for line in fh] keep = [] for i, (rid, text, tokens, line) in enumerate(zip( table.column("id").to_pylist(), table.column("text").to_pylist(), table.column("token_count").to_pylist(), lines, strict=True)): if rid in ids or rid != line["id"]: raise SystemExit(f"duplicate or misaligned id {rid}") ids.add(rid) digest = hashlib.sha256(text.encode("utf-8")).digest() if digest in first: decisions.write(json.dumps({"id": rid, "duplicate_of": first[digest]}) + "\n") duplicates += 1 continue first[digest] = rid keep.append(i) attribution.write(json.dumps(line, ensure_ascii=False, sort_keys=True) + "\n") category = f"{line['system']}|{line['house']}|{line['type']}" tally["kept"] += 1 tally["chars"] += len(text) tally["tokens"] += tokens tally["authors_with_value"] += bool(line["author"]) tally["redactions"] += len(REDACTION_TAGS.findall(text)) # redact()'s tags: the dump has none tally["docs_by_category"][category] += 1 tally["chars_by_category"][category] += len(text) if line["encoding_repair"]: tally["encoding_repair"][line["encoding_repair"]] += 1 house, created = line["house"], line["created"].split(", ") for key, value, pick in (("created_min", created[0], min), ("created_max", created[-1], max)) + ( (("date_min", created[0], min), ("date_max", created[-1], max)) if line["date"] else ()): extremes[key][house] = pick(extremes[key].get(house, value), value) if writer is None: writer = pq.ParquetWriter(root / f"{SOURCE}.parquet", table.schema, compression="zstd") writer.write_table(table.take(keep)) writer.close() labels, total, scalars = defaultdict(lambda: [0, 0, None]), defaultdict(Counter), Counter() for term, stats, label_stats in results: for key, (turns, chars) in label_stats.items(): labels[key][0] += turns labels[key][1] += chars labels[key][2] = key[2] for k, v in stats.items(): if isinstance(v, Counter): total[k].update(v) else: scalars[k] += v total["dropped_docs"]["exact_duplicate"] = duplicates rows = roles_table({key: tuple(v) for key, v in labels.items()}, {key: key[0] for key in labels}) write_roles(root / f"{SOURCE}.speaker-roles.csv", rows) stats = { "license": LICENSE, "licenses": {LICENSE: tally["kept"]}, "created_min": min(extremes["created_min"].values()), "created_max": max(extremes["created_max"].values()), **{f"{k}_by_house": dict(sorted(v.items())) for k, v in extremes.items()}, "added": ADDED, "dump": "2025-05-21", "drop_prefixes": list(DROP_PREFIXES), "sejm_coverage_end": PARLIAMENTARY_SEJM_END, **{k: dict(sorted(v.items())) for k, v in total.items()}, **dict(scalars), **{k: dict(sorted(v.items())) if isinstance(v, Counter) else v for k, v in tally.items()}, } write_json(root / f"{SOURCE}.stats.json", stats) shutil.rmtree(parts) return stats def build(dump, out, workers): (Path(out) / "parts").mkdir(parents=True, exist_ok=True) jobs = sorted(((t, s, h, str(dump), str(out)) for t, s, h in MANIFEST), key=lambda j: -j[1]) # largest first with ProcessPoolExecutor(workers) as pool: results = list(pool.map(process_zip, jobs)) return merge(out, results) def main(argv=None): parser = argparse.ArgumentParser(description=__doc__.split("\n")[0]) parser.add_argument("--dump", type=Path, default=Path("ppc-tei-20250521")) parser.add_argument("--out", type=Path, default=Path(".")) parser.add_argument("--download", action="store_true", help="fetch missing zips from kdp.ipipan.waw.pl") parser.add_argument("--workers", type=int, default=min(12, os.cpu_count() or 1)) args = parser.parse_args(argv) if args.download: download(args.dump) stats = build(args.dump, args.out, args.workers) print(json.dumps({k: stats[k] for k in ("kept", "chars", "tokens", "created_min", "created_max")}, indent=1)) if __name__ == "__main__": sys.exit(main())