#!/usr/bin/env python3 """Build a reproducible, ontology-backed Polish DynaWord Sejm API contribution.""" from __future__ import annotations import argparse import ast import collections import datetime as dt import hashlib import json import os import pathlib import re import shutil import sys from typing import Any, Iterable SOURCE_NAME = "sejm_api" SOURCE_REPOSITORY = "PiotrSty/sejm-speeches-corpus" SOURCE_RELEASE = "v1.0.1" TARGET_REPOSITORY = "SlayerLab/polish-dynaword" SOURCE_LICENSE = "public-domain (official documents)" START_DATE = "2023-01-01" EXPECTED_FIELDS = ( "id", "text", "source", "added", "created", "token_count", "license", "author" ) SOURCE_FIELDS = ( "text", "speaker", "date", "term", "source_url", "char_count", "word_count", "has_events" ) COPYRIGHT_ACT = "https://eli.gov.pl/api/acts/DU/2025/24/text/O/D20250024.pdf" OPEN_DATA_ACT = "https://eli.gov.pl/api/acts/DU/2023/1524/text.html" SEJM_API = "https://api.sejm.gov.pl/" SEJM_API_DOCUMENTATION = "https://api.sejm.gov.pl/sejm.html" COMMIT_PATTERN = re.compile(r"^[0-9a-f]{40}$") class ContributionError(ValueError): """Raised when the contribution cannot meet its declared contract.""" def canonical_sha256(value: Any) -> str: payload = json.dumps( value, ensure_ascii=False, sort_keys=True, separators=(",", ":") ).encode("utf-8") return hashlib.sha256(payload).hexdigest() def sha256_file(path: pathlib.Path) -> str: digest = hashlib.sha256() with path.open("rb") as stream: for chunk in iter(lambda: stream.read(1024 * 1024), b""): digest.update(chunk) return digest.hexdigest() def stable_document_id(row: dict[str, Any]) -> str: material = "\x1f".join( str(row.get(field, "")).strip() for field in ("date", "term", "speaker", "text") ) return f"{SOURCE_NAME}_{hashlib.sha256(material.encode('utf-8')).hexdigest()}" def text_fingerprint(text: str) -> str: return hashlib.sha1(text.encode("utf-8")).hexdigest() def normalize_source_row( row: dict[str, Any], *, start_date: str, added_date: str, encoder: Any ) -> tuple[dict[str, Any], dict[str, Any]] | None: missing = set(SOURCE_FIELDS) - set(row) if missing: raise ContributionError(f"missing required source fields: {sorted(missing)}") try: created = dt.date.fromisoformat(str(row["date"])[:10]).isoformat() threshold = dt.date.fromisoformat(start_date) dt.date.fromisoformat(added_date) except ValueError as exc: raise ContributionError("source, threshold and addition dates must be ISO dates") from exc if dt.date.fromisoformat(created) < threshold: return None text = str(row["text"]).strip() author = str(row.get("speaker", "")).strip() source_url = str(row.get("source_url", "")).strip() term = str(row.get("term", "")).strip() if len(text) < 200: raise ContributionError("source speech violates DynaWord's 200-character minimum") if not author: raise ContributionError("source speech lacks the promised speaker attribution") if not source_url.startswith("https://api.sejm.gov.pl/"): raise ContributionError(f"unexpected source URL: {source_url!r}") if term not in {"9", "10"}: raise ContributionError(f"unexpected post-2022 parliamentary term: {term!r}") document_id = stable_document_id(row) document = { "id": document_id, "text": text, "source": SOURCE_NAME, "added": added_date, "created": created, "token_count": len(encoder.encode_ordinary(text)), "license": SOURCE_LICENSE, "author": author, } attribution = { "id": document_id, "source_url": source_url, "speaker": author, "created": created, "term": term, "has_events": bool(row["has_events"]), "word_count": int(row["word_count"]), "char_count": int(row["char_count"]), "provider": "Kancelaria Sejmu RP", "source_release": f"hf://datasets/{SOURCE_REPOSITORY}@{SOURCE_RELEASE}", } return document, attribution def registry_source_end_date(registry: str, source_name: str) -> str: pattern = re.compile( rf'^\s{{4}}["\']{re.escape(source_name)}["\']\s*:\s*\{{' rf'(?P.*?)^\s{{4}}\}},?', flags=re.MULTILINE | re.DOTALL, ) match = pattern.search(registry) if not match: raise ContributionError(f"existing parliamentary source missing from registry: {source_name}") dates = re.findall(r"\d{4}-\d{2}-\d{2}", match.group("body")) if not dates: raise ContributionError(f"source {source_name} has no documented date range") return max(dates) def assert_temporal_novelty(registry: str, start_date: str) -> dict[str, str]: threshold = dt.date.fromisoformat(start_date) end_dates = { name: registry_source_end_date(registry, name) for name in ("parliamentary", "parlamint_pl") } overlapping = { name: value for name, value in end_dates.items() if dt.date.fromisoformat(value) >= threshold } if overlapping: raise ContributionError(f"candidate date range overlaps registered sources: {overlapping}") return end_dates def insert_source_registry_entry(registry: str, *, end_date: str) -> str: if re.search(r'^\s{4}["\']sejm_api["\']\s*:', registry, flags=re.MULTILINE): raise ContributionError("sejm_api already exists in the DynaWord source registry") marker = ' "parlamint_pl": {' if registry.count(marker) != 1: raise ContributionError("cannot safely locate the existing parlamint_pl registry entry") entry = ( ' "sejm_api": {\n' ' "file_key": "sejm_api",\n' ' "pretty": "Sejm API parliamentary speeches (2023 onward)",\n' ' "license": "public-domain (official documents)",\n' ' "license_spdx": "LicenseRef-Polish-Official-Documents",\n' ' "traceable": "Official parliamentary materials excluded from copyright "\n' ' "under Polish Copyright Act art. 4(2); reusable under "\n' ' "the Polish Open Data Act arts. 2(12), 5, 14 and 17.",\n' ' "upstream": "https://api.sejm.gov.pl/",\n' ' "provenance": "Direct official Sejm API records, preserved with speaker "\n' ' "attribution and immutable PiotrSty/sejm-speeches-corpus "\n' ' "v1.0.1 source provenance.",\n' ' "domain": "political/spoken",\n' f' "created": "{START_DATE}, {end_date}",\n' ' "is_ocr": False,\n' ' },\n' ) updated = registry.replace(marker, entry + marker, 1) ast.parse(updated) return updated def legal_evidence(*, source_revision: str, target_revision: str) -> dict[str, Any]: return { "status": "reviewed-open-official-materials", "source": SOURCE_NAME, "dataset_record_license": SOURCE_LICENSE, "hf_source_license_name": "polish-public-sector-open-statutory-reuse", "provider": "Kancelaria Sejmu RP", "official_source": SEJM_API, "official_source_documentation": SEJM_API_DOCUMENTATION, "copyright_basis": { "act": "Polish Copyright and Related Rights Act", "article": "4(2)", "finding": "official documents and materials are excluded from copyright", "url": COPYRIGHT_ACT, }, "reuse_basis": { "act": "Polish Open Data and Reuse of Public Sector Information Act", "articles": ["2(12)", "5", "6", "14(1)", "15", "17"], "url": OPEN_DATA_ACT, }, "limitations": [ "privacy and personal-data exceptions", "third-party rights and provider-specific conditions", "no upstream Creative Commons grant is asserted", ], "pinned_source": f"hf://datasets/{SOURCE_REPOSITORY}@{source_revision}", "pinned_target_base": f"hf://datasets/{TARGET_REPOSITORY}@{target_revision}", } def write_json(path: pathlib.Path, payload: Any) -> None: path.write_text( json.dumps(payload, ensure_ascii=False, indent=2, sort_keys=True) + "\n", encoding="utf-8", ) def source_datasheet( *, stats: dict[str, Any], source_revision: str, target_revision: str, prior_sources: dict[str, str], contribution_digest: str ) -> str: return f"""# sejm_api Contemporary official Polish Sejm speeches, supplementing existing parliamentary sources. ## Dataset description - Source (upstream): {SEJM_API} - Source documentation: {SEJM_API_DOCUMENTATION} - Domain: political/spoken - Language: Polish (`pl`) - License: `{SOURCE_LICENSE}` - Created (range): {stats['created_min']}, {stats['created_max']} - Added: {stats['added']} - Contributor: Piotr Styła (`PiotrSty` on Hugging Face; `PiotrStyla` on GitHub). ## Licensing — traceable basis Official parliamentary documents and materials are excluded from copyright by article 4(2) of the Polish Copyright Act: {COPYRIGHT_ACT}. Reuse of public-sector information is governed by articles 2(12), 5, 6, 14, 15 and 17 of the Polish Open Data Act: {OPEN_DATA_ACT}. The per-document value intentionally matches the existing `parliamentary` source. No unverified upstream Creative Commons license is asserted. ## Provenance and reproducibility - Official provider: Kancelaria Sejmu RP. - Immutable source release: `{SOURCE_REPOSITORY}@{SOURCE_RELEASE}`. - Pinned source commit: `{source_revision}`. - Reviewed DynaWord base commit: `{target_revision}`. - Rebuild: `python src/fetch_sejm_api.py --help`. - Source URLs and speech-level provenance are in `sejm_api.attribution.jsonl`. - Slayer contribution digest: `sha256:{contribution_digest}`. ## Temporal novelty and deduplication `parliamentary` ends on `{prior_sources['parliamentary']}` and registered `parlamint_pl` ends on `{prior_sources['parlamint_pl']}`. Every contributed record is dated on or after `{START_DATE}`, so its date range overlaps neither source. Exact duplicate speech texts within the contribution are removed using SHA-1 fingerprints; this is not a claim of global cross-domain near-deduplication. ## Statistics | Measure | Value | |---|---:| | Source rows inspected | {stats['read']:,} | | Rows before {START_DATE} | {stats['drop_before_start']:,} | | Exact duplicate texts removed | {stats['drop_dup']:,} | | Documents published | {stats['kept']:,} | | Characters | {stats['chars']:,} | | Tokens (`cl100k_base` proxy) | {stats['tokens']:,} | | Documents with speaker attribution | {stats['authors_with_value']:,} | Statistics are recomputed from the released Parquet file. The canonical schema is `id, text, source, added, created, token_count, license, author`. ## Privacy and limitations The upstream release heuristically redacts email addresses, PESEL identifiers and unambiguous Polish telephone numbers. Public-official names and speech attribution remain. Regex redaction is not a guarantee of zero personal data. Downstream users must review applicable privacy, third-party and source terms. """ def ontology_manifest( *, stats: dict[str, Any], source_revision: str, target_revision: str, prior_sources: dict[str, str], parquet_digest: str, sidecar_digest: str, legal_digest: str, actor: str, run_id: str, git_commit: str ) -> dict[str, Any]: config = { "source_release": SOURCE_RELEASE, "source_revision": source_revision, "target_base_revision": target_revision, "start_date": START_DATE, "added": stats["added"], "schema_fields": list(EXPECTED_FIELDS), "tokenizer": "cl100k_base", "exact_deduplication": "sha1(normalized_text)", "registered_parliamentary_end_dates": prior_sources, } version_digest = canonical_sha256({ "source": source_revision, "target": target_revision, "configuration": config, "parquet": parquet_digest, "attribution": sidecar_digest, "legal_evidence": legal_digest, "protocol": sha256_file(pathlib.Path(__file__)), }) version = f"slayer://version/dataset-source/sejm-api@sha256:{version_digest}" evidence_ids = { name: f"slayer://evidence/sejm-api-{name}@sha256:{version_digest[:20]}" for name in ("record-counts", "temporal-novelty", "author-attribution", "legal-basis", "artifact-digests") } evidence = [ {"id": evidence_ids["record-counts"], "run_id": run_id, "subject_version": version, "observation_type": "dataset_record_counts", "payload": {key: stats[key] for key in ("read", "kept", "drop_before_start", "drop_dup", "tokens")}}, {"id": evidence_ids["temporal-novelty"], "run_id": run_id, "subject_version": version, "observation_type": "registered_source_date_ranges", "payload": {"candidate_min": stats["created_min"], "candidate_max": stats["created_max"], "existing_source_end_dates": prior_sources}}, {"id": evidence_ids["author-attribution"], "run_id": run_id, "subject_version": version, "observation_type": "speaker_attribution_coverage", "payload": {"documents": stats["kept"], "attributed_documents": stats["authors_with_value"]}}, {"id": evidence_ids["legal-basis"], "run_id": run_id, "subject_version": version, "observation_type": "official_statutory_reuse_sources", "payload": {"copyright_act": COPYRIGHT_ACT, "open_data_act": OPEN_DATA_ACT, "source_documentation": SEJM_API_DOCUMENTATION, "license": SOURCE_LICENSE, "legal_evidence_sha256": legal_digest}}, {"id": evidence_ids["artifact-digests"], "run_id": run_id, "subject_version": version, "observation_type": "artifact_checksums", "payload": {"parquet_sha256": parquet_digest, "attribution_sha256": sidecar_digest}}, ] claims = [ {"id": f"slayer://claim/sejm-api-temporal-novelty@sha256:{version_digest[:20]}", "statement": "Every contributed speech postdates both registered parliamentary source ranges.", "falsification_condition": "Any contributed created date is <= either documented source end date.", "scope": [version], "supported_by": [evidence_ids["temporal-novelty"]], "asserted_by": actor}, {"id": f"slayer://claim/sejm-api-full-speaker-attribution@sha256:{version_digest[:20]}", "statement": "Every contributed document has a non-empty speech-speaker attribution.", "falsification_condition": "Any contributed document has an empty author field.", "scope": [version], "supported_by": [evidence_ids["author-attribution"]], "asserted_by": actor}, {"id": f"slayer://claim/sejm-api-open-official-materials@sha256:{version_digest[:20]}", "statement": "The source contains official parliamentary materials with documented statutory reuse.", "falsification_condition": "A record is not an official parliamentary material or an applicable statutory limitation defeats reuse.", "scope": [version], "supported_by": [evidence_ids["legal-basis"]], "asserted_by": actor}, ] return { "schema_version": "slayer.ai/dataset-source-contribution/v1", "object": {"id": "slayer://object/dataset-source/slayerlab-polish-dynaword-sejm-api", "kind": "dataset_source", "name": SOURCE_NAME}, "version": {"id": version, "digest": f"sha256:{version_digest}"}, "protocol": {"entrypoint": "python src/fetch_sejm_api.py", "git_commit": git_commit, "configuration": config}, "run": {"id": run_id, "actor_id": actor, "git_commit": git_commit, "inputs": [{"role": "source", "version_id": f"hf://datasets/{SOURCE_REPOSITORY}@{source_revision}"}, {"role": "target_base", "version_id": f"hf://datasets/{TARGET_REPOSITORY}@{target_revision}"}], "outputs": [{"role": "dataset_source", "version_id": version}]}, "relations": [ {"source_version": version, "predicate": "DERIVED_FROM", "target_version": f"hf://datasets/{SOURCE_REPOSITORY}@{source_revision}", "introduced_by_run": run_id}, {"source_version": version, "predicate": "COMPATIBLE_WITH", "target_version": f"hf://datasets/{TARGET_REPOSITORY}@{target_revision}", "introduced_by_run": run_id}, ], "evidence": evidence, "claims": claims, "claim_evidence": [ {"claim_id": claim["id"], "evidence_id": evidence_id, "relation": "SUPPORTS"} for claim in claims for evidence_id in claim["supported_by"] ], "actors": [{"id": actor, "kind": "automation" if actor.startswith("github:") else "human"}], "attestations": [ {"type": "schema_valid", "value": True, "fields": list(EXPECTED_FIELDS), "actor_id": actor}, {"type": "license_policy", "value": "open_public_sector_reuse", "actor_id": actor, "supported_by": [evidence_ids["legal-basis"]]}, {"type": "temporal_overlap", "value": "none_for_registered_parliamentary_sources", "actor_id": actor, "supported_by": [evidence_ids["temporal-novelty"]]}, {"type": "speaker_attribution", "value": "100_percent", "actor_id": actor, "supported_by": [evidence_ids["author-attribution"]]}, ], } def build_contribution( source_dir: pathlib.Path, registry_file: pathlib.Path, output_dir: pathlib.Path, *, source_revision: str, target_revision: str, added_date: str, actor: str, run_id: str, git_commit: str, tests_file: pathlib.Path | None = None, ) -> dict[str, Any]: if not COMMIT_PATTERN.fullmatch(source_revision): raise ContributionError("source revision must be an immutable 40-character Git commit") if not COMMIT_PATTERN.fullmatch(target_revision): raise ContributionError("target revision must be an immutable 40-character Git commit") if not registry_file.is_file(): raise ContributionError(f"target source registry missing: {registry_file}") registry = registry_file.read_text(encoding="utf-8") previous_sources = assert_temporal_novelty(registry, START_DATE) try: import pyarrow as pa import pyarrow.parquet as pq import tiktoken except ImportError as exc: raise ContributionError("building the contribution requires pyarrow and tiktoken") from exc schema = pa.schema([ ("id", pa.string()), ("text", pa.string()), ("source", pa.string()), ("added", pa.string()), ("created", pa.string()), ("token_count", pa.int64()), ("license", pa.string()), ("author", pa.string()), ]) encoder = tiktoken.get_encoding("cl100k_base") data_dir = output_dir / "data" / SOURCE_NAME artifact_dir = output_dir / "artifacts" src_dir = output_dir / "src" for directory in (data_dir, artifact_dir, src_dir): directory.mkdir(parents=True, exist_ok=True) parquet_path = data_dir / f"{SOURCE_NAME}.parquet" attribution_path = data_dir / f"{SOURCE_NAME}.attribution.jsonl" counter: collections.Counter[str] = collections.Counter({ "read": 0, "kept": 0, "drop_before_start": 0, "drop_dup": 0, "drop_short": 0, "drop_lang": 0, "drop_ocr": 0, "chars": 0, "tokens": 0, "authors_with_value": 0, }) years: collections.Counter[str] = collections.Counter() terms: collections.Counter[str] = collections.Counter() split_counts: collections.Counter[str] = collections.Counter() fingerprints: set[str] = set() created_dates: list[str] = [] batch_rows: list[dict[str, Any]] = [] def flush(writer: Any) -> None: if batch_rows: writer.write_table(pa.Table.from_pylist(batch_rows, schema=schema)) batch_rows.clear() with pq.ParquetWriter(parquet_path, schema, compression="zstd") as writer: with attribution_path.open("w", encoding="utf-8") as attribution_stream: for split in ("train", "validation"): input_path = source_dir / "data" / f"{split}.parquet" if not input_path.is_file(): raise ContributionError(f"pinned source split missing: {input_path}") parquet_file = pq.ParquetFile(input_path) if set(parquet_file.schema_arrow.names) != set(SOURCE_FIELDS): raise ContributionError(f"unexpected pinned source schema: {parquet_file.schema_arrow.names}") for batch in parquet_file.iter_batches(batch_size=256): for row in batch.to_pylist(): counter["read"] += 1 normalized = normalize_source_row( row, start_date=START_DATE, added_date=added_date, encoder=encoder ) if normalized is None: counter["drop_before_start"] += 1 continue document, attribution = normalized fingerprint = text_fingerprint(document["text"]) if fingerprint in fingerprints: counter["drop_dup"] += 1 continue fingerprints.add(fingerprint) attribution["source_revision"] = source_revision attribution["source_split"] = split attribution_stream.write( json.dumps(attribution, ensure_ascii=False, sort_keys=True) + "\n" ) batch_rows.append(document) counter["kept"] += 1 counter["chars"] += len(document["text"]) counter["tokens"] += document["token_count"] counter["authors_with_value"] += bool(document["author"]) years[document["created"][:4]] += 1 terms[attribution["term"]] += 1 split_counts[split] += 1 created_dates.append(document["created"]) if len(batch_rows) >= 512: flush(writer) flush(writer) if not counter["kept"]: raise ContributionError("no post-2022 Sejm speeches were available") if counter["authors_with_value"] != counter["kept"]: raise ContributionError("speaker attribution is not complete") produced = pq.ParquetFile(parquet_path) if tuple(produced.schema_arrow.names) != EXPECTED_FIELDS: raise ContributionError(f"generated Parquet violates DynaWord schema: {produced.schema_arrow.names}") if produced.metadata.num_rows != counter["kept"]: raise ContributionError("Parquet row count does not match generated evidence") stats: dict[str, Any] = { **counter, "license": SOURCE_LICENSE, "licenses": {SOURCE_LICENSE: counter["kept"]}, "added": added_date, "created_min": min(created_dates), "created_max": max(created_dates), "by_year": dict(sorted(years.items())), "by_term": dict(sorted(terms.items())), "by_source_split": dict(split_counts), "stats_recomputed_from_parquet": True, "source_revision": source_revision, "target_base_revision": target_revision, } write_json(data_dir / f"{SOURCE_NAME}.stats.json", stats) evidence_payload = legal_evidence( source_revision=source_revision, target_revision=target_revision ) legal_path = data_dir / f"{SOURCE_NAME}.license-evidence.json" write_json(legal_path, evidence_payload) manifest = ontology_manifest( stats=stats, source_revision=source_revision, target_revision=target_revision, prior_sources=previous_sources, parquet_digest=sha256_file(parquet_path), sidecar_digest=sha256_file(attribution_path), legal_digest=sha256_file(legal_path), actor=actor, run_id=run_id, git_commit=git_commit, ) contribution_digest = str(manifest["version"]["digest"]).removeprefix("sha256:") write_json(artifact_dir / "sejm_api_ontology_manifest.json", manifest) (data_dir / f"{SOURCE_NAME}.md").write_text( source_datasheet( stats=stats, source_revision=source_revision, target_revision=target_revision, prior_sources=previous_sources, contribution_digest=contribution_digest ), encoding="utf-8", ) (data_dir / "NOTICE.md").write_text( "# Source attribution\n\n" "Official materials: Kancelaria Sejmu RP, API Sejmu — https://api.sejm.gov.pl/.\n\n" "Speech attribution is preserved in `author`; the full source URL is in " "`sejm_api.attribution.jsonl`.\n\n" "Corpus preparation and contribution: Piotr Styła (Hugging Face: PiotrSty; " "GitHub: PiotrStyla).\n\n" "Reuse follows Polish Copyright Act art. 4(2) and the Polish Open Data Act. " "No upstream Creative Commons grant is asserted.\n", encoding="utf-8", ) (src_dir / "sources.py").write_text( insert_source_registry_entry(registry, end_date=stats["created_max"]), encoding="utf-8", ) shutil.copy2(pathlib.Path(__file__).resolve(), src_dir / "fetch_sejm_api.py") if tests_file is not None: if not tests_file.is_file(): raise ContributionError(f"contract test file missing: {tests_file}") shutil.copy2(tests_file, src_dir / "test_sejm_api_contract.py") return {"stats": stats, "manifest": manifest, "output": str(output_dir)} def build_parser() -> argparse.ArgumentParser: parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--source-dir", type=pathlib.Path, required=True) parser.add_argument("--target-registry", type=pathlib.Path, required=True) parser.add_argument("--output", type=pathlib.Path, required=True) parser.add_argument("--source-revision", required=True) parser.add_argument("--target-revision", required=True) parser.add_argument("--added-date", default=dt.datetime.now(dt.timezone.utc).date().isoformat()) parser.add_argument("--actor", default="local-user") parser.add_argument("--run-id", default="local-run") parser.add_argument("--git-commit", default="uncommitted") parser.add_argument("--tests-file", type=pathlib.Path) return parser def main(argv: Iterable[str] | None = None) -> int: args = build_parser().parse_args(list(argv) if argv is not None else None) try: result = build_contribution( args.source_dir, args.target_registry, args.output, source_revision=args.source_revision, target_revision=args.target_revision, added_date=args.added_date, actor=args.actor, run_id=args.run_id, git_commit=args.git_commit, tests_file=args.tests_file, ) except (ContributionError, OSError) as exc: print(f"error: {exc}", file=sys.stderr) return 1 print(json.dumps({ "stats": result["stats"], "version": result["manifest"]["version"], "claims": len(result["manifest"]["claims"]), "evidence": len(result["manifest"]["evidence"]), }, ensure_ascii=False, indent=2, sort_keys=True)) return 0 if __name__ == "__main__": raise SystemExit(main())