| |
| """Drop PAP reprints and other third-party texts from `govpl` and write a per-row URL sidecar. |
| |
| gov.pl's copyright page (https://www.gov.pl/web/gov/prawa-autorskie) licenses the |
| site's text under CC BY-SA 4.0 but excludes works whose copyright belongs to third |
| parties. Articles that credit PAP (Polish Press Agency) as their source are such |
| works (slayerlabs/polish-dynaword-v2#51). `fetch_govpl.pap_rule` names them; this |
| script removes them from the released Parquet, so ids and the other rows stay as they |
| are (a rebuild through build_dynaword.py would renumber ids). |
| |
| Other third-party texts are dropped by `govpl.third-party-review.csv` (polish-dynaword-v2#106): |
| one decision per article that carries a "Źródło:" line (`ZRODLO`) and is not a PAP reprint, |
| plus six articles reprinted from or written for other outlets. A "Źródło:" article stays only |
| when its text is credited to a public office (`credit_public_office`) or the line credits |
| something other than the text, such as data, a chart, a reference or a quotation |
| (`no_text_credit`). The review must list exactly the non-PAP articles that match `ZRODLO`, |
| plus the `third_party_text` ones. |
| |
| The releases of the prosecutor offices' sections (`fetch_govpl.PROSECUTOR_SECTION`: |
| prokuratura-krajowa, pr-*, po-*) are dropped too. They report criminal cases about people |
| who can often be identified, even from initials. A row's section is the subsite of its |
| first fetched URL; no text was fetched from both a prosecutor and another section. |
| |
| `govpl.attribution.jsonl` gives each kept row the gov.pl URL, subsite, title and date |
| of the fetched article, matched on build_dynaword's dedup key (SHA-1 of the stripped |
| text) in the fetch output `govpl.jsonl.zst`. Where the same text was fetched from |
| several URLs, the first one in fetch order is used. |
| |
| The inputs and the review are pinned by SHA-256. The Parquet, as of v0.2.5, |
| predates the October 2026 rights audit and is no longer published: |
| the release tags v0.2.0-v0.2.5 that held it were deleted after the audit. |
| The pins record which files a rerun needs; with them in place: |
| python3 src/clean_govpl.py --fetched ~/speakleash/govpl.jsonl.zst |
| """ |
| from __future__ import annotations |
|
|
| import argparse |
| import hashlib |
| import io |
| import json |
| import os |
| import re |
| import sys |
| from collections import Counter |
| from pathlib import Path |
|
|
| import pyarrow.parquet as pq |
| import zstandard |
|
|
| sys.path.insert(0, str(Path(__file__).resolve().parent)) |
| from fetch_govpl import KEY as SOURCE, PROSECUTOR_SECTION, pap_rule |
| from sejm_api_common import UNPUBLISHED, check_pin, read_pinned_review |
|
|
| ROOT = Path(__file__).resolve().parents[1] |
| DATA = ROOT / "data" / SOURCE |
| INPUT_SHA256 = "9c0310fcdf45804e6547bd197cba55f58f12df618cd3d8b92b8e9077a3720b9f" |
| FETCHED_SHA256 = "368259d0ea8522eced71b426ae238556d5330a410aa994bdcbdc7427478d783a" |
| REVIEW_SHA256 = "599f678bb1f3e1d058b3d115667e73331f3324eaccc9766cf54694860533e90b" |
| REVIEW_REASONS = { |
| "keep": {"credit_public_office", "no_text_credit"}, |
| "drop": {"credit_media", "credit_other", "third_party_text"}, |
| } |
| ZRODLO = re.compile(r"(?i)\b[źżz]r[óo]d[łl][oa](?:\s+informacji)?\s*:") |
| BUILD_STATS = { |
| "read": 90140, "drop_short": 0, "drop_lang": 24, "drop_dup": 1926, "drop_ocr": 0, |
| } |
|
|
|
|
| def text_key(text: str) -> bytes: |
| """build_dynaword's dedup key.""" |
| return hashlib.sha1(text.strip().encode("utf-8")).digest() |
|
|
|
|
| def fetched_meta(path: Path) -> dict[bytes, dict]: |
| """text_key -> meta of the first fetched record with that text.""" |
| meta: dict[bytes, dict] = {} |
| with path.open("rb") as compressed: |
| lines = io.TextIOWrapper(zstandard.ZstdDecompressor().stream_reader(compressed), encoding="utf-8") |
| for line in lines: |
| if line.strip(): |
| record = json.loads(line) |
| meta.setdefault(text_key(record["text"]), record["meta"]) |
| return meta |
|
|
|
|
| def build(input_path: Path, fetched_path: Path, review_path: Path, out_dir: Path) -> dict: |
| check_pin(input_path, INPUT_SHA256, UNPUBLISHED) |
| check_pin(fetched_path, FETCHED_SHA256, "it is not the 2026-07-19 gov.pl crawl") |
| review = read_pinned_review(review_path, REVIEW_SHA256, "it is not the reviewed govpl.third-party-review.csv", |
| REVIEW_REASONS) |
| table = pq.read_table(input_path) |
| meta = fetched_meta(fetched_path) |
|
|
| kept, attribution, dropped, dropped_third_party, dropped_prosecutor = [], [], Counter(), Counter(), 0 |
| mismatched, seen = [], set() |
| for row in table.to_pylist(): |
| if rule := pap_rule(row["text"]): |
| dropped[rule] += 1 |
| continue |
| decision, reason = review.get(row["id"], (None, None)) |
| if decision: |
| seen.add(row["id"]) |
| if bool(ZRODLO.search(row["text"])) != (decision is not None and reason != "third_party_text"): |
| mismatched.append(row["id"]) |
| if decision == "drop": |
| dropped_third_party[reason] += 1 |
| continue |
| found = meta.get(text_key(row["text"])) |
| if found is None: |
| raise SystemExit(f"{row['id']}: text not found in {fetched_path}") |
| if PROSECUTOR_SECTION.match(found["subsite"]): |
| dropped_prosecutor += 1 |
| continue |
| kept.append(row) |
| attribution.append({ |
| "id": row["id"], "url": found["url"], "subsite": found["subsite"], |
| "title": found["title"], "date": found["date"], "license": row["license"], |
| }) |
| if mismatched: |
| raise SystemExit(f"{len(mismatched)} rows where the review and the \"Źródło:\" match disagree: {mismatched[:5]}") |
| if missing := sorted(review.keys() - seen): |
| raise SystemExit(f"{len(missing)} reviewed ids are not in the input or are PAP reprints: {missing[:5]}") |
|
|
| stats = { |
| **BUILD_STATS, "drop_pap": sum(dropped.values()), "drop_pap_by_rule": dict(dropped), |
| "drop_third_party": sum(dropped_third_party.values()), |
| "drop_third_party_by_reason": dict(sorted(dropped_third_party.items())), |
| "drop_prosecutor": dropped_prosecutor, |
| "kept": len(kept), |
| "chars": sum(len(r["text"]) for r in kept), "tokens": sum(r["token_count"] for r in kept), |
| "licenses": dict(Counter(r["license"] for r in kept)), |
| "authors_with_value": sum(bool(r["author"]) for r in kept), "license": "CC-BY-SA-4.0", |
| "input_rows": table.num_rows, "input_sha256": INPUT_SHA256, "fetched_sha256": FETCHED_SHA256, |
| "review_sha256": REVIEW_SHA256, |
| } |
| build_drops = sum(v for k, v in BUILD_STATS.items() if k.startswith("drop_")) |
| if stats["read"] - build_drops != table.num_rows: |
| raise SystemExit("BUILD_STATS does not add up to the input row count") |
| staged = { |
| out_dir / f"{SOURCE}.parquet.tmp": lambda p: pq.write_table( |
| table.from_pylist(kept, schema=table.schema), p, compression="zstd"), |
| out_dir / f"{SOURCE}.attribution.jsonl.tmp": lambda p: p.write_text( |
| "".join(json.dumps(a, ensure_ascii=False) + "\n" for a in attribution), encoding="utf-8"), |
| out_dir / f"{SOURCE}.stats.json.tmp": lambda p: p.write_text( |
| json.dumps(stats, indent=2, ensure_ascii=False) + "\n", encoding="utf-8"), |
| } |
| for path, write in staged.items(): |
| write(path) |
| for path in staged: |
| os.replace(path, path.with_suffix("")) |
| return stats |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser(description=__doc__.split("\n")[0]) |
| parser.add_argument("--input", type=Path, default=DATA / f"{SOURCE}.parquet") |
| parser.add_argument("--fetched", type=Path, required=True, help="govpl.jsonl.zst from fetch_govpl.py") |
| parser.add_argument("--review", type=Path, default=DATA / f"{SOURCE}.third-party-review.csv") |
| parser.add_argument("--out", type=Path, default=DATA) |
| args = parser.parse_args() |
| print(json.dumps(build(args.input, args.fetched, args.review, args.out), indent=2, ensure_ascii=False)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
