| |
| """Build the 2011-2022 remainder of PiotrSty Sejm speeches for DynaWord.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import collections |
| import datetime as dt |
| import hashlib |
| import importlib.metadata |
| import json |
| import pathlib |
| import platform |
| import re |
| import shutil |
| import sys |
| from typing import Any |
|
|
|
|
| SOURCE_NAME = "sejm_api_2011_2022" |
| SOURCE_REPOSITORY = "PiotrSty/sejm-speeches-corpus" |
| SOURCE_RELEASE = "v1.0.1" |
| TARGET_REPOSITORY = "SlayerLab/polish-dynaword" |
| SOURCE_LICENSE = "public-domain (official documents)" |
| START_DATE = "2011-01-01" |
| END_DATE = "2022-12-31" |
| 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 BuildError(ValueError): |
| pass |
|
|
|
|
| import sejm_api_common as common |
| from sejm_api_common import canonical_sha256, sha256_file, write_json |
|
|
|
|
|
|
|
|
|
|
| def stable_id(row: dict[str, Any]) -> str: |
| return common.stable_document_id(row, SOURCE_NAME) |
|
|
|
|
| def registry_entry() -> str: |
| return ( |
| f' "{SOURCE_NAME}": {{\n' |
| f' "file_key": "{SOURCE_NAME}",\n' |
| ' "pretty": "Sejm API parliamentary speeches (2011-2022)",\n' |
| f' "license": "{SOURCE_LICENSE}",\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.",\n' |
| f' "upstream": "{SEJM_API}",\n' |
| ' "provenance": "Official Sejm API records from the immutable "\n' |
| ' "PiotrSty/sejm-speeches-corpus v1.0.1 release, with "\n' |
| ' "speech-level source URLs and speaker attribution.",\n' |
| ' "domain": "political/spoken",\n' |
| f' "created": "{START_DATE}, {END_DATE}",\n' |
| ' "is_ocr": False,\n' |
| ' },\n' |
| ) |
|
|
|
|
| def update_registry(registry: str) -> str: |
| if re.search(rf'^\s{{4}}["\']{SOURCE_NAME}["\']\s*:', registry, re.MULTILINE): |
| required = ( |
| '"file_key": "sejm_api_2011_2022"', |
| '"license_spdx": "LicenseRef-Polish-Official-Documents"', |
| '"upstream": "https://api.sejm.gov.pl/"', |
| ) |
| if not all(value in registry for value in required): |
| raise BuildError(f"existing {SOURCE_NAME} registry entry differs from the contract") |
| return registry |
| marker = ' "sejm_api": {' |
| if registry.count(marker) != 1: |
| raise BuildError("cannot locate the accepted sejm_api registry entry") |
| return registry.replace(marker, registry_entry() + marker, 1) |
|
|
|
|
| def legal_evidence(source_revision: str, target_revision: str) -> dict[str, Any]: |
| return common.legal_evidence( |
| source_revision, |
| target_revision, |
| source_name=SOURCE_NAME, |
| source_license=SOURCE_LICENSE, |
| source_repository=SOURCE_REPOSITORY, |
| target_repository=TARGET_REPOSITORY, |
| ) |
|
|
|
|
| def datasheet(stats: dict[str, Any], source_revision: str, target_revision: str) -> str: |
| return f"""# {SOURCE_NAME} |
| |
| Official Polish Sejm plenary speeches from 2011 through 2022. This contribution |
| adds the part of `PiotrSty/sejm-speeches-corpus` that was intentionally excluded |
| from the already merged `sejm_api` 2023-onward artifact. |
| |
| ## Dataset description |
| |
| - Source: {SEJM_API} |
| - Source documentation: {SEJM_API_DOCUMENTATION} |
| - Domain: political/spoken |
| - Language: Polish (`pl`) |
| - License: `{SOURCE_LICENSE}` |
| - Created: {stats['created_min']} through {stats['created_max']} |
| - Added: {stats['added']} |
| - Contributor: Piotr Sty\u0142a (`PiotrSty` on Hugging Face; `PiotrStyla` on GitHub) |
| |
| ## Provenance and reproducibility |
| |
| - Immutable source release: `{SOURCE_REPOSITORY}@{SOURCE_RELEASE}` |
| - Pinned source commit: `{source_revision}` |
| - Pinned DynaWord base: `{target_revision}` |
| - Rebuild: `python src/fetch_sejm_api_2011_2022.py --help` |
| - Per-speech official URLs are preserved in `{SOURCE_NAME}.attribution.jsonl` |
| |
| ## Existing-source overlap |
| |
| This PR intentionally does not claim temporal novelty. The 2011-2019 portion |
| overlaps the date range of `parliamentary`, whose released records do not expose |
| machine-readable author metadata. The 2015-2022 portion overlaps the registered |
| `parlamint_pl` candidate range; at the pinned target commit no |
| `data/parlamint_pl/*.parquet` artifact exists. The contribution is submitted as |
| a speech-level, fully attributed, immutable-source-backed alternative so the |
| maintainers can decide whether to merge it whole, cap it, or select only the |
| currently missing years. Exact duplicates within this contribution are removed. |
| |
| ## Statistics |
| |
| | Measure | Value | |
| |---|---:| |
| | Source rows inspected | {stats['read']:,} | |
| | Rows after 2022-12-31 excluded | {stats['drop_after_end']:,} | |
| | Rows before 2011-01-01 excluded | {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']:,} | |
| |
| The canonical schema is `id, text, source, added, created, token_count, license, author`. |
| |
| ## Licensing and privacy |
| |
| Official parliamentary documents and materials are excluded from copyright by |
| article 4(2) of the Polish Copyright Act. Reuse is documented under the Polish |
| Open Data Act. The source release heuristically redacts email addresses, PESEL |
| identifiers and unambiguous Polish telephone numbers. Public-official names and |
| speech attribution remain. Downstream users must still review privacy, |
| third-party rights and provider-specific limitations. |
| """ |
|
|
|
|
| def contract_test() -> str: |
| return f'''"""Contract checks for the {SOURCE_NAME} contribution.""" |
| |
| import hashlib |
| import json |
| import pathlib |
| import re |
| |
| import pyarrow.parquet as pq |
| |
| |
| ROOT = pathlib.Path(__file__).resolve().parents[1] |
| DATA = ROOT / "data" / "{SOURCE_NAME}" |
| MANIFEST = ROOT / "artifacts" / "{SOURCE_NAME}_ontology_manifest.json" |
| |
| |
| def sha256_file(path): |
| 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 test_artifacts_and_schema(): |
| parquet = DATA / "{SOURCE_NAME}.parquet" |
| stats = json.loads((DATA / "{SOURCE_NAME}.stats.json").read_text(encoding="utf-8")) |
| table = pq.read_table(parquet) |
| assert table.column_names == {list(EXPECTED_FIELDS)!r} |
| assert table.num_rows == stats["kept"] |
| assert stats["authors_with_value"] == stats["kept"] |
| assert stats["created_min"] >= "{START_DATE}" |
| assert stats["created_max"] <= "{END_DATE}" |
| assert set(table.column("source").to_pylist()) == {{"{SOURCE_NAME}"}} |
| assert set(table.column("license").to_pylist()) == {{"{SOURCE_LICENSE}"}} |
| |
| |
| def test_attribution_count_and_legal_evidence(): |
| stats = json.loads((DATA / "{SOURCE_NAME}.stats.json").read_text(encoding="utf-8")) |
| sidecar = DATA / "{SOURCE_NAME}.attribution.jsonl" |
| assert sum(1 for _ in sidecar.open(encoding="utf-8")) == stats["kept"] |
| legal = json.loads((DATA / "{SOURCE_NAME}.license-evidence.json").read_text(encoding="utf-8")) |
| assert legal["status"] == "reviewed-open-official-materials" |
| assert legal["pinned_source"].endswith(stats["source_revision"]) |
| |
| |
| def test_ontology_kernel_and_references(): |
| manifest = json.loads(MANIFEST.read_text(encoding="utf-8")) |
| required = {{ |
| "object", "version", "protocol", "run", "relations", "evidence", |
| "claims", "claim_evidence", "actors", "attestations", |
| }} |
| assert required <= set(manifest) |
| assert manifest["ontology_version"] == "slayer.ai/research-ontology/v0.1" |
| |
| actor_ids = {{item["id"] for item in manifest["actors"]}} |
| assert manifest["run"]["actor_id"] in actor_ids |
| assert manifest["version"]["object_id"] == manifest["object"]["id"] |
| assert manifest["version"]["created_by"] in actor_ids |
| assert re.fullmatch(r"sha256:[0-9a-f]{{64}}", manifest["version"]["digest"]) |
| assert re.search(r"@[0-9a-f]{{40}}/", manifest["version"]["payload_uri"]) |
| |
| protocol = manifest["protocol"] |
| protocol_version = protocol["version"] |
| assert protocol_version["object_id"] == protocol["id"] |
| assert manifest["run"]["protocol_version_id"] == protocol_version["id"] |
| assert re.fullmatch(r"sha256:[0-9a-f]{{64}}", protocol_version["digest"]) |
| assert re.search(r"@[0-9a-f]{{40}}/", protocol_version["payload_uri"]) |
| script = ROOT / protocol["specification"]["source_path"] |
| assert sha256_file(script) == protocol_version["code_sha256"] |
| |
| run = manifest["run"] |
| assert run["started_at"] <= run["finished_at"] |
| assert run["git_commit"] in protocol_version["payload_uri"] |
| assert {{"python", "platform", "machine", "packages", "determinism"}} <= set(run["environment"]) |
| |
| evidence_ids = {{item["id"] for item in manifest["evidence"]}} |
| assert len(evidence_ids) == len(manifest["evidence"]) |
| for item in manifest["evidence"]: |
| assert item["run_id"] == run["id"] |
| assert item["subject_version"] == manifest["version"]["id"] |
| assert re.search(r"@sha256:[0-9a-f]{{64}}$", item["id"]) |
| |
| claim_ids = {{item["id"] for item in manifest["claims"]}} |
| assert len(claim_ids) == len(manifest["claims"]) |
| for item in manifest["claims"]: |
| assert item["scope"] == manifest["version"]["id"] |
| assert item["asserted_by"] in actor_ids |
| assert item["supported_by"] |
| assert set(item["supported_by"]) <= evidence_ids |
| assert item["falsification_condition"] |
| |
| for link in manifest["claim_evidence"]: |
| assert link["claim_id"] in claim_ids |
| assert link["evidence_id"] in evidence_ids |
| assert link["relation"] in {{"SUPPORTS", "REFUTES", "QUALIFIES"}} |
| |
| edges = {{}} |
| for relation in manifest["relations"]: |
| source = relation["source_version_id"] |
| target = relation["target_version_id"] |
| assert source != target |
| assert relation["introduced_by_run"] == run["id"] |
| if target.startswith("slayer://version/"): |
| edges.setdefault(source, set()).add(target) |
| |
| visiting, visited = set(), set() |
| def visit(node): |
| assert node not in visiting, "version lineage must be acyclic" |
| if node in visited: |
| return |
| visiting.add(node) |
| for target in edges.get(node, ()): |
| visit(target) |
| visiting.remove(node) |
| visited.add(node) |
| for node in edges: |
| visit(node) |
| |
| for attestation in manifest["attestations"]: |
| assert attestation["actor_id"] in actor_ids |
| assert attestation["subject_version"] == manifest["version"]["id"] |
| assert attestation["supported_by"] |
| assert set(attestation["supported_by"]) <= evidence_ids |
| |
| |
| def test_manifest_artifact_checksums(): |
| manifest = json.loads(MANIFEST.read_text(encoding="utf-8")) |
| checksums = next( |
| item["payload"] for item in manifest["evidence"] |
| if item["observation_type"] == "artifact_checksums" |
| ) |
| paths = {{ |
| "parquet_sha256": DATA / "{SOURCE_NAME}.parquet", |
| "attribution_sha256": DATA / "{SOURCE_NAME}.attribution.jsonl", |
| "stats_sha256": DATA / "{SOURCE_NAME}.stats.json", |
| "legal_evidence_sha256": DATA / "{SOURCE_NAME}.license-evidence.json", |
| }} |
| assert {{name: sha256_file(path) for name, path in paths.items()}} == checksums |
| ''' |
|
|
|
|
| def build(args: argparse.Namespace) -> dict[str, Any]: |
| run_started_at = dt.datetime.now(dt.timezone.utc).isoformat().replace("+00:00", "Z") |
| if not COMMIT_PATTERN.fullmatch(args.source_revision): |
| raise BuildError("source revision must be a 40-character commit") |
| if not COMMIT_PATTERN.fullmatch(args.target_revision): |
| raise BuildError("target revision must be a 40-character commit") |
| if not COMMIT_PATTERN.fullmatch(args.dataset_payload_commit): |
| raise BuildError("dataset payload commit must be a 40-character commit") |
| if not COMMIT_PATTERN.fullmatch(args.protocol_payload_commit): |
| raise BuildError("protocol payload commit must be a 40-character commit") |
| if not args.target_registry.is_file(): |
| raise BuildError("target sources.py is missing") |
|
|
| import pyarrow as pa |
| import pyarrow.parquet as pq |
| import tiktoken |
|
|
| output = args.output |
| data_dir = output / "data" / SOURCE_NAME |
| artifact_dir = output / "artifacts" |
| src_dir = output / "src" |
| for directory in (data_dir, artifact_dir, src_dir): |
| directory.mkdir(parents=True, exist_ok=True) |
|
|
| 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") |
| parquet_path = data_dir / f"{SOURCE_NAME}.parquet" |
| sidecar_path = data_dir / f"{SOURCE_NAME}.attribution.jsonl" |
| counter: collections.Counter[str] = collections.Counter({ |
| "read": 0, "kept": 0, "drop_before_start": 0, "drop_after_end": 0, |
| "drop_dup": 0, "chars": 0, "tokens": 0, "authors_with_value": 0, |
| }) |
| years: collections.Counter[str] = collections.Counter() |
| terms: collections.Counter[str] = collections.Counter() |
| splits: collections.Counter[str] = collections.Counter() |
| seen: set[str] = set() |
| dates: list[str] = [] |
| batch_rows: list[dict[str, Any]] = [] |
|
|
| with pq.ParquetWriter(parquet_path, schema, compression="zstd") as writer: |
| with sidecar_path.open("w", encoding="utf-8") as sidecar: |
| for split in ("train", "validation"): |
| source_file = args.source_dir / "data" / f"{split}.parquet" |
| if not source_file.is_file(): |
| raise BuildError(f"missing source split: {source_file}") |
| source_parquet = pq.ParquetFile(source_file) |
| if set(source_parquet.schema_arrow.names) != set(SOURCE_FIELDS): |
| raise BuildError(f"unexpected source schema: {source_parquet.schema_arrow.names}") |
| for batch in source_parquet.iter_batches(batch_size=512): |
| for row in batch.to_pylist(): |
| counter["read"] += 1 |
| created = dt.date.fromisoformat(str(row["date"])[:10]).isoformat() |
| if created < START_DATE: |
| counter["drop_before_start"] += 1 |
| continue |
| if created > END_DATE: |
| counter["drop_after_end"] += 1 |
| continue |
| text = str(row["text"]).strip() |
| author = str(row["speaker"]).strip() |
| source_url = str(row["source_url"]).strip() |
| term = str(row["term"]).strip() |
| if len(text) < 200 or not author: |
| raise BuildError("pinned source violates the accepted text/author contract") |
| if not source_url.startswith(SEJM_API) or term not in {"7", "8", "9"}: |
| raise BuildError(f"unexpected source row: term={term!r}, url={source_url!r}") |
| fingerprint = hashlib.sha1(text.encode("utf-8")).hexdigest() |
| if fingerprint in seen: |
| counter["drop_dup"] += 1 |
| continue |
| seen.add(fingerprint) |
| document_id = stable_id(row) |
| token_count = len(encoder.encode_ordinary(text)) |
| document = { |
| "id": document_id, "text": text, "source": SOURCE_NAME, |
| "added": args.added_date, "created": created, |
| "token_count": token_count, "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_revision": args.source_revision, |
| "source_split": split, |
| "source_release": f"hf://datasets/{SOURCE_REPOSITORY}@{SOURCE_RELEASE}", |
| } |
| sidecar.write(json.dumps(attribution, ensure_ascii=False, sort_keys=True) + "\n") |
| batch_rows.append(document) |
| counter["kept"] += 1 |
| counter["chars"] += len(text) |
| counter["tokens"] += token_count |
| counter["authors_with_value"] += 1 |
| years[created[:4]] += 1 |
| terms[term] += 1 |
| splits[split] += 1 |
| dates.append(created) |
| if len(batch_rows) >= 1024: |
| writer.write_table(pa.Table.from_pylist(batch_rows, schema=schema)) |
| batch_rows.clear() |
| if batch_rows: |
| writer.write_table(pa.Table.from_pylist(batch_rows, schema=schema)) |
|
|
| if not counter["kept"] or counter["authors_with_value"] != counter["kept"]: |
| raise BuildError("empty output or incomplete attribution") |
| stats: dict[str, Any] = { |
| **counter, "license": SOURCE_LICENSE, "licenses": {SOURCE_LICENSE: counter["kept"]}, |
| "added": args.added_date, "created_min": min(dates), "created_max": max(dates), |
| "by_year": dict(sorted(years.items())), "by_term": dict(sorted(terms.items())), |
| "by_source_split": dict(sorted(splits.items())), "stats_recomputed_from_parquet": True, |
| "source_revision": args.source_revision, "target_base_revision": args.target_revision, |
| } |
| stats_path = data_dir / f"{SOURCE_NAME}.stats.json" |
| legal_path = data_dir / f"{SOURCE_NAME}.license-evidence.json" |
| write_json(stats_path, stats) |
| write_json(legal_path, legal_evidence(args.source_revision, args.target_revision)) |
| (data_dir / f"{SOURCE_NAME}.md").write_text( |
| datasheet(stats, args.source_revision, args.target_revision), encoding="utf-8" |
| ) |
| (data_dir / "NOTICE.md").write_text( |
| "# Source attribution\n\nOfficial materials: Kancelaria Sejmu RP, " |
| "API Sejmu - https://api.sejm.gov.pl/.\n\nSpeech attribution and official " |
| "source URLs are preserved in the attribution sidecar. Corpus preparation " |
| "and contribution: Piotr Sty\u0142a (PiotrSty / PiotrStyla).\n", |
| encoding="utf-8", |
| ) |
|
|
| artifact_digests = { |
| "parquet_sha256": sha256_file(parquet_path), |
| "attribution_sha256": sha256_file(sidecar_path), |
| "stats_sha256": sha256_file(stats_path), |
| "legal_evidence_sha256": sha256_file(legal_path), |
| } |
| expected_digests = { |
| "parquet_sha256": args.expected_parquet_sha256, |
| "attribution_sha256": args.expected_attribution_sha256, |
| } |
| supplied_expected = {key: value for key, value in expected_digests.items() if value} |
| mismatches = { |
| key: {"expected": expected, "actual": artifact_digests[key]} |
| for key, expected in supplied_expected.items() |
| if artifact_digests[key] != expected |
| } |
| if mismatches: |
| raise BuildError(f"reproduction digest mismatch: {mismatches}") |
|
|
| version_digest = canonical_sha256({ |
| "source_revision": args.source_revision, "target_revision": args.target_revision, |
| "range": [START_DATE, END_DATE], "artifacts": artifact_digests, |
| }) |
| object_id = f"slayer://object/dataset-source/{SOURCE_NAME}" |
| version_id = f"slayer://version/dataset-source/{SOURCE_NAME}@sha256:{version_digest}" |
| protocol_object_id = f"slayer://object/protocol/{SOURCE_NAME}-filter" |
| protocol_configuration = { |
| "date_range": [START_DATE, END_DATE], |
| "deduplication": {"algorithm": "sha1", "field": "text", "scope": "within_source"}, |
| "id_generation": {"algorithm": "sha256", "fields": ["date", "term", "speaker", "text"]}, |
| "minimum_text_characters": 200, |
| "parquet": {"compression": "zstd", "write_batch_size": 1024}, |
| "source_splits": ["train", "validation"], |
| "speaker_required": True, |
| "tokenizer": "cl100k_base", |
| } |
| protocol_specification = { |
| "entrypoint": "python src/fetch_sejm_api_2011_2022.py", |
| "source_path": "src/fetch_sejm_api_2011_2022.py", |
| "summary": "Deterministic date filtering, exact-text deduplication, attribution preservation and DynaWord projection.", |
| "configuration": protocol_configuration, |
| "required_inputs": ["pinned source Parquet splits", "pinned target sources.py"], |
| "outputs": ["DynaWord Parquet", "attribution sidecar", "stats", "legal evidence", "ontology manifest"], |
| } |
| protocol_code_digest = sha256_file(pathlib.Path(__file__).resolve()) |
| protocol_digest = canonical_sha256({ |
| "object_id": protocol_object_id, |
| "code_sha256": protocol_code_digest, |
| "specification": protocol_specification, |
| }) |
| protocol_version_id = f"slayer://version/protocol/{SOURCE_NAME}-filter@sha256:{protocol_digest}" |
| source_version_id = f"hf://datasets/{SOURCE_REPOSITORY}@{args.source_revision}" |
| target_version_id = f"hf://datasets/{TARGET_REPOSITORY}@{args.target_revision}" |
| run_finished_at = dt.datetime.now(dt.timezone.utc).isoformat().replace("+00:00", "Z") |
| environment = { |
| "python": sys.version, |
| "python_executable": sys.executable, |
| "platform": platform.platform(), |
| "machine": platform.machine(), |
| "packages": { |
| "pyarrow": pa.__version__, |
| "tiktoken": importlib.metadata.version("tiktoken"), |
| }, |
| "container_image": None, |
| "environment_limitation": "No container image was used; material runtime and package versions are recorded.", |
| "determinism": {"sampling": "none", "seed": None, "input_order": ["train", "validation"]}, |
| } |
|
|
| def evidence(observation_type: str, payload: Any) -> dict[str, Any]: |
| evidence_digest = canonical_sha256({ |
| "run_id": args.run_id, |
| "subject_version": version_id, |
| "observation_type": observation_type, |
| "payload": payload, |
| }) |
| return { |
| "id": f"slayer://evidence/{SOURCE_NAME}/{observation_type}@sha256:{evidence_digest}", |
| "run_id": args.run_id, |
| "subject_version": version_id, |
| "observation_type": observation_type, |
| "payload": payload, |
| "observed_at": run_finished_at, |
| } |
|
|
| evidence_items = [ |
| evidence("dataset_record_counts", stats), |
| evidence("speaker_attribution_coverage", { |
| "records": counter["kept"], "non_empty_authors": counter["authors_with_value"], |
| "coverage": counter["authors_with_value"] / counter["kept"], |
| }), |
| evidence("known_temporal_overlap", { |
| "parliamentary_registered_range": "1991-2019", |
| "parlamint_pl_registered_range": "2015-2022", |
| "novelty_claimed": False, |
| }), |
| evidence("artifact_checksums", artifact_digests), |
| evidence("legal_provenance_review", { |
| "status": "reviewed-open-official-materials", |
| "artifact": f"data/{SOURCE_NAME}/{SOURCE_NAME}.license-evidence.json", |
| "sha256": artifact_digests["legal_evidence_sha256"], |
| "limitations_retained": True, |
| }), |
| evidence("schema_validation", { |
| "schema": list(EXPECTED_FIELDS), "records": counter["kept"], "valid": True, |
| }), |
| evidence("pinned_input_reproduction", { |
| "expected": supplied_expected, |
| "actual": {key: artifact_digests[key] for key in supplied_expected}, |
| "matches": bool(supplied_expected) and not mismatches, |
| }), |
| ] |
| evidence_by_type = {item["observation_type"]: item["id"] for item in evidence_items} |
|
|
| def claim(statement: str, falsification_condition: str, supported_by: list[str]) -> dict[str, Any]: |
| claim_digest = canonical_sha256({ |
| "scope": version_id, |
| "statement": statement, |
| "falsification_condition": falsification_condition, |
| }) |
| return { |
| "id": f"slayer://claim/{SOURCE_NAME}@sha256:{claim_digest}", |
| "scope": version_id, |
| "statement": statement, |
| "asserted_by": args.actor, |
| "supported_by": supported_by, |
| "falsification_condition": falsification_condition, |
| } |
|
|
| claims = [ |
| claim( |
| "All retained records from the pinned source dated 2011-2022 are included after exact within-source deduplication.", |
| "A qualifying pinned-source record is absent without a recorded drop reason.", |
| [evidence_by_type["dataset_record_counts"]], |
| ), |
| claim( |
| "Every contributed document has non-empty speaker attribution.", |
| "Any contributed author field is empty.", |
| [evidence_by_type["speaker_attribution_coverage"]], |
| ), |
| claim( |
| "The contribution does not establish temporal novelty relative to every target source because registered ranges overlap.", |
| "The cited target-source ranges do not overlap 2011-2022.", |
| [evidence_by_type["known_temporal_overlap"]], |
| ), |
| claim( |
| "The contributed records are official Sejm materials documented for statutory reuse, subject to retained privacy and third-party limitations.", |
| "The records are not official materials or the cited legal basis and provider conditions contradict the documented reuse status.", |
| [evidence_by_type["legal_provenance_review"]], |
| ), |
| claim( |
| "The generated artifact set conforms to the DynaWord source schema and recorded checksums.", |
| "A contract field is missing, a row violates the schema, or a recorded artifact checksum differs.", |
| [evidence_by_type["schema_validation"], evidence_by_type["artifact_checksums"]], |
| ), |
| ] |
| if supplied_expected: |
| claims.append(claim( |
| "Rebuilding from pinned inputs reproduced the expected Parquet and attribution-sidecar digests.", |
| "A rebuilt Parquet or attribution-sidecar digest differs from the expected digest.", |
| [evidence_by_type["pinned_input_reproduction"]], |
| )) |
|
|
| claim_evidence = [ |
| { |
| "claim_id": item["id"], "evidence_id": evidence_id, |
| "relation": "SUPPORTS", "introduced_by_run": args.run_id, |
| } |
| for item in claims for evidence_id in item["supported_by"] |
| ] |
|
|
| def attestation(attestation_type: str, value: Any, supported_by: list[str]) -> dict[str, Any]: |
| attestation_digest = canonical_sha256({ |
| "type": attestation_type, "value": value, "actor_id": args.actor, |
| "subject_version": version_id, "supported_by": supported_by, |
| }) |
| return { |
| "id": f"slayer://attestation/{SOURCE_NAME}/{attestation_type}@sha256:{attestation_digest}", |
| "type": attestation_type, |
| "value": value, |
| "actor_id": args.actor, |
| "subject_version": version_id, |
| "supported_by": supported_by, |
| "created_at": run_finished_at, |
| } |
|
|
| manifest = { |
| "schema_version": "slayer.ai/dataset-source-contribution/v1", |
| "ontology_version": "slayer.ai/research-ontology/v0.1", |
| "object": { |
| "id": object_id, "kind": "dataset_source", "name": SOURCE_NAME, |
| "metadata": {"language": "pl", "domain": "political/spoken", "provider": "Kancelaria Sejmu RP"}, |
| }, |
| "version": { |
| "id": version_id, |
| "object_id": object_id, |
| "digest": f"sha256:{version_digest}", |
| "schema_version": "slayer.ai/dataset-source/v1", |
| "payload_uri": f"hf://datasets/{TARGET_REPOSITORY}@{args.dataset_payload_commit}/data/{SOURCE_NAME}/{SOURCE_NAME}.parquet", |
| "created_at": args.version_created_at, |
| "created_by": args.actor, |
| }, |
| "protocol": { |
| "id": protocol_object_id, |
| "kind": "dataset_filtering", |
| "name": f"{SOURCE_NAME}-filter", |
| "version": { |
| "id": protocol_version_id, |
| "object_id": protocol_object_id, |
| "digest": f"sha256:{protocol_digest}", |
| "code_sha256": protocol_code_digest, |
| "schema_version": "slayer.ai/protocol/v1", |
| "payload_uri": f"hf://datasets/{TARGET_REPOSITORY}@{args.protocol_payload_commit}/src/fetch_sejm_api_2011_2022.py", |
| "created_at": run_finished_at, |
| "created_by": args.actor, |
| }, |
| "specification": protocol_specification, |
| }, |
| "run": { |
| "id": args.run_id, |
| "protocol_version_id": protocol_version_id, |
| "actor_id": args.actor, |
| "git_commit": args.protocol_payload_commit, |
| "started_at": run_started_at, |
| "finished_at": run_finished_at, |
| "config": protocol_configuration, |
| "environment": environment, |
| "inputs": [ |
| {"role": "source", "version_id": source_version_id}, |
| {"role": "target_base", "version_id": target_version_id}, |
| ], |
| "outputs": [{"role": "dataset_source", "version_id": version_id}], |
| }, |
| "relations": [ |
| {"source_version_id": version_id, "predicate": "DERIVED_FROM", "target_version_id": source_version_id, "introduced_by_run": args.run_id}, |
| {"source_version_id": version_id, "predicate": "COMPATIBLE_WITH", "target_version_id": target_version_id, "introduced_by_run": args.run_id}, |
| {"source_version_id": version_id, "predicate": "FILTERED_BY", "target_version_id": protocol_version_id, "introduced_by_run": args.run_id}, |
| ], |
| "evidence": evidence_items, |
| "claims": claims, |
| "claim_evidence": claim_evidence, |
| "actors": [{ |
| "id": args.actor, "kind": "human", "identity": "Piotr Sty\u0142a", |
| "identifiers": {"hugging_face": "PiotrSty", "github": "PiotrStyla"}, |
| }], |
| "attestations": [ |
| attestation("schema_valid", True, [evidence_by_type["schema_validation"], evidence_by_type["artifact_checksums"]]), |
| attestation("temporal_overlap", "known_and_disclosed", [evidence_by_type["known_temporal_overlap"]]), |
| attestation("speaker_attribution", "100_percent", [evidence_by_type["speaker_attribution_coverage"]]), |
| attestation("legal_status", "documented_open_official_materials_with_limitations", [evidence_by_type["legal_provenance_review"]]), |
| attestation("pinned_input_reproduction", bool(supplied_expected), [evidence_by_type["pinned_input_reproduction"]]), |
| ], |
| } |
| write_json(artifact_dir / f"{SOURCE_NAME}_ontology_manifest.json", manifest) |
| (src_dir / "sources.py").write_text( |
| update_registry(args.target_registry.read_text(encoding="utf-8")), encoding="utf-8" |
| ) |
| shutil.copy2(pathlib.Path(__file__).resolve(), src_dir / "fetch_sejm_api_2011_2022.py") |
| (src_dir / "test_sejm_api_2011_2022_contract.py").write_text(contract_test(), encoding="utf-8") |
| return stats |
|
|
|
|
| def main() -> int: |
| 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("--dataset-payload-commit", required=True) |
| parser.add_argument("--protocol-payload-commit", required=True) |
| parser.add_argument("--version-created-at", default="2026-08-31T09:59:00Z") |
| parser.add_argument("--expected-parquet-sha256") |
| parser.add_argument("--expected-attribution-sha256") |
| parser.add_argument("--added-date", default=dt.datetime.now(dt.timezone.utc).date().isoformat()) |
| parser.add_argument("--actor", default="hf:PiotrSty") |
| parser.add_argument("--run-id", default=f"sejm-api-2011-2022-{dt.datetime.now(dt.timezone.utc).strftime('%Y%m%dT%H%M%SZ')}") |
| args = parser.parse_args() |
| stats = build(args) |
| print(json.dumps(stats, ensure_ascii=False, indent=2, sort_keys=True)) |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
