sejm_api_2011_2022: re-pin the dedup to the PPC TEI parliamentary (v2#54, 5A)

artifacts/source_findings.md

@@ -2379,3 +2379,29 @@ lines of real text (`2020 r.`) and 82 records quoting the transcript title in ru
 a speaker filter is only as good as the turn boundaries under it: the first allowlist filtered
 labels correctly but kept a guest's words inside an official's turn because the splitter knew only
 role-anchored labels. Cut at everything that looks like a label, then classify.
+
+## sejm_api_2011_2022 — dedup re-pinned to the PPC TEI `parliamentary` (2026-10-08)
+
+**Finding** (slayerlabs/polish-dynaword-v2#54, option 5A) — the cross-source dedup scored
+against the v0.2.5 `parliamentary`, which Hub PR 108 replaces with a rebuild from the PPC TEI
+dump under a speaker allowlist. The rebuild keeps Sejm plenary text up to term 8 but drops
+speakers the allowlist does not match, so a dedup against it keeps rows the old shard dropped.
+
+**Fix** — `REFERENCES` pins the rebuilt `parliamentary.parquet` (`5f21252e…`). Reference groups
+are read from the record id (`PPC_ID`, `PPC_KINDS`: house and directory code; plenary,
+interpellation and reply codes are listed, every other code is a committee) instead of the old
+heuristic. The duplicate outcome key `sejm_api_only` (same count as `only_sejm_api`) is removed.
+126,967 rows enter the search as before; 92,369 are contained (93,861), 34,598 published
+(33,106), 28,712,009 tokens. Against the old build 22 rows are newly dropped (2020-2022 Sejm
+speeches 0.50-0.71 contained in a 2019-2023 Senate document) and 1,514 rows (7,126,113
+characters) are kept again: 573 (4,908,128) whose speaker the allowlist drops (citizens'
+initiative representatives, the President's Chancellery, the Prosecutor General's office, agency
+heads; slayerlabs/polish-dynaword-v2#99), 470 (1,084,769) not in the dump (435 of them
+"(tekst niewygłoszony)"), 357 (911,196) mostly in kept text but under 0.5 (315 lose mainly
+floor interjections), 114 (222,020) to other rebuild drops. The 23 speeches of MP Piotr van der
+Coghen stay dropped: the rebuild's name check keeps a member's name with a particle (decision
+1A of 2026-10-08). Parquet sha256 `f6ec51dfd87b47b93905adcdd8f8dfb3f8449d6319df4153526c900bf258062f`.
+
+**Not established** — the hand checks in the card still date from Hub PR 76. The 573 rows whose
+speaker no allowlist rule matches stay here until the allowlist is applied to this source
+(slayerlabs/polish-dynaword-v2#99).

data/sejm_api_2011_2022/sejm_api_2011_2022.attribution.jsonl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:bb45cbd376de47a0244a661ac9eddf8a06a56ac37d048d5bcb00555c61dba72c
-size 16449002
+oid sha256:f0265fc4f2ee057a3c0d8d3b83ade5d1c2a9b02a6cac3c9729075d186c5e2eaa
+size 17245797

data/sejm_api_2011_2022/sejm_api_2011_2022.decisions.jsonl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:848e9f7bb3731149c2533d9a0e86896fc8e4129871dd6390534fc47d8499b86f
-size 29347301
+oid sha256:0af52b4c94f4afee54471cb3da82a82071de9d08e12174a990519d2c0b7aee97
+size 31246917

data/sejm_api_2011_2022/sejm_api_2011_2022.md

@@ -11,7 +11,7 @@ from the already merged `sejm_api` 2023-onward artifact.
 - Domain: political/spoken
 - Language: Polish (`pl`)
 - License: `public-domain (official documents)`
-- Created: 2011-12-14 through 2022-12-14
+- Created: 2011-11-08 through 2022-12-14
 - Added: 2026-08-31
 - Contributor: Piotr Styła (`PiotrSty` on Hugging Face; `PiotrStyla` on GitHub)
 
@@ -46,54 +46,75 @@ Hub PR 18) and `has_events: null`, since the snapshot's events flag describes th
 whole parent row. Rows that fall under the fetch's 200-character minimum after the
 cut (5,374 cut speeches and 2,189 split rows) and 20 texts that became exact
 duplicates are dropped. The cut runs before the containment search, so a speech is
-scored on its own words and an appended statement on its own; 2,527 split rows are
-published, 180 of them cut from a speech that is itself dropped as contained.
+scored on its own words and an appended statement on its own; 3,082 split rows are
+published, 500 of them cut from a speech that is itself dropped as contained.
 
 ## Existing-source overlap
 
 The rights audit (slayerlabs/polish-dynaword-v2#57) found that this source
-re-publishes text already in `parliamentary` (released in 0.2.0). A speech is now
-dropped when one document of a pinned reference set holds at least half of its
-5-word shingles (containment >= 0.5 over NFKC-casefolded `\w+` tokens, the
-tokenisation of the repo's `near_dedup`, in `src/shingle_containment.py`; the
-trailers are cut first, see "Trailer cut"). The reference set is every Parquet whose
-registry `release` is not `None`: `parliamentary` and `sejm_api` (after its own
-trailer cut).
+re-publishes text already in `parliamentary`. A speech is dropped when one document
+of a pinned reference set holds at least half of its 5-word shingles (containment
+>= 0.5 over NFKC-casefolded `\w+` tokens, the tokenisation of the repo's `near_dedup`,
+in `src/shingle_containment.py`; the trailers are cut first, see "Trailer cut"). The
+reference set is every Parquet whose registry `release` is not `None`:
+`parliamentary` (the PPC TEI rebuild of slayerlabs/polish-dynaword-v2#54, Hub PR 108)
+and `sejm_api` (after its own trailer cut), each pinned by SHA-256 in `REFERENCES`.
 `parlamint_pl` is no longer registered and has no data, so it is not a reference.
 Rows under five words have no shingles and are kept (none in this build).
 
-Rows dropped, of 126,967 after the trailer cut, by reference set (a row can match
-several slices):
-
-| Reference set | Dropped |
-|---|---:|
-| `parliamentary` + `sejm_api` (this build) | 93,861 |
-| `parliamentary`, all slices | 93,844 |
-| `parliamentary`, plenary slice alone | 53,904 |
-| `parliamentary`, committee slice alone | 40,429 |
-| `parliamentary`, interpellation question / reply / other alone | 244 / 17 / 107 |
-| `sejm_api` alone (outcome A: `parliamentary` withdrawn) | 45 |
-| `sejm_api` + `parliamentary` without its committee slice (outcome B) | 54,081 |
-
-Almost all overlap is 2011-2019: 93,784 of the 93,861 drops. Kept per year, 2011-2019:
-2, 5, 5, 5, 23, 50, 29, 32, 1,130; 2020-2022 are nearly intact (77 dropped).
-Another 639 rows score 0.3-0.5 and are kept.
-
-If #54 changes `parliamentary`, the pinned reference set is out of date: re-pin
-`REFERENCES` in `src/clean_sejm_api_2011_2022.py` and rerun it on the restored inputs.
-The slice split is the audit's heuristic classifier (`ppc_classify.py`, unvalidated):
-its "committee" label also catches plenary sittings (10 of 11 committee-labelled
-references in a 20-pair hand check), so outcome B is the number that classifier gives,
-not a count of committee transcripts.
+Rows dropped, of 126,967 after the trailer cut, against all references and against
+each reference group alone (a row can match several groups). A `parliamentary` group
+is read from the record id: the house (`sjm` Sejm, `snt` Senate) and the dump's
+directory code (plenary sitting, interpellation, reply to one; every other code is a
+committee).
+
+| Outcome key | Reference set | Dropped |
+|---|---|---:|
+| `all_references` | `parliamentary` + `sejm_api` (this build) | 92,369 |
+| `parliamentary_all` | `parliamentary`, all groups | 92,347 |
+| `only_parliamentary_sjm-plenary` | Sejm plenary sittings | 92,312 |
+| `only_parliamentary_sjm-committee` | Sejm committee sittings | 125 |
+| `only_parliamentary_sjm-interpellation` | Sejm interpellations | 281 |
+| `only_parliamentary_sjm-reply` | Replies to Sejm interpellations | 19 |
+| `only_parliamentary_snt-plenary` | Senate plenary sittings | 86 |
+| `only_parliamentary_snt-committee` | Senate committee sittings | 27 |
+| `only_sejm_api` | `sejm_api` | 45 |
+
+The overlap is the Sejm plenary record of 2011-2019: 92,281 of the 92,369 drops are
+dated 2011-2019. Kept per year, 2011-2019: 48, 120, 96, 102, 190, 235, 343, 304, 1,346;
+2020-2022 are nearly intact (88 dropped). Another 1,059 rows score 0.3-0.5 and are kept.
+
+Against the v0.2.5 `parliamentary` this step dropped 93,861 rows. Against the rebuild,
+22 more rows are dropped (Sejm speeches of 2020-2022 that are 0.50-0.71 contained in a
+2019-2023 Senate document) and 1,514 rows (7,126,113 characters) are kept again:
+
+- 573 rows (4,908,128 characters) are in the PPC dump, but the rebuild drops their
+  speaker because no allowlist rule matches: representatives of citizens' legislative
+  initiative committees, the President's Chancellery, the Prosecutor General's office
+  and agency heads. The allowlist does not apply to this source yet
+  (slayerlabs/polish-dynaword-v2#99), so they stay here.
+- 470 rows (1,084,769 characters) are not in the dump: under 0.3 of their shingles
+  occur in its Sejm sittings of the same day. 435 of them are statements entered into
+  the record without being delivered (the author ends in "(tekst niewygłoszony)"),
+  which the dump's stenograms do not hold.
+- 357 rows (911,196 characters) sit mostly in text the rebuild keeps but score under
+  0.5. In 315 of them most of the rest is floor interjections (lines with ": "), which
+  the rebuild drops.
+- 114 rows (222,020 characters) fall to other drops of the rebuild: speakers without a
+  role in the dump's header (41), interjection lines (50), free-text labels (14),
+  speaker lines inside a turn (8) and a committee chair who is not a member (1).
+
+The 23 speeches of MP Piotr van der Coghen stay dropped: the rebuild keeps a name with a
+particle when it is a member's (slayerlabs/polish-dynaword-v2#54, decision 1A).
 
 Known limits: containment is measured against single reference documents, not a union,
 and a threshold of 0.5 with no minimum size also drops short formulaic speeches. The
-hand checks that follow were made on the build before the trailer cut (Hub PR 76),
-which had 170 drops dated 2020 or later, against 77 now. In a random 12 of those 170,
-9 were stage directions or stock phrases, 2 were report templates (0.5-0.58) and 1 was
-real reuse. In a hand check of 20 pairs between 0.3 and 0.7, 14 had the speech's own
-wording in the reference (4 of 10 between 0.3 and 0.5, 10 of 10 between 0.5 and 0.7);
-the 6 that did not are all dated 2020 or later.
+hand checks that follow were made against the v0.2.5 `parliamentary` before the trailer
+cut (Hub PR 76), which had 170 drops dated 2020 or later, against 88 now. In a random 12
+of those 170, 9 were stage directions or stock phrases, 2 were report templates
+(0.5-0.58) and 1 was real reuse. In a hand check of 20 pairs between 0.3 and 0.7, 14 had
+the speech's own wording in the reference (4 of 10 between 0.3 and 0.5, 10 of 10 between
+0.5 and 0.7); the 6 that did not are all dated 2020 or later.
 
 ## Statistics
 
@@ -105,11 +126,11 @@ the 6 that did not are all dated 2020 or later.
 | Statements split into rows of their own | 15,648 |
 | Rows under 200 characters after the trailer cut | 7,563 |
 | Exact duplicate texts removed | 20 |
-| Contained in `parliamentary` / `sejm_api` (containment >= 0.5) | 93,861 |
-| Documents published | 33,106 |
-| Characters | 70,230,096 |
-| Tokens (`cl100k_base` proxy) | 26,112,679 |
-| Documents with speaker attribution | 33,106 |
+| Contained in `parliamentary` / `sejm_api` (containment >= 0.5) | 92,369 |
+| Documents published | 34,598 |
+| Characters | 77,313,079 |
+| Tokens (`cl100k_base` proxy) | 28,712,009 |
+| Documents with speaker attribution | 34,598 |
 
 The canonical schema is `id, text, source, added, created, token_count, license, author`.
 
@@ -141,7 +162,7 @@ Which cleaning ran, in order:
 3. **Trailer cut and cross-source dedup** (`src/clean_sejm_api_2011_2022.py`, run on
    the output of step 2): cuts the "Przebieg posiedzenia" trailers and splits the
    appended statements into rows of their own (see "Trailer cut"), then drops the
-   93,861 rows contained (5-shingle containment >= 0.5) in a `parliamentary` or
+   92,369 rows contained (5-shingle containment >= 0.5) in a `parliamentary` or
    `sejm_api` document; see "Existing-source overlap".
 
 Apart from the trailer cut, before/after at the text level is a deliberate no-op (the pinned

data/sejm_api_2011_2022/sejm_api_2011_2022.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:622228ca4c287f91792b7da3fb97c098610c1cf890f1bdc08922dc3aca3742db
-size 28185916
+oid sha256:f6ec51dfd87b47b93905adcdd8f8dfb3f8449d6319df4153526c900bf258062f
+size 31048209

data/sejm_api_2011_2022/sejm_api_2011_2022.stats.json

@@ -1,45 +1,45 @@
 {
   "added": "2026-08-31",
-  "authors_with_value": 33106,
+  "authors_with_value": 34598,
   "by_source_split": {
-    "train": 32454,
-    "validation": 652
+    "train": 33914,
+    "validation": 684
   },
   "by_term": {
-    "7": 21,
-    "8": 157,
-    "9": 32928
+    "7": 461,
+    "8": 1220,
+    "9": 32917
   },
   "by_year": {
-    "2011": 2,
-    "2012": 5,
-    "2013": 5,
-    "2014": 5,
-    "2015": 23,
-    "2016": 50,
-    "2017": 29,
-    "2018": 32,
-    "2019": 1130,
-    "2020": 7937,
-    "2021": 10239,
-    "2022": 13649
+    "2011": 48,
+    "2012": 120,
+    "2013": 96,
+    "2014": 102,
+    "2015": 190,
+    "2016": 235,
+    "2017": 343,
+    "2018": 304,
+    "2019": 1346,
+    "2020": 7934,
+    "2021": 10238,
+    "2022": 13642
   },
-  "chars": 70230096,
+  "chars": 77313079,
   "created_max": "2022-12-14",
-  "created_min": "2011-12-14",
+  "created_min": "2011-11-08",
   "drop_after_end": 38812,
   "drop_before_start": 0,
   "drop_dup": 20,
-  "kept": 33106,
+  "kept": 34598,
   "license": "public-domain (official documents)",
   "licenses": {
-    "public-domain (official documents)": 33106
+    "public-domain (official documents)": 34598
   },
   "read": 157714,
   "source_revision": "124557799608ce4212cf22fa90ca7904618de1b6",
   "stats_recomputed_from_parquet": true,
   "target_base_revision": "a9d134ac79a9fe586fc9c11cb39eb32d69dcd21f",
-  "tokens": 26112679,
+  "tokens": 28712009,
   "split_rows": 15648,
   "drop_short": 7563,
   "trailer_cut": {
@@ -49,7 +49,7 @@
     "drop_short": 7563,
     "drop_dup": 20
   },
-  "drop_cross_source_dup": 93861,
+  "drop_cross_source_dup": 92369,
   "cross_source_dedup": {
     "drop_at": 0.5,
     "report_at": 0.3,
@@ -60,49 +60,49 @@
       "sejm_api_2011_2022.stats.json": "398dbaff87ec8f1d8702fce347db65ae8a3e4cf69a90594a6c7998cc4441c356"
     },
     "reference_sha256": {
-      "parliamentary": "64b94993e196b9df87b243189cfe104a84b38474b701c1f249fcc9cac60488c8",
+      "parliamentary": "5f21252ee65425a77cdd48bdb964171fb06cd6cf0c59c0b882be995d84dcec7c",
       "sejm_api": "ba2daa20d2d2753c09e8bdd477839f43c82170f44caeadc634cb2295362c9c3b"
     },
     "no_shingles": 0,
     "dropped_by_best_group": {
-      "parliamentary:committee": 40095,
-      "parliamentary:interp_question": 2,
-      "parliamentary:other": 61,
-      "parliamentary:plenary": 53683,
-      "sejm_api": 20
+      "parliamentary:sjm-committee": 3,
+      "parliamentary:sjm-interpellation": 15,
+      "parliamentary:sjm-plenary": 92304,
+      "parliamentary:snt-committee": 14,
+      "parliamentary:snt-plenary": 8,
+      "sejm_api": 25
     },
     "dropped_by_year": {
-      "2011": 995,
-      "2012": 12577,
-      "2013": 12950,
-      "2014": 11402,
-      "2015": 11497,
-      "2016": 14176,
-      "2017": 12784,
-      "2018": 10876,
-      "2019": 6527,
-      "2020": 12,
-      "2021": 37,
-      "2022": 28
+      "2011": 949,
+      "2012": 12462,
+      "2013": 12859,
+      "2014": 11305,
+      "2015": 11330,
+      "2016": 13991,
+      "2017": 12470,
+      "2018": 10604,
+      "2019": 6311,
+      "2020": 15,
+      "2021": 38,
+      "2022": 35
     },
     "dropped_by_shingles": {
       "<10": 0,
-      "10-19": 5,
-      "20-49": 3910,
-      "50-199": 42880,
-      ">=200": 47066
+      "10-19": 3,
+      "20-49": 3769,
+      "50-199": 42466,
+      ">=200": 46131
     },
-    "kept_partial": 639,
+    "kept_partial": 1059,
     "outcomes": {
-      "all_references": 93861,
-      "sejm_api_only": 45,
-      "parliamentary_all": 93844,
-      "parliamentary_without_committee_plus_sejm_api": 54081,
-      "only_parliamentary_committee": 40429,
-      "only_parliamentary_interp_question": 244,
-      "only_parliamentary_interp_reply": 17,
-      "only_parliamentary_other": 107,
-      "only_parliamentary_plenary": 53904,
+      "all_references": 92369,
+      "parliamentary_all": 92347,
+      "only_parliamentary_sjm-committee": 125,
+      "only_parliamentary_sjm-interpellation": 281,
+      "only_parliamentary_sjm-plenary": 92312,
+      "only_parliamentary_sjm-reply": 19,
+      "only_parliamentary_snt-committee": 27,
+      "only_parliamentary_snt-plenary": 86,
       "only_sejm_api": 45
     }
   }

src/clean_sejm_api_2011_2022.py

@@ -1,9 +1,9 @@
 #!/usr/bin/env python3
 """Drop sejm_api_2011_2022 speeches already contained in a pinned reference set (slayerlabs/polish-dynaword-v2#57).
 
-The rights audit found that sejm_api_2011_2022 overlaps `parliamentary` (2011-2019) and the
-since-removed `parlamint_pl`. A speech is dropped when one document of the reference set holds at
-least DROP_AT of its shingles:
+The rights audit found that sejm_api_2011_2022 overlaps `parliamentary` (Sejm sittings to the end of
+term 8, sejm_api_common.PARLIAMENTARY_SEJM_END) and the since-removed `parlamint_pl`. A speech is
+dropped when one document of the reference set holds at least DROP_AT of its shingles:
 
   containment(speech, ref) = |S(speech) & S(ref)| / |S(speech)|
 
@@ -16,17 +16,17 @@ document can be a whole sitting while a speech is a few paragraphs. It is measur
 reference documents, not a union of them.
 
 The reference set is REFERENCES: every Parquet whose registry `release` is not None, each pinned by
-SHA-256. If slayerlabs/polish-dynaword-v2#54 changes `parliamentary` (withdraw it, or filter out its
-committee slice), re-pin REFERENCES and rerun this script on the restored input; nothing here
+SHA-256. `parliamentary` is the PPC TEI rebuild of slayerlabs/polish-dynaword-v2#54 (option C). When a
+reference changes, re-pin REFERENCES and rerun this script on the restored input; nothing here
 follows the registry silently.
 
 Exact search: the speeches are indexed, the references are streamed. A speech is found when a
 reference shares at least one of its rarest (1 - REPORT_AT) * n + 1 shingles (prefix filter,
 exact by pigeonhole), and every such candidate is then scored on its full shingle sets. No
 MinHash/LSH, so there is no sampling error. Speeches scoring from REPORT_AT up are written to
-sejm_api_2011_2022.decisions.jsonl with the best score against each reference group, so the
-effect of each #54 outcome can be read without rerunning. Speeches under five words have no
-shingles and are never dropped.
+sejm_api_2011_2022.decisions.jsonl with the best score against each reference group
+(`parliamentary:<house>-<kind>` from the record id, or the source key). Speeches under five words
+have no shingles and are never dropped.
 
 The inputs are the pre-dedup release files, pinned by SHA-256. Restore them before a rerun:
   git checkout 3bab9f9 -- data/sejm_api_2011_2022/sejm_api_2011_2022.{parquet,attribution.jsonl,stats.json}
@@ -66,7 +66,7 @@ INPUT_SHA256 = {
 # `parlamint_pl` left the registry in Hub PR 54 and never had data, so it cannot be pinned.
 REFERENCES = {
     "parliamentary": (ROOT / "data/parliamentary/parliamentary.parquet",
-                      "64b94993e196b9df87b243189cfe104a84b38474b701c1f249fcc9cac60488c8"),
+                      "5f21252ee65425a77cdd48bdb964171fb06cd6cf0c59c0b882be995d84dcec7c"),
     "sejm_api": (ROOT / "data/sejm_api/sejm_api.parquet",  # after src/clean_sejm_api.py
                  "ba2daa20d2d2753c09e8bdd477839f43c82170f44caeadc634cb2295362c9c3b"),
 }
@@ -76,29 +76,22 @@ REPORT_AT = 0.3
 ROW_GROUP_SIZE = 1024  # the layout of the released file
 SIZE_BUCKETS = (("<10", 0, 10), ("10-19", 10, 20), ("20-49", 20, 50), ("50-199", 50, 200), (">=200", 200, 10**9))
 
-_R = lambda pattern: re.compile(pattern, re.I)  # noqa: E731
-# The audit's heuristic split of `parliamentary` (artifacts/rights_audit_2026-10/official/ppc_classify.py,
-# unvalidated, v2#54). It only labels the report; the drop decision never uses it.
-PPC_COMMITTEE = _R(r'(Otwieram|Rozpoczynam|Witam)[^.\n]{0,160}(posiedzenie|posiedzeniu|Komisji)|posiedzenie (Komisji|Podkomisji)|^\(Początek posiedzenia|Posiedzeniu przewodniczy')
-PPC_PLENARY = _R(r'^\((Wznowienie|Początek|Ciąg dalszy|Przerwa)[^)]*\)\s*\n?\(?(Posiedzeniu przewodnicz|Na posiedzeniu przewodnicz)|Wysoka Izbo|Wysoki Sejmie|Wysoki Senacie')
-PPC_REPLY = _R(r'SPS-0\d\d|W odpowiedzi na (interpelacj|zapytani)|Odpowiadając na (interpelacj|zapytani)|odpowiedzi na (interpelacj|zapytani)|w związku z (interpelacj|zapytani)')
-PPC_QUESTION = _R(r'^(Szanown|Szanowni|Wielce Szanown|Panie Marszałku|Pani Marszałek|Panie Ministrze|Pani Minister|Panie Premierze|Pani Premier)|zwracam się (do Pana|do Pani)|interpelacj')
+# `parliamentary` ids are parliamentary_<term>-<house>-<code>-<sitting>-<part> (src/fetch_parliamentary.py),
+# <code> being the dump's directory name padded with "x" to five letters. These codes are the plenary and
+# interpellation directories; every other code is a committee. Codes can be non-ASCII ("kśpxx").
+PPC_ID = re.compile(r"parliamentary_\d+-(sjm|snt|krn)-(\w+)-\d+-\d+")
+PPC_KINDS = {"ppxxx": "plenary", "usxxx": "plenary", "uzxxx": "plenary", "wsxxx": "plenary", "znxxx": "plenary",
+             "ipxxx": "interpellation", "zpxxx": "interpellation", "ioxxx": "reply", "zoxxx": "reply"}
 
 
-def ppc_slice(text: str) -> str:
-    head = text[:2500]
-    if PPC_COMMITTEE.search(head) and not PPC_REPLY.search(head):
-        return "committee"
-    if PPC_PLENARY.search(text[:4000]) and not PPC_REPLY.search(head):
-        return "plenary"
-    if PPC_REPLY.search(head):
-        return "interp_reply"
-    return "interp_question" if PPC_QUESTION.search(head) else "other"
-
-
-def group_of(source: str, text: str) -> str:
-    """Reference group a document is reported under: `parliamentary:<slice>` or the source key."""
-    return f"parliamentary:{ppc_slice(text)}" if source == "parliamentary" else source
+def group_of(source: str, ref_id: str) -> str:
+    """Reference group a document is reported under: `parliamentary:<house>-<kind>` or the source key."""
+    if source != "parliamentary":
+        return source
+    match = PPC_ID.fullmatch(ref_id)
+    if not match:
+        raise ValueError(f"{ref_id!r} is not a parliamentary record id")
+    return f"parliamentary:{match[1]}-{PPC_KINDS.get(match[2], 'committee')}"
 
 
 def min_shared(sizes: np.ndarray, at: float) -> np.ndarray:
@@ -162,7 +155,7 @@ def _scan_row_group(task: tuple[str, str, int]) -> dict[tuple[int, str], tuple[i
         hits = int(lens.sum())
         if not hits:
             continue
-        group = group_of(source, text)
+        group = group_of(source, ref_id)
         for doc in np.unique(prefix_doc[np.repeat(lo - np.cumsum(lens) + lens, lens) + np.arange(hits)]):
             speech = flat[offsets[doc]:offsets[doc + 1]]
             at = np.minimum(np.searchsorted(ref, speech), len(ref) - 1)
@@ -217,15 +210,13 @@ def score_table(sizes: np.ndarray, best: dict[tuple[int, str], tuple[int, str]],
 
 
 def outcomes(scores: np.ndarray, groups: list[str]) -> dict[str, int]:
-    """Speeches dropped (best score >= DROP_AT) for each reference set the maintainers may end up with."""
+    """Speeches dropped (best score >= DROP_AT) against each reference, and against each group alone."""
     def dropped(wanted):
         cols = [i for i, g in enumerate(groups) if wanted(g)]
         return int((scores[:, cols].max(axis=1) >= DROP_AT).sum()) if cols else 0
     return {
         "all_references": dropped(lambda g: True),
-        "sejm_api_only": dropped(lambda g: g == "sejm_api"),
         "parliamentary_all": dropped(lambda g: g.startswith("parliamentary:")),
-        "parliamentary_without_committee_plus_sejm_api": dropped(lambda g: g != "parliamentary:committee"),
         **{f"only_{g.replace(':', '_')}": dropped(lambda x, g=g: x == g) for g in groups},
     }
 

src/sources.py

@@ -332,13 +332,13 @@ SOURCES = {
                       "src/clean_sejm_api_2011_2022.py cuts the \"Przebieg posiedzenia\" "
                       "trailers (appended statements become rows of their own) and drops rows "
                       "whose 5-shingle containment in one document of the pinned "
-                      "parliamentary / sejm_api Parquets is >= 0.5 (118,902 -> 33,106 docs; "
-                      "re-pin and rerun if polish-dynaword-v2#54 changes parliamentary). NERGAL "
+                      "parliamentary / sejm_api Parquets is >= 0.5 (118,902 -> 34,598 docs; "
+                      "parliamentary is the polish-dynaword-v2#54 PPC TEI rebuild). NERGAL "
                       "not run - re-run "
                       "through SlayerLab/NERGAL before release. Shared helpers factored into "
                       "src/sejm_api_common.py.",
         "domain": "political/spoken",
-        "created": "2011-12-14, 2022-12-14",
+        "created": "2011-11-08, 2022-12-14",
         "is_ocr": False,
         "custom_datasheet": True,
     },

src/test_sejm_api_2011_2022_contract.py

@@ -225,6 +225,44 @@ def test_no_trailer_is_left_and_split_rows_are_marked():
                for row, line in split)
 
 
+def test_card_cites_the_stats():
+    stats = json.loads((DATA / "sejm_api_2011_2022.stats.json").read_text(encoding="utf-8"))
+    dedup = stats["cross_source_dedup"]
+    card = " ".join((DATA / "sejm_api_2011_2022.md").read_text(encoding="utf-8").split())
+    table = {
+        "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"],
+        "Statements split into rows of their own": stats["split_rows"],
+        "Rows under 200 characters after the trailer cut": stats["drop_short"],
+        "Exact duplicate texts removed": stats["drop_dup"],
+        "Contained in `parliamentary` / `sejm_api` (containment >= 0.5)": stats["drop_cross_source_dup"],
+        "Documents published": stats["kept"],
+        "Characters": stats["chars"],
+        "Tokens (`cl100k_base` proxy)": stats["tokens"],
+        "Documents with speaker attribution": stats["authors_with_value"],
+    }
+    for label, value in table.items():
+        assert f"| {label} | {value:,} |" in card
+    assert f"- Created: {stats['created_min']} through {stats['created_max']}" in card
+    entry = SOURCES["sejm_api_2011_2022"]
+    assert entry["created"] == f"{stats['created_min']}, {stats['created_max']}"
+    assert f"-> {stats['kept']:,} docs" in entry["provenance"]
+    for outcome, dropped in dedup["outcomes"].items():
+        assert re.search(rf"\| `{re.escape(outcome)}` \|[^|]*\| {dropped:,} \|", card), outcome
+    assert f"Another {dedup['kept_partial']:,} rows score 0.3-0.5 and are kept." in card
+    assert f"drops the {stats['drop_cross_source_dup']:,} rows contained" in card
+    kept_by_year = ", ".join(f"{stats['by_year'].get(str(year), 0):,}" for year in range(2011, 2020))
+    assert f"Kept per year, 2011-2019: {kept_by_year};" in card
+
+    decisions = [json.loads(line) for line in (DATA / clean.DECISIONS).open(encoding="utf-8")]
+    dropped = {d["id"] for d in decisions if d["action"] == "drop"}
+    with (DATA / "sejm_api_2011_2022.attribution.jsonl").open(encoding="utf-8") as stream:
+        parents = [line["split_from"] for line in map(json.loads, stream) if "split_from" in line]
+    assert (f"{len(parents):,} split rows are published, {sum(p in dropped for p in parents):,} of them "
+            "cut from a speech that is itself dropped as contained") in card
+
+
 def test_pin_check_fails_closed_and_writes_nothing(tmp_path, monkeypatch):
     (tmp_path / "x").write_bytes(b"x")
     with pytest.raises(SystemExit, match="pinned SHA-256"):
@@ -244,31 +282,32 @@ def test_pin_check_fails_closed_and_writes_nothing(tmp_path, monkeypatch):
 
 
 WORDS = lambda tag, count: " ".join(f"{tag}{i}" for i in range(count))  # noqa: E731
+P1, P2 = "parliamentary_201115-sjm-ppxxx-00001-01", "parliamentary_201115-sjm-zdrxx-00001-01"  # plenary, committee
 
 
 def _write_refs(tmp_path):
     parliamentary, sejm_api = tmp_path / "parliamentary.parquet", tmp_path / "sejm_api.parquet"
-    pq.write_table(pa.table({"id": ["ref_p1", "ref_p2"], "text": [WORDS("w", 40), WORDS("z", 40)]}), parliamentary)
+    pq.write_table(pa.table({"id": [P1, P2], "text": [WORDS("w", 40), WORDS("z", 40)]}), parliamentary)
     pq.write_table(pa.table({"id": ["ref_s1"], "text": [WORDS("s", 40)]}), sejm_api)
     return {"parliamentary": parliamentary, "sejm_api": sejm_api}
 
 
 def test_synthetic_containment_boundaries_and_groups(tmp_path):
     texts = [
-        WORDS("w", 20),                               # 0: all of it is in ref_p1 -> 1.0
+        WORDS("w", 20),                               # 0: all of it is in P1 -> 1.0
         WORDS("w", 8) + " " + WORDS("a", 6),          # 1: 4 of 10 shingles -> 0.4, reported, kept
         WORDS("w", 8) + " " + WORDS("b", 4),          # 2: 4 of 8 shingles -> exactly 0.5, dropped
         WORDS("q", 30),                               # 3: unrelated
         "w0 w1 w2 w3",                                # 4: under five words, no shingles
-        WORDS("w", 20) + " " + WORDS("s", 20),        # 5: ref_p1 holds 16 of 36, ref_s1 holds 16 of 36
+        WORDS("w", 20) + " " + WORDS("s", 20),        # 5: P1 holds 16 of 36, ref_s1 holds 16 of 36
         WORDS("s", 30),                               # 6: only in the sejm_api reference
     ]
     sizes, best = clean.find_contained(texts, _write_refs(tmp_path), tmp_path, workers=1)
     assert sizes.tolist() == [16, 10, 8, 26, 0, 36, 26]
-    assert best[(0, "parliamentary:other")] == (16, "ref_p1")
-    assert best[(1, "parliamentary:other")] == (4, "ref_p1")
-    assert best[(2, "parliamentary:other")] == (4, "ref_p1")
-    assert best[(5, "parliamentary:other")] == (16, "ref_p1")
+    assert best[(0, "parliamentary:sjm-plenary")] == (16, P1)
+    assert best[(1, "parliamentary:sjm-plenary")] == (4, P1)
+    assert best[(2, "parliamentary:sjm-plenary")] == (4, P1)
+    assert best[(5, "parliamentary:sjm-plenary")] == (16, P1)
     assert best[(5, "sejm_api")] == (16, "ref_s1")
     assert best[(6, "sejm_api")] == (26, "ref_s1")
     assert not {doc for doc, _ in best} & {3, 4}
@@ -276,13 +315,16 @@ def test_synthetic_containment_boundaries_and_groups(tmp_path):
     scores = clean.score_table(sizes, best, groups)
     assert scores[2].max() == 0.5 and scores[1].max() == 0.4
     assert clean.outcomes(scores, groups)["all_references"] == 3  # docs 0, 2 and 6; doc 5 holds 16/36 = 0.44 per group
-    assert clean.outcomes(scores, groups)["sejm_api_only"] == 1   # doc 6
+    assert clean.outcomes(scores, groups)["only_sejm_api"] == 1   # doc 6
+    assert clean.outcomes(scores, groups)["parliamentary_all"] == 2  # docs 0 and 2
+    assert clean.outcomes(scores, groups)["only_parliamentary_sjm-plenary"] == 2
 
 
 def test_search_agrees_with_brute_force_and_ties_go_to_the_smaller_id(tmp_path):
     from shingle_containment import shingles
     refs = {"parliamentary": tmp_path / "parliamentary.parquet"}
-    ref_texts = {"ref_b": WORDS("w", 25), "ref_a": WORDS("w", 25), "ref_c": WORDS("w", 12) + " " + WORDS("k", 20)}
+    a, b, c = (f"parliamentary_201115-sjm-ppxxx-0000{n}-01" for n in (1, 2, 3))
+    ref_texts = {b: WORDS("w", 25), a: WORDS("w", 25), c: WORDS("w", 12) + " " + WORDS("k", 20)}
     pq.write_table(pa.table({"id": list(ref_texts), "text": list(ref_texts.values())}), refs["parliamentary"],
                    row_group_size=1)
     texts = [WORDS("w", n) + " " + WORDS(f"n{n}_", m) for n, m in ((25, 0), (14, 6), (10, 10), (6, 12))]
@@ -292,20 +334,33 @@ def test_search_agrees_with_brute_force_and_ties_go_to_the_smaller_id(tmp_path):
         expected = {rid: len(mine & set(shingles(r).tolist())) for rid, r in ref_texts.items()}
         top = max(expected.values())
         if top >= clean.min_shared(sizes[doc:doc + 1], clean.REPORT_AT)[0]:
-            assert best[(doc, "parliamentary:other")] == (top, min(r for r, n in expected.items() if n == top))
+            assert best[(doc, "parliamentary:sjm-plenary")] == (top, min(r for r, n in expected.items() if n == top))
         else:
-            assert (doc, "parliamentary:other") not in best
+            assert (doc, "parliamentary:sjm-plenary") not in best
+
+
+def test_groups_come_from_the_record_id():
+    assert clean.group_of("parliamentary", P1) == "parliamentary:sjm-plenary"
+    assert clean.group_of("parliamentary", P2) == "parliamentary:sjm-committee"
+    assert clean.group_of("parliamentary", "parliamentary_202327-snt-kśpxx-00001-01") == "parliamentary:snt-committee"
+    assert clean.group_of("parliamentary", "parliamentary_201115-sjm-ipxxx-00001-01") == "parliamentary:sjm-interpellation"
+    assert clean.group_of("parliamentary", "parliamentary_201115-sjm-zoxxx-00001-01") == "parliamentary:sjm-reply"
+    assert clean.group_of("parliamentary", "parliamentary_194447-krn-ppxxx-00001-01") == "parliamentary:krn-plenary"
+    assert clean.group_of("sejm_api", "anything") == "sejm_api"
+    for bad in ("ref_p1", "parliamentary_201115-xyz-ppxxx-00001-01", "parliamentary_201115-sjm-ppxxx-00001"):
+        with pytest.raises(ValueError, match="not a parliamentary record id"):
+            clean.group_of("parliamentary", bad)
 
 
-def test_slice_labels_follow_the_audit_heuristic():
-    # Patterns copied verbatim from the audit's ppc_classify.py (unvalidated, v2#54); labels only, never a drop rule.
-    assert clean.ppc_slice("(Wznowienie posiedzenia o godz. 9)\n(Na posiedzeniu przewodniczą marszałek Sejmu)") == "plenary"
-    assert clean.ppc_slice("Otwieram posiedzenie Komisji Kultury") == "committee"
-    assert clean.ppc_slice("W odpowiedzi na interpelację nr 5") == "interp_reply"
-    assert clean.ppc_slice("Szanowny Panie Ministrze, zwracam się") == "interp_question"
-    assert clean.ppc_slice(WORDS("w", 10)) == "other"
-    assert clean.group_of("parliamentary", WORDS("w", 10)) == "parliamentary:other"
-    assert clean.group_of("sejm_api", "Otwieram posiedzenie Komisji") == "sejm_api"
+def test_record_id_groups_agree_with_the_ppc_document_types():
+    kinds = {"Komisja": "committee", "Interpelacja": "interpellation", "Zapytanie": "interpellation",
+             "Odpowiedź na interpelację": "reply", "Odpowiedź na zapytanie": "reply"}
+    with (ROOT / "data/parliamentary/parliamentary.attribution.jsonl").open(encoding="utf-8") as stream:
+        lines = [json.loads(line) for line in stream]
+    assert lines
+    wrong = [line["id"] for line in lines
+             if clean.group_of("parliamentary", line["id"]).split("-")[-1] != kinds.get(line["type"], "plenary")]
+    assert wrong == []
 
 
 def _synthetic_release(directory, ids_texts):
@@ -336,7 +391,7 @@ def test_synthetic_build_filters_every_output_consistently(tmp_path, monkeypatch
     assert [json.loads(line)["id"] for line in (tmp_path / f"{clean.SOURCE}.attribution.jsonl").open()] == ["keep", "part", "tiny"]
     decisions = [json.loads(line) for line in (tmp_path / clean.DECISIONS).open()]
     assert [(d["id"], d["action"], d["containment"], d["ref_id"]) for d in decisions] == [
-        ("dup", "drop", 1.0, "ref_p1"), ("edge", "drop", 0.5, "ref_p1"), ("part", "keep_partial", 0.4, "ref_p1")]
+        ("dup", "drop", 1.0, P1), ("edge", "drop", 0.5, P1), ("part", "keep_partial", 0.4, P1)]
     assert (stats["kept"], stats["drop_cross_source_dup"], stats["read"]) == (3, 2, 8)
     assert stats["chars"] == sum(len(t) for i, t in release if i in ("keep", "part", "tiny"))
     assert stats["cross_source_dedup"]["no_shingles"] == 1 and stats["cross_source_dedup"]["kept_partial"] == 1
@@ -347,7 +402,7 @@ def test_synthetic_build_filters_every_output_consistently(tmp_path, monkeypatch
 def test_trailers_are_cut_before_containment(tmp_path, monkeypatch):
     (tmp_path / "refs").mkdir()
     refs = _write_refs(tmp_path / "refs")
-    statement = WORDS("w", 40) + " " + WORDS("x", 20)  # 219 characters; 36 of its 56 shingles are in ref_p1
+    statement = WORDS("w", 40) + " " + WORDS("x", 20)  # 219 characters; 36 of its 56 shingles are in P1
     # Uncut, the row would hold those 36 among ~130 shingles (under REPORT_AT) and be kept whole.
     text = WORDS("q", 60) + " " + header("Jan Nowak", "Poseł Jan Nowak", "01-01-2020") + " Poseł Jan Nowak: " + statement
     monkeypatch.setattr(clean, "INPUT_SHA256", _synthetic_release(tmp_path, [("speech", text)]))
@@ -357,7 +412,7 @@ def test_trailers_are_cut_before_containment(tmp_path, monkeypatch):
     assert pq.read_table(tmp_path / f"{clean.SOURCE}.parquet").to_pylist()[0]["text"] == WORDS("q", 60)
     assert [json.loads(line)["id"] for line in (tmp_path / f"{clean.SOURCE}.attribution.jsonl").open()] == ["speech"]
     decisions = [json.loads(line) for line in (tmp_path / clean.DECISIONS).open()]
-    assert [(d["action"], d["containment"], d["ref_id"]) for d in decisions] == [("drop", round(36 / 56, 4), "ref_p1")]
+    assert [(d["action"], d["containment"], d["ref_id"]) for d in decisions] == [("drop", round(36 / 56, 4), P1)]
     assert decisions[0]["id"].startswith(f"{clean.SOURCE}_")
     assert (stats["kept"], stats["split_rows"], stats["drop_short"], stats["drop_cross_source_dup"]) == (1, 1, 0, 1)
     assert stats["trailer_cut"]["rows_cut"] == 1