From c0692b307854f0b3fc737da892a3b8f66a0e3182 Mon Sep 17 00:00:00 2001 From: Dotty Dotter Date: Tue, 28 Apr 2026 23:09:07 +0200 Subject: [PATCH] feat(#106 Folge): 16 Stub-Parser + Tracking-Issues fuer alle Bundeslaender MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Pro BL (BUND + 15 Laender) ein Modul app/protokoll_parsers/.py mit: - Recherche-Findings im Docstring (Doku-System, Base-URL, Format, URL-Discovery-Status, Familie, Aufwand-Schaetzung) - parse_protocol() raised NotImplementedError mit Hinweis auf Issue-Tracker - *Nicht* in PROTOKOLL_PARSERS-Registry → Auto-Ingest-Cron uebersieht sie Tracking-Issues #148-#163 auf Gitea, jeweils mit den Recherche-Findings und einer Checkliste fuer die Implementer-Session. Roadmap-Doc (docs/protokoll-parser-roadmap.md) aktualisiert mit Stub→Issue-Mapping-Tabelle. Wenn der Implementer pro BL fertig ist: 1. NotImplementedError durch echten Parser ersetzen 2. Eintrag in app/protokoll_parsers/__init__.py::PROTOKOLL_PARSERS 3. PROTO_TARGETS in scripts/auto-ingest-protocols.sh ergaenzen 787 Tests gruen, NRW unveraendert. --- app/protokoll_parsers/bb.py | 47 ++++++++++++++++ app/protokoll_parsers/be.py | 47 ++++++++++++++++ app/protokoll_parsers/bund.py | 93 ++++++++++++++++++++++++++++++++ app/protokoll_parsers/bw.py | 47 ++++++++++++++++ app/protokoll_parsers/by.py | 47 ++++++++++++++++ app/protokoll_parsers/hb.py | 47 ++++++++++++++++ app/protokoll_parsers/he.py | 47 ++++++++++++++++ app/protokoll_parsers/hh.py | 47 ++++++++++++++++ app/protokoll_parsers/lsa.py | 47 ++++++++++++++++ app/protokoll_parsers/mv.py | 47 ++++++++++++++++ app/protokoll_parsers/ni.py | 47 ++++++++++++++++ app/protokoll_parsers/rp.py | 47 ++++++++++++++++ app/protokoll_parsers/sh.py | 47 ++++++++++++++++ app/protokoll_parsers/sl.py | 47 ++++++++++++++++ app/protokoll_parsers/sn.py | 47 ++++++++++++++++ app/protokoll_parsers/th.py | 47 ++++++++++++++++ docs/protokoll-parser-roadmap.md | 27 ++++++++++ 17 files changed, 825 insertions(+) create mode 100644 app/protokoll_parsers/bb.py create mode 100644 app/protokoll_parsers/be.py create mode 100644 app/protokoll_parsers/bund.py create mode 100644 app/protokoll_parsers/bw.py create mode 100644 app/protokoll_parsers/by.py create mode 100644 app/protokoll_parsers/hb.py create mode 100644 app/protokoll_parsers/he.py create mode 100644 app/protokoll_parsers/hh.py create mode 100644 app/protokoll_parsers/lsa.py create mode 100644 app/protokoll_parsers/mv.py create mode 100644 app/protokoll_parsers/ni.py create mode 100644 app/protokoll_parsers/rp.py create mode 100644 app/protokoll_parsers/sh.py create mode 100644 app/protokoll_parsers/sl.py create mode 100644 app/protokoll_parsers/sn.py create mode 100644 app/protokoll_parsers/th.py diff --git a/app/protokoll_parsers/bb.py b/app/protokoll_parsers/bb.py new file mode 100644 index 0000000..81f3a71 --- /dev/null +++ b/app/protokoll_parsers/bb.py @@ -0,0 +1,47 @@ +"""Brandenburg (BB) — Plenarprotokoll-Parser STUB (#106 Folge, ADR 0009). + +**Status: noch nicht implementiert.** Dieser Modul-Stub enthaelt +Recherche-Findings vom 2026-04-28, sodass die Implementer-Session +direkt produktiv loslegen kann. Der Stub wird **nicht** in +``app.protokoll_parsers.PROTOKOLL_PARSERS`` registriert — der +Auto-Ingest-Cron ueberspringt BB solange. + +## Recherche + +| Feld | Wert | +|---|---| +| **Doku-System** | portala | +| **Base-URL** | https://www.parlamentsdokumentation.brandenburg.de | +| **Familie** | RP/HE-Familie | +| **Format** | PDF (Vote-Tabellen erwartet); BB-Adapter PortalaAdapter | + +## URL-Discovery + +https://www.parlamentsdokumentation.brandenburg.de/parladoku/w8/plpr/PlPr8-{n}.pdf (HTTP 403 ohne Referer) + +## Bezug + +- Architektur: ADR 0009 (Plenarprotokoll-Parser-Registry) +- Roadmap: ``docs/protokoll-parser-roadmap.md`` +- Referenz-Implementation: ``app/protokoll_parsers/nrw.py`` + (38 Tests, 19/19-Fixture-Garantie) +- Folge-Issue: https://repo.toppyr.de/tobias/gwoe-antragspruefer/issues/149 (Titel: "protokoll-parser: BB (Brandenburg)") + +## Aufwand + +Geschaetzt 1-3 Tage konzentrierte Arbeit: +- 2-4h URL-Discovery + Format-Inspektion (Sample-Protokoll inhaltlich anschauen) +- 4-8h Anchor-Phrasen-Reverse-Engineering + Parser-Implementierung +- 4h Tests mit Fixture-Pinning +- 1h Eintrag in PROTOKOLL_PARSERS + auto-ingest-protocols.sh +""" +from __future__ import annotations + + +def parse_protocol(path: str) -> list[dict]: + """STUB — siehe Modul-Docstring.""" + raise NotImplementedError( + "BB-Plenarprotokoll-Parser ist noch nicht implementiert. " + "Siehe app/protokoll_parsers/bb.py-Docstring fuer Recherche-Findings " + "und docs/protokoll-parser-roadmap.md." + ) diff --git a/app/protokoll_parsers/be.py b/app/protokoll_parsers/be.py new file mode 100644 index 0000000..0524ffa --- /dev/null +++ b/app/protokoll_parsers/be.py @@ -0,0 +1,47 @@ +"""Berlin (BE) — Plenarprotokoll-Parser STUB (#106 Folge, ADR 0009). + +**Status: noch nicht implementiert.** Dieser Modul-Stub enthaelt +Recherche-Findings vom 2026-04-28, sodass die Implementer-Session +direkt produktiv loslegen kann. Der Stub wird **nicht** in +``app.protokoll_parsers.PROTOKOLL_PARSERS`` registriert — der +Auto-Ingest-Cron ueberspringt BE solange. + +## Recherche + +| Feld | Wert | +|---|---| +| **Doku-System** | PARDOK | +| **Base-URL** | https://pardok.parlament-berlin.de | +| **Familie** | LSA-Familie | +| **Format** | PDF erwartet | + +## URL-Discovery + +Plenum-PDF-URLs ueber PARDOK-Search-API zu ermitteln; direktes Pattern noch nicht bekannt + +## Bezug + +- Architektur: ADR 0009 (Plenarprotokoll-Parser-Registry) +- Roadmap: ``docs/protokoll-parser-roadmap.md`` +- Referenz-Implementation: ``app/protokoll_parsers/nrw.py`` + (38 Tests, 19/19-Fixture-Garantie) +- Folge-Issue: https://repo.toppyr.de/tobias/gwoe-antragspruefer/issues/150 (Titel: "protokoll-parser: BE (Berlin)") + +## Aufwand + +Geschaetzt 1-3 Tage konzentrierte Arbeit: +- 2-4h URL-Discovery + Format-Inspektion (Sample-Protokoll inhaltlich anschauen) +- 4-8h Anchor-Phrasen-Reverse-Engineering + Parser-Implementierung +- 4h Tests mit Fixture-Pinning +- 1h Eintrag in PROTOKOLL_PARSERS + auto-ingest-protocols.sh +""" +from __future__ import annotations + + +def parse_protocol(path: str) -> list[dict]: + """STUB — siehe Modul-Docstring.""" + raise NotImplementedError( + "BE-Plenarprotokoll-Parser ist noch nicht implementiert. " + "Siehe app/protokoll_parsers/be.py-Docstring fuer Recherche-Findings " + "und docs/protokoll-parser-roadmap.md." + ) diff --git a/app/protokoll_parsers/bund.py b/app/protokoll_parsers/bund.py new file mode 100644 index 0000000..bf155f2 --- /dev/null +++ b/app/protokoll_parsers/bund.py @@ -0,0 +1,93 @@ +"""Bundestag (BUND) — Plenarprotokoll-Parser STUB (#106 Folge, ADR 0009). + +**Status: noch nicht implementiert.** Dieser Modul-Stub enthaelt +Recherche-Findings, sodass die Implementer-Session direkt produktiv +loslegen kann. Der Stub wird **nicht** in +``app.protokoll_parsers.PROTOKOLL_PARSERS`` registriert — der +Auto-Ingest-Cron ueberspringt BUND solange. + +## Recherche 2026-04-28 + +### URL-Pattern + +Plenum-Protokoll als XML (strukturiert): +``` +https://dserver.bundestag.de/btp/{wp}/{wp}{n:03}.xml +``` +Beispiel WP20 Sitzung 184: ``https://dserver.bundestag.de/btp/20/20184.xml`` + +Plenum-Protokoll als PDF (rendert dasselbe): +``` +https://dserver.bundestag.de/btp/{wp}/{wp}{n:03}.pdf +``` + +### XML-Format + +Top-Level: ```` mit Children: +- ```` — Sitzungsmetadaten +- ```` — Reden + Tagesordnungspunkte +- ```` — Beschluss-Anlagen, namentliche Abstimmungen +- ```` + +Tags: ````, ````, ```` (Regie- +Anweisungen wie "(Beifall bei der CDU/CSU)"), ```` mit +````-Untertag. + +**Kein ````-Tag.** Vote-Daten muessen aus Reden + Kommentaren +extrahiert werden — gleiche Architektur wie NRW (Anchor-basiert), aber +mit ANDEREN Anchor-Phrasen. + +### Vote-Anchor-Phrasen (vom NRW-Pattern abweichend!) + +Bundestag-typisch: +- "Wer dem [Antrag/Gesetzentwurf] seine Zustimmung gibt, den bitte + ich, sich vom Platz zu erheben." +- "Damit ist [...] in zweiter Beratung angenommen." +- "Die Mehrheit hat den Gesetzentwurf [...] abgelehnt." +- "Wir kommen zur Abstimmung in dritter Lesung." +- "[...] wird zur federfuehrenden Beratung an den Ausschuss [...] + ueberwiesen." + +**Achtung:** WP20-Sitzung 184 enthielt 0 dieser Anchors weil pure +Aussprache. Echtes Sample mit Beschluessen brauchts (z.B. Sitzungen +mit Gesetzentwurf-Lesungen). + +### Strukturierte Alternative — namentliche Abstimmungen + +Bundestag publiziert namentliche Abstimmungen separat als Excel/XML +unter ``bundestag.de/parlament/plenum/abstimmung/abstimmung``. Pro +Abstimmung MP-level Vote-Records. Fraktions-Aggregate sind dort +extrahierbar OHNE PDF-Parsing. + +**Empfehlung fuer Implementer:** statt PDF/XML-Parser bauen, lieber +``app/abgeordnetenwatch.py`` (existiert) auf Fraktions-Aggregat-Form +runterrechnen — das deckt namentliche Abstimmungen sauber ab. Nur fuer +Hammelsprung-und-Handzeichen-Abstimmungen (nicht-namentlich) muss man +das XML-Plenum parsen. + +### Sample-Daten fuer Tests + +- WP20 Sitzung 30: "{wp}{n:03}" → btp/20/20030.xml — enthaelt diverse + Gesetzentwurf-Beschluesse +- Sitzungen mit "namentliche Abstimmung" laut Tagesordnung sind + Goldstandard fuer Tests + +### Aufwand + +Geschaetzt 1-2 Tage: +- 4h Reverse-Engineering der Anchor-Sprache (mehrere Sample-Sitzungen) +- 4h Parser-Implementierung +- 4h Tests (Fixture-Pinning analog NRW 19/19-Garantie) + +Folge-Issue: https://repo.toppyr.de/tobias/gwoe-antragspruefer/issues/148 +""" +from __future__ import annotations + + +def parse_protocol(pdf_or_xml_path: str) -> list[dict]: + """STUB — siehe Modul-Docstring.""" + raise NotImplementedError( + "BUND-Plenarprotokoll-Parser ist noch nicht implementiert. " + "Siehe app/protokoll_parsers/bund.py-Docstring fuer Recherche-Findings " + "und docs/protokoll-parser-roadmap.md." + ) diff --git a/app/protokoll_parsers/bw.py b/app/protokoll_parsers/bw.py new file mode 100644 index 0000000..8a71845 --- /dev/null +++ b/app/protokoll_parsers/bw.py @@ -0,0 +1,47 @@ +"""Baden-Württemberg (BW) — Plenarprotokoll-Parser STUB (#106 Folge, ADR 0009). + +**Status: noch nicht implementiert.** Dieser Modul-Stub enthaelt +Recherche-Findings vom 2026-04-28, sodass die Implementer-Session +direkt produktiv loslegen kann. Der Stub wird **nicht** in +``app.protokoll_parsers.PROTOKOLL_PARSERS`` registriert — der +Auto-Ingest-Cron ueberspringt BW solange. + +## Recherche + +| Feld | Wert | +|---|---| +| **Doku-System** | PARLIS | +| **Base-URL** | https://parlis.landtag-bw.de | +| **Familie** | eigenstaendig (PARLIS-spezifisch, eigene Pattern) | +| **Format** | PDF; URL-Pattern bekannt mit 4-stelliger Sitzungs-Nr | + +## URL-Discovery + +https://www.landtag-bw.de/files/live/sites/LTBW/files/dokumente/WP{wp}/Plp/{wp}_{n:04}.pdf (HTTP 200 verifiziert!) + +## Bezug + +- Architektur: ADR 0009 (Plenarprotokoll-Parser-Registry) +- Roadmap: ``docs/protokoll-parser-roadmap.md`` +- Referenz-Implementation: ``app/protokoll_parsers/nrw.py`` + (38 Tests, 19/19-Fixture-Garantie) +- Folge-Issue: https://repo.toppyr.de/tobias/gwoe-antragspruefer/issues/151 (Titel: "protokoll-parser: BW (Baden-Württemberg)") + +## Aufwand + +Geschaetzt 1-3 Tage konzentrierte Arbeit: +- 2-4h URL-Discovery + Format-Inspektion (Sample-Protokoll inhaltlich anschauen) +- 4-8h Anchor-Phrasen-Reverse-Engineering + Parser-Implementierung +- 4h Tests mit Fixture-Pinning +- 1h Eintrag in PROTOKOLL_PARSERS + auto-ingest-protocols.sh +""" +from __future__ import annotations + + +def parse_protocol(path: str) -> list[dict]: + """STUB — siehe Modul-Docstring.""" + raise NotImplementedError( + "BW-Plenarprotokoll-Parser ist noch nicht implementiert. " + "Siehe app/protokoll_parsers/bw.py-Docstring fuer Recherche-Findings " + "und docs/protokoll-parser-roadmap.md." + ) diff --git a/app/protokoll_parsers/by.py b/app/protokoll_parsers/by.py new file mode 100644 index 0000000..1c3d285 --- /dev/null +++ b/app/protokoll_parsers/by.py @@ -0,0 +1,47 @@ +"""Bayern (BY) — Plenarprotokoll-Parser STUB (#106 Folge, ADR 0009). + +**Status: noch nicht implementiert.** Dieser Modul-Stub enthaelt +Recherche-Findings vom 2026-04-28, sodass die Implementer-Session +direkt produktiv loslegen kann. Der Stub wird **nicht** in +``app.protokoll_parsers.PROTOKOLL_PARSERS`` registriert — der +Auto-Ingest-Cron ueberspringt BY solange. + +## Recherche + +| Feld | Wert | +|---|---| +| **Doku-System** | Eigensystem | +| **Base-URL** | https://www.bayern.landtag.de | +| **Familie** | eigenstaendig | +| **Format** | PDF erwartet, eigenes ElanTextAblage-System | + +## URL-Discovery + +URL-Pattern nicht trivial vorhersagbar — direkte Probe schlug 404 + +## Bezug + +- Architektur: ADR 0009 (Plenarprotokoll-Parser-Registry) +- Roadmap: ``docs/protokoll-parser-roadmap.md`` +- Referenz-Implementation: ``app/protokoll_parsers/nrw.py`` + (38 Tests, 19/19-Fixture-Garantie) +- Folge-Issue: https://repo.toppyr.de/tobias/gwoe-antragspruefer/issues/152 (Titel: "protokoll-parser: BY (Bayern)") + +## Aufwand + +Geschaetzt 1-3 Tage konzentrierte Arbeit: +- 2-4h URL-Discovery + Format-Inspektion (Sample-Protokoll inhaltlich anschauen) +- 4-8h Anchor-Phrasen-Reverse-Engineering + Parser-Implementierung +- 4h Tests mit Fixture-Pinning +- 1h Eintrag in PROTOKOLL_PARSERS + auto-ingest-protocols.sh +""" +from __future__ import annotations + + +def parse_protocol(path: str) -> list[dict]: + """STUB — siehe Modul-Docstring.""" + raise NotImplementedError( + "BY-Plenarprotokoll-Parser ist noch nicht implementiert. " + "Siehe app/protokoll_parsers/by.py-Docstring fuer Recherche-Findings " + "und docs/protokoll-parser-roadmap.md." + ) diff --git a/app/protokoll_parsers/hb.py b/app/protokoll_parsers/hb.py new file mode 100644 index 0000000..878ac06 --- /dev/null +++ b/app/protokoll_parsers/hb.py @@ -0,0 +1,47 @@ +"""Bremen (HB) — Plenarprotokoll-Parser STUB (#106 Folge, ADR 0009). + +**Status: noch nicht implementiert.** Dieser Modul-Stub enthaelt +Recherche-Findings vom 2026-04-28, sodass die Implementer-Session +direkt produktiv loslegen kann. Der Stub wird **nicht** in +``app.protokoll_parsers.PROTOKOLL_PARSERS`` registriert — der +Auto-Ingest-Cron ueberspringt HB solange. + +## Recherche + +| Feld | Wert | +|---|---| +| **Doku-System** | PARiS | +| **Base-URL** | https://paris.bremische-buergerschaft.de | +| **Familie** | StarWeb-Familie | +| **Format** | PDF (oder HTML) | + +## URL-Discovery + +URL-Pattern unbekannt — PARiS-Skin-Search-API noetig + +## Bezug + +- Architektur: ADR 0009 (Plenarprotokoll-Parser-Registry) +- Roadmap: ``docs/protokoll-parser-roadmap.md`` +- Referenz-Implementation: ``app/protokoll_parsers/nrw.py`` + (38 Tests, 19/19-Fixture-Garantie) +- Folge-Issue: https://repo.toppyr.de/tobias/gwoe-antragspruefer/issues/153 (Titel: "protokoll-parser: HB (Bremen)") + +## Aufwand + +Geschaetzt 1-3 Tage konzentrierte Arbeit: +- 2-4h URL-Discovery + Format-Inspektion (Sample-Protokoll inhaltlich anschauen) +- 4-8h Anchor-Phrasen-Reverse-Engineering + Parser-Implementierung +- 4h Tests mit Fixture-Pinning +- 1h Eintrag in PROTOKOLL_PARSERS + auto-ingest-protocols.sh +""" +from __future__ import annotations + + +def parse_protocol(path: str) -> list[dict]: + """STUB — siehe Modul-Docstring.""" + raise NotImplementedError( + "HB-Plenarprotokoll-Parser ist noch nicht implementiert. " + "Siehe app/protokoll_parsers/hb.py-Docstring fuer Recherche-Findings " + "und docs/protokoll-parser-roadmap.md." + ) diff --git a/app/protokoll_parsers/he.py b/app/protokoll_parsers/he.py new file mode 100644 index 0000000..140d7c1 --- /dev/null +++ b/app/protokoll_parsers/he.py @@ -0,0 +1,47 @@ +"""Hessen (HE) — Plenarprotokoll-Parser STUB (#106 Folge, ADR 0009). + +**Status: noch nicht implementiert.** Dieser Modul-Stub enthaelt +Recherche-Findings vom 2026-04-28, sodass die Implementer-Session +direkt produktiv loslegen kann. Der Stub wird **nicht** in +``app.protokoll_parsers.PROTOKOLL_PARSERS`` registriert — der +Auto-Ingest-Cron ueberspringt HE solange. + +## Recherche + +| Feld | Wert | +|---|---| +| **Doku-System** | portala | +| **Base-URL** | https://starweb.hessen.de/portal | +| **Familie** | BB/RP-Familie | +| **Format** | HTML bevorzugt; ggf. PDF als Fallback | + +## URL-Discovery + +Plenum-Protokolle wahrscheinlich als HTML mit semantischen Tags pro Beschluss — wenn HTML zugaenglich, EINFACHER als PDF-Parser + +## Bezug + +- Architektur: ADR 0009 (Plenarprotokoll-Parser-Registry) +- Roadmap: ``docs/protokoll-parser-roadmap.md`` +- Referenz-Implementation: ``app/protokoll_parsers/nrw.py`` + (38 Tests, 19/19-Fixture-Garantie) +- Folge-Issue: https://repo.toppyr.de/tobias/gwoe-antragspruefer/issues/154 (Titel: "protokoll-parser: HE (Hessen)") + +## Aufwand + +Geschaetzt 1-3 Tage konzentrierte Arbeit: +- 2-4h URL-Discovery + Format-Inspektion (Sample-Protokoll inhaltlich anschauen) +- 4-8h Anchor-Phrasen-Reverse-Engineering + Parser-Implementierung +- 4h Tests mit Fixture-Pinning +- 1h Eintrag in PROTOKOLL_PARSERS + auto-ingest-protocols.sh +""" +from __future__ import annotations + + +def parse_protocol(path: str) -> list[dict]: + """STUB — siehe Modul-Docstring.""" + raise NotImplementedError( + "HE-Plenarprotokoll-Parser ist noch nicht implementiert. " + "Siehe app/protokoll_parsers/he.py-Docstring fuer Recherche-Findings " + "und docs/protokoll-parser-roadmap.md." + ) diff --git a/app/protokoll_parsers/hh.py b/app/protokoll_parsers/hh.py new file mode 100644 index 0000000..310b8a9 --- /dev/null +++ b/app/protokoll_parsers/hh.py @@ -0,0 +1,47 @@ +"""Hamburg (HH) — Plenarprotokoll-Parser STUB (#106 Folge, ADR 0009). + +**Status: noch nicht implementiert.** Dieser Modul-Stub enthaelt +Recherche-Findings vom 2026-04-28, sodass die Implementer-Session +direkt produktiv loslegen kann. Der Stub wird **nicht** in +``app.protokoll_parsers.PROTOKOLL_PARSERS`` registriert — der +Auto-Ingest-Cron ueberspringt HH solange. + +## Recherche + +| Feld | Wert | +|---|---| +| **Doku-System** | ParlDok | +| **Base-URL** | https://www.buergerschaft-hh.de/parldok | +| **Familie** | MV/TH-Familie | +| **Format** | PDF via ParlDok-Search | + +## URL-Discovery + +ParlDok 5.x oder 8.x — Live-Format vor Implementierung verifizieren (curl -s buergerschaft-hh.de/parldok/ | grep ParlDok) + +## Bezug + +- Architektur: ADR 0009 (Plenarprotokoll-Parser-Registry) +- Roadmap: ``docs/protokoll-parser-roadmap.md`` +- Referenz-Implementation: ``app/protokoll_parsers/nrw.py`` + (38 Tests, 19/19-Fixture-Garantie) +- Folge-Issue: https://repo.toppyr.de/tobias/gwoe-antragspruefer/issues/155 (Titel: "protokoll-parser: HH (Hamburg)") + +## Aufwand + +Geschaetzt 1-3 Tage konzentrierte Arbeit: +- 2-4h URL-Discovery + Format-Inspektion (Sample-Protokoll inhaltlich anschauen) +- 4-8h Anchor-Phrasen-Reverse-Engineering + Parser-Implementierung +- 4h Tests mit Fixture-Pinning +- 1h Eintrag in PROTOKOLL_PARSERS + auto-ingest-protocols.sh +""" +from __future__ import annotations + + +def parse_protocol(path: str) -> list[dict]: + """STUB — siehe Modul-Docstring.""" + raise NotImplementedError( + "HH-Plenarprotokoll-Parser ist noch nicht implementiert. " + "Siehe app/protokoll_parsers/hh.py-Docstring fuer Recherche-Findings " + "und docs/protokoll-parser-roadmap.md." + ) diff --git a/app/protokoll_parsers/lsa.py b/app/protokoll_parsers/lsa.py new file mode 100644 index 0000000..05a516a --- /dev/null +++ b/app/protokoll_parsers/lsa.py @@ -0,0 +1,47 @@ +"""Sachsen-Anhalt (LSA) — Plenarprotokoll-Parser STUB (#106 Folge, ADR 0009). + +**Status: noch nicht implementiert.** Dieser Modul-Stub enthaelt +Recherche-Findings vom 2026-04-28, sodass die Implementer-Session +direkt produktiv loslegen kann. Der Stub wird **nicht** in +``app.protokoll_parsers.PROTOKOLL_PARSERS`` registriert — der +Auto-Ingest-Cron ueberspringt LSA solange. + +## Recherche + +| Feld | Wert | +|---|---| +| **Doku-System** | PARDOK | +| **Base-URL** | https://padoka.landtag.sachsen-anhalt.de | +| **Familie** | BE-Familie | +| **Format** | PDF erwartet | + +## URL-Discovery + +Padoka-Plattform; URL-Pattern via Search-API zu ermitteln + +## Bezug + +- Architektur: ADR 0009 (Plenarprotokoll-Parser-Registry) +- Roadmap: ``docs/protokoll-parser-roadmap.md`` +- Referenz-Implementation: ``app/protokoll_parsers/nrw.py`` + (38 Tests, 19/19-Fixture-Garantie) +- Folge-Issue: https://repo.toppyr.de/tobias/gwoe-antragspruefer/issues/156 (Titel: "protokoll-parser: LSA (Sachsen-Anhalt)") + +## Aufwand + +Geschaetzt 1-3 Tage konzentrierte Arbeit: +- 2-4h URL-Discovery + Format-Inspektion (Sample-Protokoll inhaltlich anschauen) +- 4-8h Anchor-Phrasen-Reverse-Engineering + Parser-Implementierung +- 4h Tests mit Fixture-Pinning +- 1h Eintrag in PROTOKOLL_PARSERS + auto-ingest-protocols.sh +""" +from __future__ import annotations + + +def parse_protocol(path: str) -> list[dict]: + """STUB — siehe Modul-Docstring.""" + raise NotImplementedError( + "LSA-Plenarprotokoll-Parser ist noch nicht implementiert. " + "Siehe app/protokoll_parsers/lsa.py-Docstring fuer Recherche-Findings " + "und docs/protokoll-parser-roadmap.md." + ) diff --git a/app/protokoll_parsers/mv.py b/app/protokoll_parsers/mv.py new file mode 100644 index 0000000..c5fa028 --- /dev/null +++ b/app/protokoll_parsers/mv.py @@ -0,0 +1,47 @@ +"""Mecklenburg-Vorpommern (MV) — Plenarprotokoll-Parser STUB (#106 Folge, ADR 0009). + +**Status: noch nicht implementiert.** Dieser Modul-Stub enthaelt +Recherche-Findings vom 2026-04-28, sodass die Implementer-Session +direkt produktiv loslegen kann. Der Stub wird **nicht** in +``app.protokoll_parsers.PROTOKOLL_PARSERS`` registriert — der +Auto-Ingest-Cron ueberspringt MV solange. + +## Recherche + +| Feld | Wert | +|---|---| +| **Doku-System** | ParlDok | +| **Base-URL** | https://www.dokumentation.landtag-mv.de | +| **Familie** | TH-Familie (synergie-fähig) | +| **Format** | PDF nach ID-Discovery | + +## URL-Discovery + +ParlDok 8.x SPA — Plenum-PDFs hinter Search-API. Doc-IDs nicht direkt vorhersagbar. Fuer URL-Discovery: ParlDok-Search mit Plenarprotokoll-Filter durchparsen. + +## Bezug + +- Architektur: ADR 0009 (Plenarprotokoll-Parser-Registry) +- Roadmap: ``docs/protokoll-parser-roadmap.md`` +- Referenz-Implementation: ``app/protokoll_parsers/nrw.py`` + (38 Tests, 19/19-Fixture-Garantie) +- Folge-Issue: https://repo.toppyr.de/tobias/gwoe-antragspruefer/issues/157 (Titel: "protokoll-parser: MV (Mecklenburg-Vorpommern)") + +## Aufwand + +Geschaetzt 1-3 Tage konzentrierte Arbeit: +- 2-4h URL-Discovery + Format-Inspektion (Sample-Protokoll inhaltlich anschauen) +- 4-8h Anchor-Phrasen-Reverse-Engineering + Parser-Implementierung +- 4h Tests mit Fixture-Pinning +- 1h Eintrag in PROTOKOLL_PARSERS + auto-ingest-protocols.sh +""" +from __future__ import annotations + + +def parse_protocol(path: str) -> list[dict]: + """STUB — siehe Modul-Docstring.""" + raise NotImplementedError( + "MV-Plenarprotokoll-Parser ist noch nicht implementiert. " + "Siehe app/protokoll_parsers/mv.py-Docstring fuer Recherche-Findings " + "und docs/protokoll-parser-roadmap.md." + ) diff --git a/app/protokoll_parsers/ni.py b/app/protokoll_parsers/ni.py new file mode 100644 index 0000000..a9aa864 --- /dev/null +++ b/app/protokoll_parsers/ni.py @@ -0,0 +1,47 @@ +"""Niedersachsen (NI) — Plenarprotokoll-Parser STUB (#106 Folge, ADR 0009). + +**Status: noch nicht implementiert.** Dieser Modul-Stub enthaelt +Recherche-Findings vom 2026-04-28, sodass die Implementer-Session +direkt produktiv loslegen kann. Der Stub wird **nicht** in +``app.protokoll_parsers.PROTOKOLL_PARSERS`` registriert — der +Auto-Ingest-Cron ueberspringt NI solange. + +## Recherche + +| Feld | Wert | +|---|---| +| **Doku-System** | StarWeb | +| **Base-URL** | https://www.landtag-niedersachsen.de | +| **Familie** | HB/SH-Familie | +| **Format** | PDF erwartet, ggf. mit Auth-Workaround | + +## URL-Discovery + +nilas-Portal Login-protected fuer Drucksachen — fuer Plenarprotokolle ggf. eigener oeffentlicher Endpunkt; HAR-Capture noetig (siehe Issue #22) + +## Bezug + +- Architektur: ADR 0009 (Plenarprotokoll-Parser-Registry) +- Roadmap: ``docs/protokoll-parser-roadmap.md`` +- Referenz-Implementation: ``app/protokoll_parsers/nrw.py`` + (38 Tests, 19/19-Fixture-Garantie) +- Folge-Issue: https://repo.toppyr.de/tobias/gwoe-antragspruefer/issues/158 (Titel: "protokoll-parser: NI (Niedersachsen)") + +## Aufwand + +Geschaetzt 1-3 Tage konzentrierte Arbeit: +- 2-4h URL-Discovery + Format-Inspektion (Sample-Protokoll inhaltlich anschauen) +- 4-8h Anchor-Phrasen-Reverse-Engineering + Parser-Implementierung +- 4h Tests mit Fixture-Pinning +- 1h Eintrag in PROTOKOLL_PARSERS + auto-ingest-protocols.sh +""" +from __future__ import annotations + + +def parse_protocol(path: str) -> list[dict]: + """STUB — siehe Modul-Docstring.""" + raise NotImplementedError( + "NI-Plenarprotokoll-Parser ist noch nicht implementiert. " + "Siehe app/protokoll_parsers/ni.py-Docstring fuer Recherche-Findings " + "und docs/protokoll-parser-roadmap.md." + ) diff --git a/app/protokoll_parsers/rp.py b/app/protokoll_parsers/rp.py new file mode 100644 index 0000000..d965357 --- /dev/null +++ b/app/protokoll_parsers/rp.py @@ -0,0 +1,47 @@ +"""Rheinland-Pfalz (RP) — Plenarprotokoll-Parser STUB (#106 Folge, ADR 0009). + +**Status: noch nicht implementiert.** Dieser Modul-Stub enthaelt +Recherche-Findings vom 2026-04-28, sodass die Implementer-Session +direkt produktiv loslegen kann. Der Stub wird **nicht** in +``app.protokoll_parsers.PROTOKOLL_PARSERS`` registriert — der +Auto-Ingest-Cron ueberspringt RP solange. + +## Recherche + +| Feld | Wert | +|---|---| +| **Doku-System** | portala | +| **Base-URL** | https://opal.rlp.de | +| **Familie** | BB/HE-Familie | +| **Format** | PDF erwartet | + +## URL-Discovery + +OPAL_extern (NICHT identisch mit NRW-OPAL); URL-Pattern via Search-API + +## Bezug + +- Architektur: ADR 0009 (Plenarprotokoll-Parser-Registry) +- Roadmap: ``docs/protokoll-parser-roadmap.md`` +- Referenz-Implementation: ``app/protokoll_parsers/nrw.py`` + (38 Tests, 19/19-Fixture-Garantie) +- Folge-Issue: https://repo.toppyr.de/tobias/gwoe-antragspruefer/issues/159 (Titel: "protokoll-parser: RP (Rheinland-Pfalz)") + +## Aufwand + +Geschaetzt 1-3 Tage konzentrierte Arbeit: +- 2-4h URL-Discovery + Format-Inspektion (Sample-Protokoll inhaltlich anschauen) +- 4-8h Anchor-Phrasen-Reverse-Engineering + Parser-Implementierung +- 4h Tests mit Fixture-Pinning +- 1h Eintrag in PROTOKOLL_PARSERS + auto-ingest-protocols.sh +""" +from __future__ import annotations + + +def parse_protocol(path: str) -> list[dict]: + """STUB — siehe Modul-Docstring.""" + raise NotImplementedError( + "RP-Plenarprotokoll-Parser ist noch nicht implementiert. " + "Siehe app/protokoll_parsers/rp.py-Docstring fuer Recherche-Findings " + "und docs/protokoll-parser-roadmap.md." + ) diff --git a/app/protokoll_parsers/sh.py b/app/protokoll_parsers/sh.py new file mode 100644 index 0000000..12ab25c --- /dev/null +++ b/app/protokoll_parsers/sh.py @@ -0,0 +1,47 @@ +"""Schleswig-Holstein (SH) — Plenarprotokoll-Parser STUB (#106 Folge, ADR 0009). + +**Status: noch nicht implementiert.** Dieser Modul-Stub enthaelt +Recherche-Findings vom 2026-04-28, sodass die Implementer-Session +direkt produktiv loslegen kann. Der Stub wird **nicht** in +``app.protokoll_parsers.PROTOKOLL_PARSERS`` registriert — der +Auto-Ingest-Cron ueberspringt SH solange. + +## Recherche + +| Feld | Wert | +|---|---| +| **Doku-System** | StarWeb | +| **Base-URL** | http://lissh.lvn.parlanet.de | +| **Familie** | HB/NI-Familie | +| **Format** | PDF erwartet | + +## URL-Discovery + +Starfinder-CGI-Backend; Plenum-Protokolle als PDF-Direktlinks moeglich + +## Bezug + +- Architektur: ADR 0009 (Plenarprotokoll-Parser-Registry) +- Roadmap: ``docs/protokoll-parser-roadmap.md`` +- Referenz-Implementation: ``app/protokoll_parsers/nrw.py`` + (38 Tests, 19/19-Fixture-Garantie) +- Folge-Issue: https://repo.toppyr.de/tobias/gwoe-antragspruefer/issues/160 (Titel: "protokoll-parser: SH (Schleswig-Holstein)") + +## Aufwand + +Geschaetzt 1-3 Tage konzentrierte Arbeit: +- 2-4h URL-Discovery + Format-Inspektion (Sample-Protokoll inhaltlich anschauen) +- 4-8h Anchor-Phrasen-Reverse-Engineering + Parser-Implementierung +- 4h Tests mit Fixture-Pinning +- 1h Eintrag in PROTOKOLL_PARSERS + auto-ingest-protocols.sh +""" +from __future__ import annotations + + +def parse_protocol(path: str) -> list[dict]: + """STUB — siehe Modul-Docstring.""" + raise NotImplementedError( + "SH-Plenarprotokoll-Parser ist noch nicht implementiert. " + "Siehe app/protokoll_parsers/sh.py-Docstring fuer Recherche-Findings " + "und docs/protokoll-parser-roadmap.md." + ) diff --git a/app/protokoll_parsers/sl.py b/app/protokoll_parsers/sl.py new file mode 100644 index 0000000..f930945 --- /dev/null +++ b/app/protokoll_parsers/sl.py @@ -0,0 +1,47 @@ +"""Saarland (SL) — Plenarprotokoll-Parser STUB (#106 Folge, ADR 0009). + +**Status: noch nicht implementiert.** Dieser Modul-Stub enthaelt +Recherche-Findings vom 2026-04-28, sodass die Implementer-Session +direkt produktiv loslegen kann. Der Stub wird **nicht** in +``app.protokoll_parsers.PROTOKOLL_PARSERS`` registriert — der +Auto-Ingest-Cron ueberspringt SL solange. + +## Recherche + +| Feld | Wert | +|---|---| +| **Doku-System** | Eigensystem | +| **Base-URL** | https://www.landtag-saar.de | +| **Familie** | eigenstaendig | +| **Format** | PDF erwartet ueber Umbraco-Filterm | + +## URL-Discovery + +Umbraco-Backend; siehe SaarlandAdapter — Plenum-Protokolle ggf. analog Drucksachen via aawSearchSurfaceController-Pattern + +## Bezug + +- Architektur: ADR 0009 (Plenarprotokoll-Parser-Registry) +- Roadmap: ``docs/protokoll-parser-roadmap.md`` +- Referenz-Implementation: ``app/protokoll_parsers/nrw.py`` + (38 Tests, 19/19-Fixture-Garantie) +- Folge-Issue: https://repo.toppyr.de/tobias/gwoe-antragspruefer/issues/161 (Titel: "protokoll-parser: SL (Saarland)") + +## Aufwand + +Geschaetzt 1-3 Tage konzentrierte Arbeit: +- 2-4h URL-Discovery + Format-Inspektion (Sample-Protokoll inhaltlich anschauen) +- 4-8h Anchor-Phrasen-Reverse-Engineering + Parser-Implementierung +- 4h Tests mit Fixture-Pinning +- 1h Eintrag in PROTOKOLL_PARSERS + auto-ingest-protocols.sh +""" +from __future__ import annotations + + +def parse_protocol(path: str) -> list[dict]: + """STUB — siehe Modul-Docstring.""" + raise NotImplementedError( + "SL-Plenarprotokoll-Parser ist noch nicht implementiert. " + "Siehe app/protokoll_parsers/sl.py-Docstring fuer Recherche-Findings " + "und docs/protokoll-parser-roadmap.md." + ) diff --git a/app/protokoll_parsers/sn.py b/app/protokoll_parsers/sn.py new file mode 100644 index 0000000..76ecdcc --- /dev/null +++ b/app/protokoll_parsers/sn.py @@ -0,0 +1,47 @@ +"""Sachsen (SN) — Plenarprotokoll-Parser STUB (#106 Folge, ADR 0009). + +**Status: noch nicht implementiert.** Dieser Modul-Stub enthaelt +Recherche-Findings vom 2026-04-28, sodass die Implementer-Session +direkt produktiv loslegen kann. Der Stub wird **nicht** in +``app.protokoll_parsers.PROTOKOLL_PARSERS`` registriert — der +Auto-Ingest-Cron ueberspringt SN solange. + +## Recherche + +| Feld | Wert | +|---|---| +| **Doku-System** | EDAS-XML-Export | +| **Base-URL** | https://edas.landtag.sachsen.de | +| **Familie** | eigenstaendig | +| **Format** | XML bevorzugt | + +## URL-Discovery + +EDAS macht XML-Export — Plenarprotokolle ggf. ebenfalls strukturiert verfuegbar; Synergie mit bestehendem `app/sn_xml_export`-Workflow pruefen + +## Bezug + +- Architektur: ADR 0009 (Plenarprotokoll-Parser-Registry) +- Roadmap: ``docs/protokoll-parser-roadmap.md`` +- Referenz-Implementation: ``app/protokoll_parsers/nrw.py`` + (38 Tests, 19/19-Fixture-Garantie) +- Folge-Issue: https://repo.toppyr.de/tobias/gwoe-antragspruefer/issues/162 (Titel: "protokoll-parser: SN (Sachsen)") + +## Aufwand + +Geschaetzt 1-3 Tage konzentrierte Arbeit: +- 2-4h URL-Discovery + Format-Inspektion (Sample-Protokoll inhaltlich anschauen) +- 4-8h Anchor-Phrasen-Reverse-Engineering + Parser-Implementierung +- 4h Tests mit Fixture-Pinning +- 1h Eintrag in PROTOKOLL_PARSERS + auto-ingest-protocols.sh +""" +from __future__ import annotations + + +def parse_protocol(path: str) -> list[dict]: + """STUB — siehe Modul-Docstring.""" + raise NotImplementedError( + "SN-Plenarprotokoll-Parser ist noch nicht implementiert. " + "Siehe app/protokoll_parsers/sn.py-Docstring fuer Recherche-Findings " + "und docs/protokoll-parser-roadmap.md." + ) diff --git a/app/protokoll_parsers/th.py b/app/protokoll_parsers/th.py new file mode 100644 index 0000000..82f9fb2 --- /dev/null +++ b/app/protokoll_parsers/th.py @@ -0,0 +1,47 @@ +"""Thüringen (TH) — Plenarprotokoll-Parser STUB (#106 Folge, ADR 0009). + +**Status: noch nicht implementiert.** Dieser Modul-Stub enthaelt +Recherche-Findings vom 2026-04-28, sodass die Implementer-Session +direkt produktiv loslegen kann. Der Stub wird **nicht** in +``app.protokoll_parsers.PROTOKOLL_PARSERS`` registriert — der +Auto-Ingest-Cron ueberspringt TH solange. + +## Recherche + +| Feld | Wert | +|---|---| +| **Doku-System** | ParlDok | +| **Base-URL** | https://parldok.thueringer-landtag.de | +| **Familie** | MV-Familie (Synergien hoch) | +| **Format** | PDF nach ID-Discovery | + +## URL-Discovery + +ParlDok-Plattform analog MV — sobald MV-Parser steht, ist TH eine Iteration der MV-Logik mit anderem Base-URL-Praefix + +## Bezug + +- Architektur: ADR 0009 (Plenarprotokoll-Parser-Registry) +- Roadmap: ``docs/protokoll-parser-roadmap.md`` +- Referenz-Implementation: ``app/protokoll_parsers/nrw.py`` + (38 Tests, 19/19-Fixture-Garantie) +- Folge-Issue: https://repo.toppyr.de/tobias/gwoe-antragspruefer/issues/163 (Titel: "protokoll-parser: TH (Thüringen)") + +## Aufwand + +Geschaetzt 1-3 Tage konzentrierte Arbeit: +- 2-4h URL-Discovery + Format-Inspektion (Sample-Protokoll inhaltlich anschauen) +- 4-8h Anchor-Phrasen-Reverse-Engineering + Parser-Implementierung +- 4h Tests mit Fixture-Pinning +- 1h Eintrag in PROTOKOLL_PARSERS + auto-ingest-protocols.sh +""" +from __future__ import annotations + + +def parse_protocol(path: str) -> list[dict]: + """STUB — siehe Modul-Docstring.""" + raise NotImplementedError( + "TH-Plenarprotokoll-Parser ist noch nicht implementiert. " + "Siehe app/protokoll_parsers/th.py-Docstring fuer Recherche-Findings " + "und docs/protokoll-parser-roadmap.md." + ) diff --git a/docs/protokoll-parser-roadmap.md b/docs/protokoll-parser-roadmap.md index a243f5c..2a53c38 100644 --- a/docs/protokoll-parser-roadmap.md +++ b/docs/protokoll-parser-roadmap.md @@ -5,6 +5,33 @@ Cron-Infrastruktur (`scripts/auto-ingest-protocols.sh`) BL-erweiterbar. Pro weiterem BL ist ein eigener Parser zu implementieren — das ist deterministische Reverse-Engineering-Arbeit, keine LLM-Calls, keine Kosten. +## Stub-Module + Folge-Issues + +Pro BL ein Modul `app/protokoll_parsers/.py` mit Recherche-Findings +im Docstring und `NotImplementedError` als Body. Stubs sind **nicht** +in `PROTOKOLL_PARSERS` registriert — der Auto-Ingest-Cron ueberspringt +sie. Sobald ein Parser implementiert ist, verschwindet der `NotImplementedError`- +Body und der Eintrag wird in `PROTOKOLL_PARSERS` ergaenzt. + +| BL | Stub-Modul | Tracking-Issue | +|---|---|---| +| BUND | `bund.py` | [#148](https://repo.toppyr.de/tobias/gwoe-antragspruefer/issues/148) | +| BB | `bb.py` | [#149](https://repo.toppyr.de/tobias/gwoe-antragspruefer/issues/149) | +| BE | `be.py` | [#150](https://repo.toppyr.de/tobias/gwoe-antragspruefer/issues/150) | +| BW | `bw.py` | [#151](https://repo.toppyr.de/tobias/gwoe-antragspruefer/issues/151) | +| BY | `by.py` | [#152](https://repo.toppyr.de/tobias/gwoe-antragspruefer/issues/152) | +| HB | `hb.py` | [#153](https://repo.toppyr.de/tobias/gwoe-antragspruefer/issues/153) | +| HE | `he.py` | [#154](https://repo.toppyr.de/tobias/gwoe-antragspruefer/issues/154) | +| HH | `hh.py` | [#155](https://repo.toppyr.de/tobias/gwoe-antragspruefer/issues/155) | +| LSA | `lsa.py` | [#156](https://repo.toppyr.de/tobias/gwoe-antragspruefer/issues/156) | +| MV | `mv.py` | [#157](https://repo.toppyr.de/tobias/gwoe-antragspruefer/issues/157) | +| NI | `ni.py` | [#158](https://repo.toppyr.de/tobias/gwoe-antragspruefer/issues/158) | +| RP | `rp.py` | [#159](https://repo.toppyr.de/tobias/gwoe-antragspruefer/issues/159) | +| SH | `sh.py` | [#160](https://repo.toppyr.de/tobias/gwoe-antragspruefer/issues/160) | +| SL | `sl.py` | [#161](https://repo.toppyr.de/tobias/gwoe-antragspruefer/issues/161) | +| SN | `sn.py` | [#162](https://repo.toppyr.de/tobias/gwoe-antragspruefer/issues/162) | +| TH | `th.py` | [#163](https://repo.toppyr.de/tobias/gwoe-antragspruefer/issues/163) | + ## Pattern fuer neue BL 1. **Sample-PDF/HTML/XML besorgen** und Vote-Anchor-Phrasen identifizieren.