from __future__ import annotations import ast import json import pathlib import sys import tempfile import unittest for candidate in ( pathlib.Path(__file__).resolve().parent, pathlib.Path(__file__).resolve().parents[1] / "scripts", ): if str(candidate) not in sys.path: sys.path.insert(0, str(candidate)) try: from fetch_sejm_api import ( ContributionError, EXPECTED_FIELDS, SOURCE_FIELDS, SOURCE_LICENSE, START_DATE, assert_temporal_novelty, build_contribution, insert_source_registry_entry, legal_evidence, normalize_source_row, stable_document_id, text_fingerprint, ) except ImportError: from build_dynaword_sejm_api import ( ContributionError, EXPECTED_FIELDS, SOURCE_FIELDS, SOURCE_LICENSE, START_DATE, assert_temporal_novelty, build_contribution, insert_source_registry_entry, legal_evidence, normalize_source_row, stable_document_id, text_fingerprint, ) REGISTRY = '''SOURCES = { "parliamentary": { "created": "1991-01-01, 2019-12-31", "license": "public-domain (official documents)", }, "parlamint_pl": { "created": "2015-01-01, 2022-12-31", "license": "CC-BY-4.0", }, } ''' class FakeEncoder: def encode_ordinary(self, text: str) -> list[str]: return text.split() def sample_row(index: int, *, date: str = "2024-05-10") -> dict[str, object]: text = ( f"Panie Marszałku, Wysoka Izbo, wypowiedź numer {index}. " + " ".join(f"słowo{number}" for number in range(65)) ) return { "text": text, "speaker": f"Poseł {index}", "date": date, "term": "10" if date >= "2023-11-13" else "9", "source_url": f"https://api.sejm.gov.pl/sejm/term10/videos/{date}", "char_count": len(text), "word_count": len(text.split()), "has_events": index % 2 == 0, } class DynawordContractTests(unittest.TestCase): def test_exact_dynaword_schema_and_speaker_attribution(self) -> None: result = normalize_source_row( sample_row(1), start_date=START_DATE, added_date="2026-08-22", encoder=FakeEncoder() ) self.assertIsNotNone(result) document, attribution = result self.assertEqual(tuple(document), EXPECTED_FIELDS) self.assertEqual(document["source"], "sejm_api") self.assertEqual(document["author"], "Poseł 1") self.assertEqual(document["license"], SOURCE_LICENSE) self.assertEqual(attribution["id"], document["id"]) self.assertTrue(attribution["source_url"].startswith("https://api.sejm.gov.pl/")) def test_pre_2023_records_are_excluded(self) -> None: self.assertIsNone(normalize_source_row( sample_row(2, date="2022-12-31"), start_date=START_DATE, added_date="2026-08-22", encoder=FakeEncoder() )) def test_first_day_after_parlamint_is_included(self) -> None: self.assertIsNotNone(normalize_source_row( sample_row(2, date="2023-01-01"), start_date=START_DATE, added_date="2026-08-22", encoder=FakeEncoder() )) def test_document_identity_is_stable_and_source_specific(self) -> None: row = sample_row(1) self.assertEqual(stable_document_id(row), stable_document_id(dict(row))) changed = dict(row, speaker="Inny poseł") self.assertNotEqual(stable_document_id(row), stable_document_id(changed)) self.assertTrue(stable_document_id(row).startswith("sejm_api_")) def test_exact_duplicate_fingerprint_depends_on_text_only(self) -> None: left = sample_row(1) right = dict(left, speaker="Inny mówca", date="2025-01-01") self.assertEqual(text_fingerprint(str(left["text"])), text_fingerprint(str(right["text"]))) def test_missing_speaker_rejected(self) -> None: with self.assertRaisesRegex(ContributionError, "speaker"): normalize_source_row( dict(sample_row(1), speaker=""), start_date=START_DATE, added_date="2026-08-22", encoder=FakeEncoder() ) def test_nonofficial_source_url_rejected(self) -> None: with self.assertRaisesRegex(ContributionError, "source URL"): normalize_source_row( dict(sample_row(1), source_url="https://example.com/speech"), start_date=START_DATE, added_date="2026-08-22", encoder=FakeEncoder() ) def test_temporal_novelty_against_both_registered_sources(self) -> None: self.assertEqual(assert_temporal_novelty(REGISTRY, START_DATE), { "parliamentary": "2019-12-31", "parlamint_pl": "2022-12-31", }) def test_overlap_with_registered_parlamint_fails_closed(self) -> None: with self.assertRaisesRegex(ContributionError, "overlaps"): assert_temporal_novelty(REGISTRY, "2022-01-01") def test_registry_entry_is_valid_and_preserves_existing_sources(self) -> None: updated = insert_source_registry_entry(REGISTRY, end_date="2026-07-03") ast.parse(updated) self.assertIn('"sejm_api": {', updated) self.assertIn('"parlamint_pl": {', updated) self.assertIn('"created": "2023-01-01, 2026-07-03"', updated) def test_legal_evidence_contains_official_sources_and_no_fake_cc(self) -> None: evidence = legal_evidence(source_revision="a" * 40, target_revision="b" * 40) self.assertEqual(evidence["dataset_record_license"], SOURCE_LICENSE) self.assertEqual(evidence["copyright_basis"]["article"], "4(2)") self.assertIn("no upstream Creative Commons grant is asserted", evidence["limitations"]) class DynawordParquetIntegrationTests(unittest.TestCase): def test_end_to_end_candidate_preserves_ontology_and_attribution(self) -> None: try: import pyarrow as pa import pyarrow.parquet as pq import tiktoken # noqa: F401 except ImportError: self.skipTest("pyarrow and tiktoken are installed on the release runner") with tempfile.TemporaryDirectory() as temporary: root = pathlib.Path(temporary) source_dir = root / "source" / "data" source_dir.mkdir(parents=True) duplicate = sample_row(1) train_rows = [ sample_row(0, date="2022-12-31"), duplicate, sample_row(2, date="2025-06-10"), ] validation_rows = [dict(duplicate, speaker="Duplikat mówcy")] for name, rows in (("train", train_rows), ("validation", validation_rows)): pq.write_table(pa.Table.from_pylist(rows), source_dir / f"{name}.parquet") registry = root / "sources.py" registry.write_text(REGISTRY, encoding="utf-8") output = root / "result" result = build_contribution( root / "source", registry, output, source_revision="a" * 40, target_revision="b" * 40, added_date="2026-08-22", actor="github:PiotrStyla", run_id="github-actions:1", git_commit="c" * 40, tests_file=pathlib.Path(__file__), ) self.assertEqual(result["stats"]["read"], 4) self.assertEqual(result["stats"]["drop_before_start"], 1) self.assertEqual(result["stats"]["drop_dup"], 1) self.assertEqual(result["stats"]["kept"], 2) self.assertEqual(result["stats"]["authors_with_value"], 2) parquet = pq.read_table(output / "data" / "sejm_api" / "sejm_api.parquet") self.assertEqual(tuple(parquet.column_names), EXPECTED_FIELDS) self.assertEqual(parquet.num_rows, 2) manifest = json.loads( (output / "artifacts" / "sejm_api_ontology_manifest.json").read_text() ) self.assertEqual(len(manifest["claims"]), 3) self.assertEqual(len(manifest["evidence"]), 5) self.assertTrue((output / "src" / "fetch_sejm_api.py").is_file()) self.assertTrue((output / "src" / "test_sejm_api_contract.py").is_file()) if __name__ == "__main__": unittest.main()