src/fetch_sejm_api.py

#!/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

sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent))

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."""


import sejm_api_common as common
from sejm_api_common import canonical_sha256, sha256_file, write_json


def stable_document_id(row: dict[str, Any]) -> str:
    return common.stable_document_id(row, SOURCE_NAME)


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_entry(registry: str, source_name: str) -> re.Match[str] | None:
    pattern = re.compile(
        rf'^\s{{4}}["\']{re.escape(source_name)}["\']\s*:\s*\{{'
        rf'(?P<body>.*?)^\s{{4}}\}},?',
        flags=re.MULTILINE | re.DOTALL,
    )
    return pattern.search(registry)


# `parlamint_pl` (2015-2022) left the registry in Hub PR 54 without ever shipping data, and sejm_api_2011_2022
# ends on 2022-12-31 by its own END_DATE, so only `parliamentary` is checked. Its registry `created` range runs
# to 2025 because it holds the Senate; this source is Sejm-only, so the check uses the end of its Sejm material.
PRIOR_SEJM_END_DATES = {"parliamentary": common.PARLIAMENTARY_SEJM_END}


def assert_temporal_novelty(start_date: str) -> dict[str, str]:
    threshold = dt.date.fromisoformat(start_date)
    overlapping = {
        name: value for name, value in PRIOR_SEJM_END_DATES.items()
        if dt.date.fromisoformat(value) >= threshold
    }
    if overlapping:
        raise ContributionError(f"candidate date range overlaps registered sources: {overlapping}")
    return dict(PRIOR_SEJM_END_DATES)


def insert_source_registry_entry(registry: str, *, end_date: str) -> str:
    """Add the sejm_api entry after `parliamentary`; on a rerun, check the existing entry and keep it."""
    existing = registry_entry(registry, SOURCE_NAME)
    if existing:
        required = (
            f'"file_key": "{SOURCE_NAME}"',
            f'"license": "{SOURCE_LICENSE}"',
            '"license_spdx": "LicenseRef-Polish-Official-Documents"',
            f'"upstream": "{SEJM_API}"',
            f'"created": "{START_DATE}, {end_date}"',
        )
        differing = [value for value in required if value not in existing.group("body")]
        if differing:
            raise ContributionError(f"existing sejm_api registry entry differs from the contract: {differing}")
        return registry
    anchor = registry_entry(registry, "parliamentary")
    if not anchor:
        raise ContributionError("cannot safely locate the existing parliamentary 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": "Sejm API data via contributor snapshot: text from the "\n'
        '                      "PiotrSty/sejm-speeches-corpus v1.0.1 Hugging Face snapshot "\n'
        '                      "(commit 1245577), not fetched from the live API by SlayerLab. "\n'
        '                      "Speaker attribution preserved; source_url is a day-level "\n'
        '                      "api.sejm.gov.pl /videos/ listing, not a per-speech URL.",\n'
        '        "domain": "political/spoken",\n'
        f'        "created": "{START_DATE}, {end_date}",\n'
        '        "is_ocr": False,\n'
        '    },\n'
    )
    insert_at = registry.index("\n", anchor.end()) + 1
    updated = registry[:insert_at] + entry + registry[insert_at:]
    ast.parse(updated)
    return updated


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 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 the Sejm material of every checked registered parliamentary source.",
         "falsification_condition": "Any contributed created date is <= a 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(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,
    )
    write_json(artifact_dir / "sejm_api_ontology_manifest.json", manifest)
    # The card (sejm_api.md) and NOTICE.md are kept by hand in the repository since the
    # v0.2.6 rights audit (v2#107); this build does not write them, so a rerun cannot
    # bring back an older text.
    (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())