diff --git a/AGENTS.md b/AGENTS.md index 19208e9..cc54479 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -5,8 +5,8 @@ Multi-User-Webanwendung „KI-Assistenz für Spielemagazin-Redaktionen": Neuheit ## Status Kern mit Plugin-System/Auth/Migrationen fertig; `audit-log`, -`benachrichtigung` und `neuheiten` (BGG-Sync) vollständig implementiert; -übrige Plugins Stubs. +`benachrichtigung`, `neuheiten` (BGG-Sync), `dedup` und `planung` +vollständig implementiert; übrige Plugins Stubs. Live-Status: README.md → „Projekt-Fortschritt“. ## Struktur diff --git a/README.md b/README.md index dae6941..1f83c96 100644 --- a/README.md +++ b/README.md @@ -3,7 +3,8 @@ **KI-Assistenz für Spielemagazin-Redaktionen** — Multi-User-Webanwendung mit modularer Plugin-Architektur. Lauffähiger Kern mit Plugin-System, Authentifizierung/Rollen und Migrationen; vollständig implementiert sind -bisher **Audit-Log**, **Benachrichtigung** und **Neuheiten (BGG-Sync)**. +bisher **Audit-Log**, **Benachrichtigung**, **Neuheiten (BGG-Sync)**, +**Dedup-Prüfung** und **Planungsliste**. ## Stack @@ -52,6 +53,7 @@ Beim ersten Start wird automatisch ein Admin-Konto angelegt: | `SPIELE_BGG_SYNC_INTERVALL_STUNDEN` | `24` | Intervall des BGG-Syncs in Stunden (min. 1) | | `SPIELE_BGG_SUCHBEGRIFFE` | `brettspiel` | Komma-getrennte Suchbegriffe für den regelmäßigen Sync | | `SPIELE_BGG_MAX_TREFFER_PRO_SUCHE` | `25` | Obergrenze Treffer je Suchbegriff (schont das BGG-Rate-Limit) | +| `SPIELE_DEDUP_BGG_AKTIV` | `1` | BGG-Zusatzdaten für die Dedup-Prüfung an (`1`) oder aus (`0`): Alternate-Names und Erweiterungs-Relationen | ## Tests @@ -67,7 +69,12 @@ Audit-Log-Plugin (Logging-Funktion, Migration, Filter, Paginierung, Nur-Admin-Zugriff) sowie das Neuheiten-Plugin: BGG-Parsing, Erweiterungs-/ Prototyp-Filter, Rate-Limit & Retry-Backoff (gemockte HTTP-Antworten, keine echten API-Calls), Update-statt-Duplikat-Logik, UI-Suche/Filter/Sortierung, -Rollen am Sync-Endpunkt und Scheduler-Lifecycle. +Rollen am Sync-Endpunkt und Scheduler-Lifecycle. Dazu die beiden neuen +Plugins: **dedup** (Titel-Heuristik, Fuzzy-Match, alle vier Prüfungen mit +Fake-BGG-Client, Prüfprotokoll, Prüfseite) und **planung** (beide Eintragswege +mit Stub-gemockter dedup-/Benachrichtigungs-/Audit-API, Verlags-Auswahl- +Dialog, Statuswechsel, Bearbeiten/Löschen, Rechte pro Rolle) plus ein +Integrationstest mit den echten Plugins (In-App-Nachricht + Audit-Eintrag). ## Architektur @@ -85,7 +92,9 @@ plugins/ ein Ordner pro Funktion, ladbar über den Plugin-Load ├── audit-log/ VOLL IMPLEMENTIERT: Model, Migration, API, Admin-Ansicht ├── neuheiten/ VOLL IMPLEMENTIERT: BGG-Client, Sync-Job, Migration, UI ├── benachrichtigung/ VOLL IMPLEMENTIERT: E-Mail/Telegram/In-App -├── dedup/ planung/ archiv/ erinnerung/ export/ (Stubs, ladbar) +├── dedup/ VOLL IMPLEMENTIERT: check_titel-API, Heuristik, Protokoll +├── planung/ VOLL IMPLEMENTIERT: Planungsliste, Verschiebung, Dialoge +├── archiv/ erinnerung/ export/ (Stubs, ladbar) └── … je __init__.py + templates// ``` @@ -269,6 +278,91 @@ Autor, Erscheinungsjahr, Status, aktualisiert am): - Jeder Titel verlinkt direkt auf den BGG-Eintrag. - Sync-Steuerung nur für Rolle Admin/Redakteur. +## Plugin „dedup“ (implementiert) + +Dedup-Prüfungen bei Import und händigem Eintrag. Die Prüf-Logik liegt +komplett im Plugin; der Kern bleibt unberührt. + +### Öffentliche Prüf-API für andere Plugins + +```python +dedup = request.app.state.registry.get("dedup") +ergebnis = await dedup.check_titel(titel, verlag, bgg_id, user=user) +# ergebnis.hat_konflikte -> bool +# ergebnis.konflikte -> Liste TitelKonflikt (art, beschreibung, details) +# ergebnis.verlags_optionen -> Verlage zur Auswahl bei Verlags-Konflikt +# ergebnis.titel_empfehlung -> deutschester bekannter Titel +# ergebnis.als_text() -> lesbare Zusammenfassung (deutsch) +``` + +### Die vier Prüfungen + +| # | Prüfung | Mechanik | +|---|---------|----------| +| a | **Verlags-Konflikt** | Gleiches Spiel (BGG-ID oder Fuzzy-Match) bereits unter anderem Verlag/Vertrieb → Konflikt mit Verlagsauswahl | +| b | **Titel-Varianten** | Deutsche Version wird bevorzugt — Heuristik über deutsche Titel-Indikatoren (Umlaute/ß, Funktionswörter, typische Spielbegriffe) plus BGG Alternate-Names, falls verfügbar | +| c | **Bereits besprochen** | Abgeschlossene Planungseinträge bilden das Korpus; Vorgänger werden über die BGG `boardgameexpansion`-Relation erkannt und zusätzlich fuzzy auf Titel gematcht (rapidfuzz, Schwelle 85, `token_set_ratio`) | +| d | **Schon in Planung** | Titel steht bereits in der Planungsliste eines anderen Rezensenten (eigene Einträge zählen nicht) | + +Fehlt eine Partner-Tabelle (Plugin nicht geladen), entfällt die jeweilige +Teilprüfung. BGG-Störungen blockieren nie: der Hilfsclient degradiert auf +die reine Heuristik und protokolliert nur. Abschaltbar über +`SPIELE_DEDUP_BGG_AKTIV=0` (Standard: an, Rate-Limit 1 s). + +### Prüfprotokoll & Prüfseite + +Jede `check_titel`-Prüfung landet in der eigenen Migration +`0001_pruefprotokoll` (Tabelle `dedup_pruefungen`: Titel, Verlag, BGG-ID, +Befund als JSON, geprüft von, Zeitpunkt). Unter **Dedup-Prüfung** (`/dedup`) +kann jeder angemeldete Benutzer einen Titel von Hand prüfen und sieht die +letzten 20 Prüfungen. + +## Plugin „planung“ (implementiert) + +Planungsliste mit Zuordnung an Rezensenten und Ausgaben. Beide Eintragswege +laufen automatisch durch die dedup-Prüfung. + +### Datentabelle + +Eigene Migration `0001_planungsliste`, Tabelle `planungsliste`: + +| Spalte | Inhalt | +|--------|--------| +| `titel` / `verlag` / `autor` | Spieldaten | +| `bgg_id` | BoardGameGeek-ID (Match-Kriterium der dedup-Prüfung) | +| `ausgabe` | Magazin-Ausgabe, z. B. „3/2025“ (mehrere parallel möglich) | +| `rezensent_id` | Zuordnung (FK auf die Benutzer-Tabelle des Kerns) | +| `status` | `offen` → `in_bearbeitung` → `abgeschlossen` | +| `notizen` | Freitext | +| `quelle` | `neuheiten` (verschoben) oder `manuell` (nachgetragen) | +| `pruefung` | Befund der dedup-Prüfung beim Anlegen (JSON) | +| `erstellt_am` / `aktualisiert_am` | Zeitstempel | + +### Die beiden Eintragswege + +1. **Verschiebung aus der Neuheitenliste** — Button „→ Zur Planung“ in der + Neuheitenliste ruft `POST /planung/uebernehmen/` auf; der Neuheiten- + Eintrag wechselt in den Status `planung`, der Planungseintrag wird als + Quelle `neuheiten` angelegt. +2. **Händisches Nachtragen** — Formular auf der Planungsseite + (`POST /planung/neu`, Quelle `manuell`). + +Bei einem Prüftreffer erhält der eintragende Rezensent eine +**Benachrichtigung** (`send_notification` des benachrichtigung-Plugins, +Kategorie `dedup`), und es wird ein **Audit-Log-Eintrag** geschrieben +(`log` des audit-log-Plugins, Befund in `details.dedup_konflikte`). Bei +einem **Verlags-Konflikt** erscheint zuerst der Auswahl-Dialog „Welcher +Verlag soll geführt werden?“ — erst die bestätigte Wahl legt den Eintrag an; +die Entscheidung ist auditiert. + +### UI & Rechte + +Unter **Planung** (`/planung`) sieht jeder angemeldete Benutzer die komplette +Liste mit Zuordnung (Rezensent, Ausgabe, Status, Prüfhinweis-Badge). +Rezensenten können **nur ihre eigenen Einträge** bearbeiten (Statuswechsel, +Bearbeiten, Löschen); Admins und Redakteure alle. Jede Änderung wird im +Audit-Log protokolliert (`erstellt`/`verschoben`/`geaendert`/`geloescht`). + ## Deployment (später) Docker/Podman Compose ist vorgesehen (Henry-Lab, danach Kundenhardware). @@ -282,11 +376,11 @@ geschrieben. | # | Baustein | Status | |---|----------|--------| | 1 | Kern: FastAPI, Plugin-System, DB/Migrationen, Auth/Rollen, HTMX-Layout | ✅ fertig (28 Tests grün) | -| 2 | Plugin `benachrichtigung` (E-Mail/Telegram/In-App, User-Präferenzen) | 🔄 in Arbeit | +| 2 | Plugin `benachrichtigung` (E-Mail/Telegram/In-App, User-Präferenzen) | ✅ fertig | | 3 | Plugin `audit-log` (Wer/Was/Wann, Admin-Ansicht, öffentliche API) | ✅ fertig | | 4 | Plugin `neuheiten` (BGG-Sync, APScheduler, Filter) | ✅ fertig | -| 5 | Plugin `dedup` (Verlags-Konflikt, deutsche Version, Vorgänger-/Planungs-Check) | ⏳ offen | -| 6 | Plugin `planung` (Verschiebung, händischer Eintrag + Prüfungen + Benachrichtigung) | ⏳ offen | +| 5 | Plugin `dedup` (Verlags-Konflikt, deutsche Version, Vorgänger-/Planungs-Check) | ✅ fertig (141 Tests grün) | +| 6 | Plugin `planung` (Verschiebung, händischer Eintrag + Prüfungen + Benachrichtigung) | ✅ fertig (141 Tests grün) | | 7 | Plugin `archiv` (12-Monats-Autopilot) | ⏳ offen | | 8 | Plugin `erinnerung` (Redaktionsschluss pro Ausgabe, 4-Wochen-Erinnerung) | ⏳ offen | | 9 | Plugin `export` (CSV + PDF via WeasyPrint) | ⏳ offen | diff --git a/plugins/dedup/__init__.py b/plugins/dedup/__init__.py index b0be2d1..e556991 100644 --- a/plugins/dedup/__init__.py +++ b/plugins/dedup/__init__.py @@ -1,41 +1,221 @@ -"""Plugin „dedup“ — Platzhalter gemäß Plugin-Vertrag. +"""Plugin „dedup“ — Prüfungen bei Import und händischem Eintrag. -Implementiert in einer späteren Phase. Der Stub zeigt den vollen Vertrag: -eigene Route, eigenes Template, Lifecycle-Hooks, Migrations-Schnittstelle. +Öffentliche API für andere Plugins (z. B. „planung“): + + dedup = request.app.state.registry.get("dedup") + ergebnis = await dedup.check_titel(titel, verlag, bgg_id, user=user) + # ergebnis.hat_konflikte / ergebnis.konflikte / ergebnis.verlags_optionen + # ergebnis.titel_empfehlung / ergebnis.als_text() + +Die vier Prüfungen (Verlags-Konflikt, deutsche Titel-Variante, bereits +besprochen inkl. Vorgänger-Erkennung, schon in fremder Planungsliste) sind +in `pruefung.py` beschrieben. Jede Prüfung wird in der eigenen Tabelle +`dedup_pruefungen` protokolliert. + +Zusatzdaten von BoardGameGeek (Alternate-Names, Erweiterungs-Relationen) +können über SPIELE_DEDUP_BGG_AKTIV=0 abgeschaltet werden (Standard: an); +ohne Netzwerk degradiert die Prüfung automatisch auf die Heuristik. """ from __future__ import annotations -from fastapi import Depends, Request +import logging +import os -from redaktionskern.auth.deps import require_user +from fastapi import Depends, Form, Request +from sqlalchemy import select +from sqlalchemy.orm import Session + +from redaktionskern.auth.deps import get_db, require_user from redaktionskern.auth.models import User -from redaktionskern.contracts import BasePlugin, NavEntry +from redaktionskern.contracts import BasePlugin, Migration, NavEntry + +from .bgg import BggPruefClient +from .models import Pruefung +from .pruefung import KONFLIKT_ANZEIGE, PruefErgebnis, fuehre_pruefung_durch + +_logger = logging.getLogger("plugins.dedup") + +ANZAHL_PROTOKOLL = 20 + + +def _protokoll_tabelle(conn) -> None: + """Migration 0001: legt die Protokoll-Tabelle an (portabel, idempotent).""" + Pruefung.__table__.create(conn, checkfirst=True) class DedupPlugin(BasePlugin): name = "dedup" title = "Dedup-Prüfung" - description = "Prüfungen bei Import und händischem Eintrag (Platzhalter)." + description = ( + "Prüfungen bei Import und händigem Eintrag: Verlags-Konflikt, " + "Titel-Varianten (deutsche Version bevorzugt), besprochene Spiele " + "inkl. Vorgänger und fremde Planungseinträge." + ) def __init__(self) -> None: super().__init__() + self._bgg_aktiv = True + self._bgg_client: BggPruefClient | None = None + #: Von Tests überschreibbare Fabrik für den BGG-Hilfsclient. + self.bgg_client_fabrik = None - @self.router.get("/dedup") - def seite(request: Request, user: User = Depends(require_user)): - """Platzhalterseite des Plugins.""" - return self.context.templates.TemplateResponse( - request=request, - name="dedup/index.html", - context={ - "user": user, - "titel": self.title, - "name": self.name, - "version": self.version, - }, - ) + self._routen_registrieren() + + # ---------- Plugin-Vertrag ---------- + + def migrations(self) -> list[Migration]: + return [Migration(version="0001_pruefprotokoll", up=_protokoll_tabelle)] def navigation(self) -> list[NavEntry]: return [NavEntry(label=self.title, url="/dedup")] + def on_load(self, context) -> None: + super().on_load(context) + self._bgg_aktiv = os.environ.get("SPIELE_DEDUP_BGG_AKTIV", "1").strip() != "0" + + def on_unload(self) -> None: + if self._bgg_client is not None: + self._bgg_client.schliessen() + self._bgg_client = None + super().on_unload() + + # ---------- Öffentliche Prüf-API für andere Plugins ---------- + + async def check_titel( + self, + titel: str, + verlag: str | None = None, + bgg_id: int | str | None = None, + *, + user: User | None = None, + ) -> PruefErgebnis: + """Prüft einen Titel gegen Neuheiten- und Planungsliste. + + Liefert ein strukturiertes `PruefErgebnis` mit Konflikt-Details; + wirft nicht (BGG-Probleme werden protokolliert und degradieren die + Prüfung auf die Titel-Heuristik). Jede Prüfung landet im Protokoll. + """ + id_wert: int | None + try: + id_wert = int(bgg_id) if bgg_id not in (None, "") else None + except (TypeError, ValueError): + id_wert = None + + client = self._hilfsclient() + try: + ergebnis = fuehre_pruefung_durch( + self.context.session_factory, + client, + titel=titel, + verlag=verlag, + bgg_id=id_wert, + user_id=user.id if user is not None else None, + ) + finally: + if client is not None: + client.schliessen() + self._protokolliere(ergebnis, user) + return ergebnis + + # ---------- Internas ---------- + + def _hilfsclient(self) -> BggPruefClient | None: + if self.bgg_client_fabrik is not None: + return self.bgg_client_fabrik() + if not self._bgg_aktiv or self.context is None: + return None + if self._bgg_client is None: + self._bgg_client = BggPruefClient() + return self._bgg_client + + def _protokolliere(self, ergebnis: PruefErgebnis, user: User | None) -> None: + """Schreibt den Prüfbefund ins eigene Protokoll (best effort).""" + try: + with self.context.session_factory() as db: + db.add( + Pruefung( + titel=ergebnis.titel[:300], + verlag=ergebnis.verlag, + bgg_id=ergebnis.bgg_id, + konflikte=ergebnis.als_liste() or None, + geprueft_durch_id=user.id if user is not None else None, + geprueft_durch=user.username if user is not None else "System", + ) + ) + db.commit() + except Exception: + _logger.exception("dedup: Prüfung konnte nicht protokolliert werden.") + + def _seite_rendern( + self, + request: Request, + user: User, + *, + ergebnis: PruefErgebnis | None = None, + meldung: str = "", + fehler: str = "", + ): + with self.context.session_factory() as db: + protokoll = db.scalars( + select(Pruefung) + .order_by(Pruefung.erstellt_am.desc(), Pruefung.id.desc()) + .limit(ANZAHL_PROTOKOLL) + ).all() + return self.context.templates.TemplateResponse( + request=request, + name="dedup/index.html", + context={ + "user": user, + "titel": self.title, + "ergebnis": ergebnis, + "konflikt_anzeige": KONFLIKT_ANZEIGE, + "protokoll": protokoll, + "meldung": meldung[:300], + "fehler": fehler[:300], + }, + ) + + def _routen_registrieren(self) -> None: + + @self.router.get("/dedup") + def seite(request: Request, user: User = Depends(require_user)): + """Prüfseite: Manuelle Prüfung + Protokoll der letzten Prüfungen.""" + return self._seite_rendern(request, user) + + @self.router.post("/dedup/pruefen") + async def pruefen( + request: Request, + user: User = Depends(require_user), + titel: str = Form(""), + verlag: str = Form(""), + bgg_id: str = Form(""), + ): + """Führt eine manuelle Prüfung durch und zeigt das Ergebnis.""" + roh_titel = titel.strip() + if not roh_titel: + return self._seite_rendern( + request, user, fehler="Bitte einen Spieltitel angeben." + ) + try: + id_wert = int(bgg_id.strip()) if bgg_id.strip() else None + except ValueError: + return self._seite_rendern( + request, user, + fehler="Die BGG-ID muss eine Zahl sein.", + meldung="", + ) + ergebnis = await self.check_titel( + roh_titel, verlag.strip() or None, id_wert, user=user + ) + return self._seite_rendern( + request, + user, + ergebnis=ergebnis, + meldung="Prüfung abgeschlossen." + if not ergebnis.hat_konflikte + else "", + ) + + plugin = DedupPlugin() diff --git a/plugins/dedup/bgg.py b/plugins/dedup/bgg.py new file mode 100644 index 0000000..c471138 --- /dev/null +++ b/plugins/dedup/bgg.py @@ -0,0 +1,104 @@ +"""Hilfsclient des Plugins „dedup“ für die BoardGameGeek XML API2. + +Besorgt zwei Zusatzinformationen für die Prüfung: +- Alternate-Names eines Spiels (für die deutsche Titel-Empfehlung), +- die `boardgameexpansion`-Relation — welches Basisspiel eine Erweiterung + ergänzt (für die Vorgänger-Erkennung). + +Der Client ist bewusst defensiv: Fehlt das Netzwerk oder liefert BGG +Unsinn, geben die Methoden leere Listen zurück und die Prüfung fällt auf +die reine Titel-Heuristik zurück, statt den Eintrage-Vorgang zu blockieren. +Rate-Limit wie im Neuheiten-Plugin: mindestens 1 Sekunde zwischen Requests; +Uhr, Schlaf-Funktion und HTTP-Transport sind injizierbar, damit Tests +netzwerkfrei bleiben. +""" +from __future__ import annotations + +import logging +import time +import xml.etree.ElementTree as ET +from collections.abc import Callable + +import httpx + +_logger = logging.getLogger("plugins.dedup") + +BASIS_URL = "https://boardgamegeek.com/xmlapi2" + + +class BggPruefClient: + """Liest Alternate-Names und Erweiterungs-Relationen von BGG.""" + + def __init__( + self, + mindestabstand_sekunden: float = 1.0, + *, + transport: httpx.BaseTransport | None = None, + uhr: Callable[[], float] = time.monotonic, + schlafen: Callable[[float], None] = time.sleep, + timeout: float = 10.0, + ) -> None: + self._mindestabstand = max(0.0, mindestabstand_sekunden) + self._zuletzt: float | None = None + self._uhr = uhr + self._schlafen = schlafen + self._client = httpx.Client( + base_url=BASIS_URL, timeout=timeout, transport=transport + ) + + def schliessen(self) -> None: + self._client.close() + + # ---------- Internas ---------- + + def _hole(self, pfad: str, parameter: dict[str, str]) -> ET.Element | None: + """Ein GET mit Rate-Limit; bei jedem Fehler None (Prüfung degradiert).""" + if self._zuletzt is not None: + vergangen = self._uhr() - self._zuletzt + if vergangen < self._mindestabstand: + self._schlafen(self._mindestabstand - vergangen) + self._zuletzt = self._uhr() + try: + antwort = self._client.get(pfad, params=parameter) + antwort.raise_for_status() + return ET.fromstring(antwort.content) + except Exception as exc: + _logger.warning("BGG-Hilfsabruf fehlgeschlagen (%s %s): %s", pfad, parameter, exc) + return None + + # ---------- Öffentliche API ---------- + + def alternativen(self, bgg_id: int) -> list[str]: + """Alternate-Names des Spiels laut BGG (leer bei Problemen).""" + wurzel = self._hole("/thing", {"id": str(bgg_id), "type": "boardgame"}) + namen: list[str] = [] + if wurzel is None: + return namen + for element in wurzel.iter("name"): + if element.get("type") == "alternate": + wert = (element.get("value") or "").strip() + if wert: + namen.append(wert) + return namen + + def vorgaenger(self, bgg_id: int) -> list[tuple[int, str]]: + """Basisspiele, die dieses Spiel ergänzt — als (bgg_id, titel). + + Die XML API2 listet auf der Seite einer Erweiterung die Links vom + Typ `boardgameexpansion` auf das jeweils ergänzte Basisspiel. + """ + wurzel = self._hole("/thing", {"id": str(bgg_id), "type": "boardgame"}) + ergebnis: list[tuple[int, str]] = [] + if wurzel is None: + return ergebnis + for element in wurzel.iter("link"): + if element.get("type") != "boardgameexpansion": + continue + try: + fremd_id = int(element.get("id") or "") + except ValueError: + continue + titel = (element.get("value") or "").strip() + if titel: + ergebnis.append((fremd_id, titel)) + return ergebnis diff --git a/plugins/dedup/models.py b/plugins/dedup/models.py new file mode 100644 index 0000000..ccedd4a --- /dev/null +++ b/plugins/dedup/models.py @@ -0,0 +1,38 @@ +"""Datenmodell des Plugins „dedup“. + +Das Plugin speichert ein Protokoll der durchgeführten Prüfungen: wer hat +wann welchen Titel prüfen lassen und was wurde befunden. Die Fachdaten der +geprüften Spiele liegen in den Plugin-Tabellen von „neuheiten“ und +„planung“ — dedup liest diese ausschließlich lesend über die gemeinsame +SQLAlchemy-Metadata und schreibt keine fremden Tabellen. +""" +from __future__ import annotations + +from datetime import datetime + +from sqlalchemy import JSON, DateTime, Integer, String, func +from sqlalchemy.orm import Mapped, mapped_column + +from redaktionskern.db import Base + + +class Pruefung(Base): + """Protokolleintrag einer durchgeführten dedup-Prüfung.""" + + __tablename__ = "dedup_pruefungen" + __table_args__ = {"extend_existing": True} + + id: Mapped[int] = mapped_column(primary_key=True) + titel: Mapped[str] = mapped_column(String(300)) + verlag: Mapped[str | None] = mapped_column(String(300)) + bgg_id: Mapped[int | None] = mapped_column(Integer) + #: Liste von Konflikt-Dicts ({art, beschreibung, details}) oder None. + konflikte: Mapped[list | None] = mapped_column(JSON) + geprueft_durch_id: Mapped[int | None] = mapped_column(Integer) + geprueft_durch: Mapped[str] = mapped_column(String(100), default="") + erstellt_am: Mapped[datetime] = mapped_column( + DateTime, server_default=func.now() + ) + + def __repr__(self) -> str: # pragma: no cover - Debug-Hilfe + return f"" diff --git a/plugins/dedup/pruefung.py b/plugins/dedup/pruefung.py new file mode 100644 index 0000000..bd33369 --- /dev/null +++ b/plugins/dedup/pruefung.py @@ -0,0 +1,413 @@ +"""Prüflogik des Plugins „dedup“ — die vier Prüfungen laut Fachanforderung: + +a) **Verlags-Konflikt** — dasselbe Spiel ist bereits unter anderem + Verlag/Vertrieb geführt. Ergebnis enthält eine Verlagsauswahl. +b) **Titel-Varianten** — dasselbe Spiel mit unterschiedlichem Titel; die + deutsche Version wird bevorzugt (Heuristik über deutsche Titel-Indikatoren, + ergänzt um BGG Alternate-Names, falls ein Hilfsclient verfügbar ist). +c) **Spiel oder Vorgänger bereits besprochen** — abgeschlossene Einträge der + Planungsliste bilden das „besprochen“-Korpus; Vorgänger werden über die + BGG `boardgameexpansion`-Relation erkannt und zusätzlich fuzzy auf Titel + gematcht (rapidfuzz). +d) **Titel schon in Planungsliste eines anderen Rezensenten.** + +Die Daten der anderen Plugins (neuheiten, planung) liest dieses Plugin +lesend über die gemeinsame SQLAlchemy-Metadata (`Base.metadata.tables`) — +so entstehen keine Import-Abhängigkeiten zwischen Plugin-Paketen. Fehlt eine +Tabelle (Plugin nicht geladen), entfällt die jeweilige Teilprüfung einfach. +""" +from __future__ import annotations + +import logging +import re +import unicodedata +from collections.abc import Iterable +from dataclasses import dataclass, field + +from sqlalchemy import select +from sqlalchemy.exc import SQLAlchemyError + +from redaktionskern.db import Base + +try: + from rapidfuzz import fuzz +except ImportError: # pragma: no cover - rapidfuzz ist eine harte Abhängigkeit + fuzz = None + +_logger = logging.getLogger("plugins.dedup") + +#: Fuzzy-Schwelle für „gemeintes Spiel“ (rapidfuzz token_sort_ratio 0–100). +TITEL_SCHWELLE = 85 + +#: Statuswert des planung-Plugins für „bereits besprochen“ (bewusst als +#: Literal, damit keine Import-Abhängigkeit zwischen den Plugins entsteht). +STATUS_ABGESCHLOSSEN = "abgeschlossen" + +#: Funktionswörter, die stark auf einen deutschen Spieltitel hindeuten. +DEUTSCHE_INDIKATOREN = frozenset({ + "der", "die", "das", "den", "dem", "des", + "ein", "eine", "einen", "einem", "einer", "eines", + "und", "für", "von", "vom", "zu", "zum", "zur", + "im", "am", "beim", "auf", "mit", "aus", +}) + +#: Typische Begriffe deutscher Spieltitel (+2 Punkte je Treffer). +DEUTSCHE_SPIELWOERTER = frozenset({ + "abenteuer", "berg", "blitz", "burg", "dorf", "drache", "drachen", + "erde", "feuer", "gärten", "haus", "himmel", "insel", "jagd", + "kaiser", "könig", "könige", "königreich", "land", "länder", + "meister", "mond", "norden", "osten", "pfad", "reich", "ritter", + "schiff", "schloss", "see", "spiel", "spiele", "spielen", + "stadt", "stern", "süden", "turm", "wald", "weg", "welt", + "westen", "wiese", "wilder", "wüste", "zauber", "zeit", +}) + +#: Wörter, die auf einen englischen Titeltitel hindeuten (−1 Punkt je Treffer). +ENGLISCHE_INDIKATOREN = frozenset({ + "the", "of", "and", "game", "games", "card", "cards", "dice", "board", +}) + +_UM_LAUTE = frozenset("äöüßÄÖÜ") +_WORT_MUSTER = re.compile(r"[^\W\d_]+", re.UNICODE) + + +# ---------------- Titel-Heuristik ---------------- + +def normalisiere(text: str) -> str: + """Vereinheitlicht einen Titel für Vergleiche (Groß-/Satzzeichen egal).""" + text = unicodedata.normalize("NFC", text or "") + text = text.casefold() + text = re.sub(r"[^\w\s]+", " ", text, flags=re.UNICODE) + return re.sub(r"\s+", " ", text).strip() + + +def titel_aehnlich(a: str, b: str, schwelle: int = TITEL_SCHWELLE) -> bool: + """True, wenn zwei Titel dasselbe Spiel meinen (exakt oder fuzzy). + + Nach der Normalisierung zählt `fuzz.token_set_ratio`: Wortreihenfolge + und Füllwörter sind egal, damit „Die Siedler von Catan“ und + „Siedler von Catan, Die“ zusammenpassen, „Catan Erweiterung“ und + „Catan Grundspiel“ aber nicht. + """ + if not a or not b: + return False + na, nb = normalisiere(a), normalisiere(b) + if not na or not nb: + return False + if na == nb: + return True + if fuzz is None: # pragma: no cover + return False + return fuzz.token_set_ratio(na, nb) >= schwelle + + +def deutsch_score(titel: str) -> int: + """Heuristik-Score: > 0 spricht für einen deutschen Titel. + + Umlaute/ß zählen am stärksten (+3), deutsche Funktionswörter +1, + typische deutsche Spielbegriffe +2, englische Indikatoren −1. + """ + if not titel: + return 0 + score = 0 + if any(zeichen in _UM_LAUTE for zeichen in titel): + score += 3 + woerter = {wort.casefold() for wort in _WORT_MUSTER.findall(titel)} + score += sum(1 for wort in woerter if wort in DEUTSCHE_INDIKATOREN) + score += sum(2 for wort in woerter if wort in DEUTSCHE_SPIELWOERTER) + score -= sum(1 for wort in woerter if wort in ENGLISCHE_INDIKATOREN) + return score + + +def ist_deutscher_titel(titel: str) -> bool: + return deutsch_score(titel) > 0 + + +def bevorzuge_deutschen_titel(kandidaten: Iterable[str]) -> str | None: + """Wählt aus Kandidaten den deutschesten Titel (bei Gleichstand den ersten).""" + bester: str | None = None + bester_score = 0 + for kandidat in kandidaten: + kandidat = (kandidat or "").strip() + if not kandidat: + continue + score = deutsch_score(kandidat) + if bester is None or score > bester_score: + bester, bester_score = kandidat, score + return bester + + +def _verlags_schluessel(verlag: str) -> str: + """Vergleichsschlüssel für Verlage („Kosmos“ == „kosmos “).""" + return normalisiere(verlag) + + +# ---------------- Prüfergebnis ---------------- + +#: Anzeigenamen der Konflikt-Arten (deutsche UI). +KONFLIKT_ANZEIGE: dict[str, str] = { + "verlag": "Verlags-Konflikt", + "titel": "Titel-Variante", + "besprochen": "Bereits besprochen", + "planung": "Schon in Planung", +} + + +@dataclass(frozen=True) +class TitelKonflikt: + """Ein einzelner Befund der Prüfung.""" + + art: str # Schlüssel aus KONFLIKT_ANZEIGE + beschreibung: str + details: dict = field(default_factory=dict) + + def als_dict(self) -> dict: + return {"art": self.art, "beschreibung": self.beschreibung, "details": self.details} + + @property + def anzeige(self) -> str: + return KONFLIKT_ANZEIGE.get(self.art, self.art) + + +@dataclass +class PruefErgebnis: + """Strukturiertes Ergebnis einer dedup-Prüfung.""" + + titel: str + verlag: str | None = None + bgg_id: int | None = None + konflikte: list[TitelKonflikt] = field(default_factory=list) + #: Verlage zur Auswahl bei einem Verlags-Konflikt (welcher wird geführt?). + verlags_optionen: list[str] = field(default_factory=list) + #: Empfohlener (deutschester) Titel, falls Titel-Varianten bekannt sind. + titel_empfehlung: str | None = None + + @classmethod + def ohne_befund(cls, titel: str, verlag: str | None = None, bgg_id: int | None = None): + return cls(titel=titel, verlag=verlag, bgg_id=bgg_id) + + @property + def hat_konflikte(self) -> bool: + return bool(self.konflikte) + + @property + def hat_verlagskonflikt(self) -> bool: + return any(konflikt.art == "verlag" for konflikt in self.konflikte) + + def als_liste(self) -> list[dict]: + return [konflikt.als_dict() for konflikt in self.konflikte] + + def als_text(self) -> str: + if not self.konflikte: + return "Keine Treffer." + zeilen = [f"• [{k.anzeige}] {k.beschreibung}" for k in self.konflikte] + if ( + self.titel_empfehlung + and normalisiere(self.titel_empfehlung) != normalisiere(self.titel) + ): + zeilen.append(f"• Empfohlener Titel: „{self.titel_empfehlung}“") + return "\n".join(zeilen) + + +# ---------------- Datenzugriff (fremde Plugin-Tabellen, nur lesend) ---------------- + +def _lade_zeilen(db, tabellenname: str, spalten: tuple[str, ...]) -> list[dict]: + """Liest Zeilen einer Plugin-Tabelle über die gemeinsame Metadata. + + Fehlt die Tabelle (Plugin nicht geladen bzw. Migration nicht gelaufen), + wird eine leere Liste zurückgegeben — die jeweilige Teilprüfung entfällt. + """ + tabelle = Base.metadata.tables.get(tabellenname) + if tabelle is None: + return [] + try: + zeilen = db.execute(select(*(tabelle.c[name] for name in spalten))).all() + except SQLAlchemyError as exc: + _logger.warning("dedup: Tabelle '%s' nicht lesbar (%s) — Teilprüfung übersprungen.", tabellenname, exc) + return [] + return [dict(zip(spalten, zeile._tuple())) for zeile in zeilen] + + +def _lade_benutzernamen(db) -> dict[int, str]: + benutzer = Base.metadata.tables.get("users") + namen: dict[int, str] = {} + if benutzer is None: + return namen + try: + for zeile in db.execute( + select(benutzer.c.id, benutzer.c.display_name, benutzer.c.username) + ).all(): + id_wert, anzeige, username = zeile._tuple() + namen[id_wert] = anzeige or username or f"Benutzer {id_wert}" + except SQLAlchemyError: # pragma: no cover - defensive + pass + return namen + + +def _rezensent_name(zeile: dict, namen: dict[int, str]) -> str: + id_wert = zeile.get("rezensent_id") + if id_wert is None: + return "unbekannt" + return namen.get(id_wert, f"Benutzer {id_wert}") + + +def _gleiches_spiel(zeile: dict, titel: str, bgg_id: int | None) -> bool: + """Match über eindeutige BGG-ID, sonst fuzzy über den Titel.""" + fremd_bgg = zeile.get("bgg_id") + if bgg_id is not None and fremd_bgg is not None and int(fremd_bgg) == int(bgg_id): + return True + return titel_aehnlich(titel, zeile.get("titel") or "") + + +# ---------------- Hauptprüfung ---------------- + +def fuehre_pruefung_durch( + session_factory, + bgg_hilfsclient, + *, + titel: str, + verlag: str | None = None, + bgg_id: int | None = None, + user_id: int | None = None, +) -> PruefErgebnis: + """Führt alle vier Prüfungen durch und liefert ein PruefErgebnis. + + `bgg_hilfsclient` darf None sein (BGG-Zusatzdaten deaktiviert) — dann + entfallen Alternate-Names und Vorgänger-Relationen, die Heuristik und + der Fuzzy-Match arbeiten weiter. + `user_id` ist der Eintragende: eigene Planungseinträge lösen keinen + „schon in Planung“-Konflikt aus. + """ + titel = (titel or "").strip() + verlag = (verlag or "").strip() or None + id_wert = int(bgg_id) if bgg_id else None + ergebnis = PruefErgebnis.ohne_befund(titel, verlag, id_wert) + if not titel: + return ergebnis + + with session_factory() as db: + neuheiten = _lade_zeilen(db, "neuheiten", ("id", "titel", "verlag", "bgg_id")) + planungen = _lade_zeilen( + db, "planungsliste", ("id", "titel", "verlag", "bgg_id", "status", "rezensent_id") + ) + namen = _lade_benutzernamen(db) + + alternativen: list[str] = [] + vorgaenger: list[tuple[int, str]] = [] + if id_wert is not None and bgg_hilfsclient is not None: + try: + alternativen = list(bgg_hilfsclient.alternativen(id_wert)) + except Exception as exc: # Zusatzdaten dürfen die Prüfung nie blockieren + _logger.warning("dedup: BGG-Alternativen nicht verfügbar (%s)", exc) + try: + vorgaenger = list(bgg_hilfsclient.vorgaenger(id_wert)) + except Exception as exc: + _logger.warning("dedup: BGG-Vorgänger nicht verfügbar (%s)", exc) + + # Kandidaten = Einträge zum selben Spiel (Neuheiten + Planungsliste). + kandidaten = [ + zeile for zeile in (*neuheiten, *planungen) + if _gleiches_spiel(zeile, titel, id_wert) + ] + + # a) Verlags-Konflikt: gleiches Spiel unter anderem Verlag/Vertrieb. + bekannte_verlage: dict[str, str] = {} + for zeile in kandidaten: + kandidat_verlag = (zeile.get("verlag") or "").strip() + if kandidat_verlag: + bekannte_verlage.setdefault(_verlags_schluessel(kandidat_verlag), kandidat_verlag) + abweichend = [ + name for schluessel, name in bekannte_verlage.items() + if verlag and schluessel != _verlags_schluessel(verlag) + ] + if abweichend or len(bekannte_verlage) > 1: + optionen = list(bekannte_verlage.values()) + if verlag and _verlags_schluessel(verlag) not in bekannte_verlage: + optionen.append(verlag) + ergebnis.verlags_optionen = optionen + ergebnis.konflikte.append(TitelKonflikt( + art="verlag", + beschreibung=( + "Gleiches Spiel ist bereits unter anderem Verlag geführt: " + + ", ".join(sorted(bekannte_verlage.values())) + + ". Bitte wählen, welcher Verlag geführt wird." + ), + details={"eigener_verlag": verlag, "bekannte_verlage": list(bekannte_verlage.values())}, + )) + + # b) Titel-Varianten → deutsche Version bevorzugen. + varianten = [ + zeile["titel"] for zeile in kandidaten + if normalisiere(zeile.get("titel") or "") != normalisiere(titel) + ] + ergebnis.titel_empfehlung = bevorzuge_deutschen_titel( + [titel, *varianten, *alternativen] + ) + if varianten and ergebnis.titel_empfehlung \ + and normalisiere(ergebnis.titel_empfehlung) != normalisiere(titel): + ergebnis.konflikte.append(TitelKonflikt( + art="titel", + beschreibung=( + f"Gleiches Spiel unter anderem Titel bekannt — empfohlen: " + f"„{ergebnis.titel_empfehlung}“." + ), + details={ + "empfehlung": ergebnis.titel_empfehlung, + "varianten": sorted(set(varianten)), + "bgg_alternativen": alternativen[:10], + }, + )) + + # c) Spiel oder Vorgänger bereits besprochen (Planungsstatus „abgeschlossen“). + besprochen = [z for z in planungen if z.get("status") == STATUS_ABGESCHLOSSEN] + for zeile in besprochen: + if _gleiches_spiel(zeile, titel, id_wert): + wer = _rezensent_name(zeile, namen) + ergebnis.konflikte.append(TitelKonflikt( + art="besprochen", + beschreibung=f"„{zeile['titel']}“ wurde bereits besprochen ({wer}).", + details={"planungseintrag": zeile["id"], "titel": zeile["titel"], "rezensent": wer}, + )) + for fremd_id, fremd_titel in vorgaenger: + for zeile in besprochen: + zeilen_bgg = zeile.get("bgg_id") + passt = ( + (fremd_id and zeilen_bgg is not None and int(zeilen_bgg) == fremd_id) + or titel_aehnlich(fremd_titel, zeile.get("titel") or "") + ) + if passt: + wer = _rezensent_name(zeile, namen) + ergebnis.konflikte.append(TitelKonflikt( + art="besprochen", + beschreibung=( + f"Vorgänger „{fremd_titel}“ wurde bereits besprochen ({wer}) — " + "Erweiterung prüfen, ob sie noch Redaktionsstoff bietet." + ), + details={ + "vorgaenger_bgg_id": fremd_id, + "vorgaenger_titel": fremd_titel, + "planungseintrag": zeile["id"], + }, + )) + + # d) Titel schon in der Planungsliste eines anderen Rezensenten. + for zeile in planungen: + if user_id is not None and zeile.get("rezensent_id") == user_id: + continue + if _gleiches_spiel(zeile, titel, id_wert): + wer = _rezensent_name(zeile, namen) + status = zeile.get("status") or "" + ergebnis.konflikte.append(TitelKonflikt( + art="planung", + beschreibung=( + f"„{zeile['titel']}“ ist bereits in der Planungsliste " + f"von {wer} (Status: {status})." + ), + details={ + "planungseintrag": zeile["id"], + "rezensent": wer, + "status": status, + }, + )) + + return ergebnis diff --git a/plugins/dedup/templates/dedup/index.html b/plugins/dedup/templates/dedup/index.html index cc09663..9b0edb9 100644 --- a/plugins/dedup/templates/dedup/index.html +++ b/plugins/dedup/templates/dedup/index.html @@ -2,9 +2,121 @@ {% block titel %}{{ titel }} — Spiele-Redaktion{% endblock %} {% block inhalt %}

{{ titel }}

-

- Plugin {{ name }} - in Version {{ version }} ist geladen. - Diese Seite ist ein Platzhalter — die Funktion wird in einer späteren Phase implementiert. +

+ Die Prüfung läuft automatisch bei jeder Eintragung in die Planungsliste. + Hier kann sie auch von Hand für einen Titel ausgeführt werden.

+ +
+
+

🏚 Verlags-Konflikt

+

Gleiches Spiel bei verschiedenen Verlagen/Vertrieb → Verlagsauswahl.

+
+
+

🇧 Titel-Varianten

+

Deutsche Version wird bevorzugt (Heuristik + BGG Alternate-Names).

+
+
+

📖 Bereits besprochen

+

Spiel oder Vorgänger (BGG-Erweiterungs-Relation + Fuzzy-Match) schon in der Redaktion.

+
+
+

📋 Schon in Planung

+

Titel steht bereits in der Planungsliste eines anderen Rezensenten.

+
+
+ +
+

Titel prüfen

+
+
+ + +
+
+ + +
+
+ + +
+ +
+ + {% if fehler %} +
{{ fehler }}
+ {% endif %} + {% if meldung %} +
{{ meldung }}
+ {% endif %} + + {% if ergebnis %} +
+

+ {% if ergebnis.hat_konflikte %}⚠ {{ ergebnis.konflikte|length }} Treffer für „{{ ergebnis.titel }}“{% else %}✓ Keine Treffer für „{{ ergebnis.titel }}“{% endif %} +

+
    + {% for konflikt in ergebnis.konflikte %} +
  • + {{ konflikt.anzeige }} + {{ konflikt.beschreibung }} +
    • + {% endfor %} +
+ {% if ergebnis.titel_empfehlung and ergebnis.titel_empfehlung != ergebnis.titel %} +

Empfohlener Titel: {{ ergebnis.titel_empfehlung }}

+ {% endif %} +
+ {% endif %} +
+ +
+

Letzte Prüfungen

+ + + + + + + + + + + + + {% for pruefung in protokoll %} + + + + + + + + + {% else %} + + {% endfor %} + +
ZeitpunktTitelVerlagBGG-IDGeprüft vonBefund
{{ pruefung.erstellt_am.strftime('%d.%m.%Y %H:%M') if pruefung.erstellt_am else '—' }}{{ pruefung.titel }}{{ pruefung.verlag or '—' }}{{ pruefung.bgg_id or '—' }}{{ pruefung.geprueft_durch or '—' }} + {% if pruefung.konflikte %} + {% for konflikt in pruefung.konflikte %} + {{ konflikt_anzeige.get(konflikt.art, konflikt.art) }} + {% endfor %} + {% else %} + Keine Treffer + {% endif %} +
Noch keine Prüfungen durchgeführt.
+
{% endblock %} diff --git a/plugins/neuheiten/__init__.py b/plugins/neuheiten/__init__.py index 5cb39c2..3c683e3 100644 --- a/plugins/neuheiten/__init__.py +++ b/plugins/neuheiten/__init__.py @@ -80,6 +80,7 @@ class NeuheitenPlugin(BasePlugin): sort: str = STANDARD_SORTIERUNG[0], richtung: str = STANDARD_SORTIERUNG[1], meldung: str = "", + fehler: str = "", ): spalte = SORTIERBAR.get(sort, SORTIERBAR[STANDARD_SORTIERUNG[0]]) abwaerts = richtung == "ab" if sort in SORTIERBAR else False @@ -117,6 +118,7 @@ class NeuheitenPlugin(BasePlugin): "richtung": "ab" if abwaerts else "auf", "status_optionen": status_optionen, "meldung": meldung[:MAX_MELDUNGS_LAENGE], + "fehler": fehler[:MAX_MELDUNGS_LAENGE], "ist_redaktion": user.role in ( Role.ADMIN.value, Role.REDAKTEUR.value, diff --git a/plugins/neuheiten/templates/neuheiten/_liste.html b/plugins/neuheiten/templates/neuheiten/_liste.html index 685bf2f..89107c7 100644 --- a/plugins/neuheiten/templates/neuheiten/_liste.html +++ b/plugins/neuheiten/templates/neuheiten/_liste.html @@ -15,6 +15,7 @@ {% endif %} {% endfor %} + Aktion @@ -34,10 +35,18 @@ {{ eintrag.aktualisiert_am.strftime('%d.%m.%Y %H:%M') if eintrag.aktualisiert_am else '—' }} + + {% if eintrag.status == 'neuheit' %} +
+ +
+ {% endif %} + {% else %} - + Keine Einträge gefunden. {% if ist_redaktion %}Nutze „Jetzt synchronisieren“, um die Liste aus BoardGameGeek zu befüllen.{% endif %} diff --git a/plugins/neuheiten/templates/neuheiten/index.html b/plugins/neuheiten/templates/neuheiten/index.html index a27ad2a..af500f0 100644 --- a/plugins/neuheiten/templates/neuheiten/index.html +++ b/plugins/neuheiten/templates/neuheiten/index.html @@ -14,6 +14,9 @@ {{ meldung }} {% endif %} +{% if fehler %} +
{{ fehler }}
+{% endif %}
{% if ist_redaktion %} diff --git a/plugins/planung/__init__.py b/plugins/planung/__init__.py index 1d1c883..4354381 100644 --- a/plugins/planung/__init__.py +++ b/plugins/planung/__init__.py @@ -1,41 +1,529 @@ -"""Plugin „planung“ — Platzhalter gemäß Plugin-Vertrag. +"""Plugin „planung“ — Planungsliste mit Zuordnung an Rezensenten. -Implementiert in einer späteren Phase. Der Stub zeigt den vollen Vertrag: -eigene Route, eigenes Template, Lifecycle-Hooks, Migrations-Schnittstelle. +Zwei Eintragswege, beide laufen automatisch durch die dedup-Prüfung des +dedup-Plugins: + +1. **Verschiebung aus der Neuheitenliste** — Button „Zur Planung“ in der + Neuheitenliste ruft `POST /planung/uebernehmen/` auf; der + Neuheiten-Eintrag wechselt dabei in den Status „planung“. +2. **Händisches Nachtragen** über das Formular auf `/planung`. + +Bei einem Prüftreffer wird eine Benachrichtigung an den eintragenden +Rezensenten verschickt (Plugin „benachrichtigung“, `send_notification`) +und ein Audit-Log-Eintrag geschrieben (Plugin „audit-log“, `log`). Bei +einem Verlags-Konflikt erscheint zuerst ein Auswahl-Dialog, welcher Verlag +geführt wird; erst nach der Bestätigung wird der Eintrag angelegt. + +Rezensenten sehen die komplette Liste (mit Zuordnung), dürfen aber nur +ihre eigenen Einträge bearbeiten; Admins und Redakteure alle. + +Beide Partner-Plugins werden über die Registry geholt (`registry.get(...)`); +fehlen sie, entfallen Benachrichtigung/Audit bzw. die Prüfung, ohne dass +der Eintrage-Vorgang bricht. """ from __future__ import annotations -from fastapi import Depends, Request +import logging +from urllib.parse import quote -from redaktionskern.auth.deps import require_user -from redaktionskern.auth.models import User -from redaktionskern.contracts import BasePlugin, NavEntry +from fastapi import Depends, Form, Request +from fastapi.responses import RedirectResponse +from sqlalchemy import select, update +from sqlalchemy.orm import Session + +from redaktionskern.auth.deps import AccessDenied, get_db, require_user +from redaktionskern.auth.models import Role, User +from redaktionskern.contracts import BasePlugin, Migration, NavEntry +from redaktionskern.db import Base + +from .models import ( + GUELTIGE_STATUS, + STATUS_ANZEIGE, + Planungseintrag, +) + +_logger = logging.getLogger("plugins.planung") + +REDAKTION = (Role.ADMIN.value, Role.REDAKTEUR.value) + +#: Konflikt-Anzeigenamen für UI/Benachrichtigung (bewusst als Kopie ohne +#: Import-Abhängigkeit zum dedup-Plugin). +KONFLIKT_ANZEIGE = { + "verlag": "Verlags-Konflikt", + "titel": "Titel-Variante", + "besprochen": "Bereits besprochen", + "planung": "Schon in Planung", +} + + +def _planungs_tabelle(conn) -> None: + """Migration 0001: legt die Tabelle `planungsliste` an.""" + Planungseintrag.__table__.create(conn, checkfirst=True) + + +def _neuheiten_tabelle(): + """Neuheiten-Tabelle über die gemeinsame Metadata (nur lesend/schreibend + auf den Status — kein Import des neuheiten-Pakets nötig).""" + return Base.metadata.tables.get("neuheiten") class PlanungPlugin(BasePlugin): name = "planung" title = "Planung" - description = "Planungsliste mit Zuordnung an Rezensenten (Platzhalter)." + description = ( + "Planungsliste mit Zuordnung an Rezensenten — Verschiebung aus den " + "Neuheiten und händisches Nachtragen, automatisch durch die " + "dedup-Prüfung." + ) def __init__(self) -> None: super().__init__() + self._routen_registrieren() + + # ---------- Plugin-Vertrag ---------- + + def migrations(self) -> list[Migration]: + return [Migration(version="0001_planungsliste", up=_planungs_tabelle)] + + def navigation(self) -> list[NavEntry]: + return [NavEntry(label=self.title, url="/planung")] + + # ---------- Hilfsfunktionen ---------- + + @staticmethod + def _darf_bearbeiten(user: User, eintrag: Planungseintrag) -> bool: + return user.role in REDAKTION or eintrag.rezensent_id == user.id + + @classmethod + def _pruefe_bearbeitbar(cls, user: User, eintrag: Planungseintrag) -> None: + if not cls._darf_bearbeiten(user, eintrag): + raise AccessDenied( + "Rezensenten dürfen nur ihre eigenen Planungseinträge ändern." + ) + + @staticmethod + def _hole_dedup(request: Request): + return request.app.state.registry.get("dedup") + + @staticmethod + async def _benachrichtige( + request: Request, user: User, titel: str, ergebnis + ) -> None: + """Versendet bei Prüftreffern eine Nachricht an den Eintragenden.""" + benachrichtigung = request.app.state.registry.get("benachrichtigung") + if benachrichtigung is None: + return + zeilen = [ + f"Die Dedup-Prüfung für „{titel}“ hat {len(ergebnis.konflikte)} Treffer:" + ] + for konflikt in ergebnis.konflikte: + anzeige = KONFLIKT_ANZEIGE.get(konflikt.art, konflikt.art) + zeilen.append(f"• [{anzeige}] {konflikt.beschreibung}") + try: + await benachrichtigung.send_notification( + user, + f"Dedup-Hinweis: {titel}", + "\n".join(zeilen), + "dedup", + ) + except Exception: + # Eine fehlgeschlagene Benachrichtigung darf den Eintrag nicht blockieren. + _logger.exception("Benachrichtigung über Dedup-Treffer fehlgeschlagen.") + + @staticmethod + async def _audit( + request: Request, + actor, + action: str, + objekt_id, + details: dict | None = None, + ) -> None: + """Schreibt einen Audit-Log-Eintrag (best effort, wenn Plugin geladen).""" + audit = request.app.state.registry.get("audit-log") + if audit is None: + return + try: + await audit.log(actor, action, "planungseintrag", objekt_id, details) + except Exception: + _logger.exception("Audit-Log-Eintrag für Planung fehlgeschlagen.") + + @staticmethod + def _meldung(url: str, text: str, art: str = "meldung") -> RedirectResponse: + return RedirectResponse(f"{url}?{art}={quote(text)}", status_code=303) + + def _dialog_antwort( + self, + request: Request, + user: User, + *, + titel: str, + ergebnis, + aktion: str, + versteckt: dict[str, str], + abbrechen_url: str = "/planung", + ): + """Auswahl-Dialog bei Verlags-Konflikt: Welcher Verlag wird geführt?""" + return self.context.templates.TemplateResponse( + request=request, + name="planung/pruefung.html", + context={ + "user": user, + "titel_headline": f"Dedup-Prüfung — {titel}", + "spiel_titel": titel, + "konflikte": ergebnis.konflikte, + "konflikt_anzeige": KONFLIKT_ANZEIGE, + "titel_empfehlung": ergebnis.titel_empfehlung, + "verlags_optionen": ergebnis.verlags_optionen, + "aktion": aktion, + "versteckt": versteckt, + "abbrechen_url": abbrechen_url, + }, + ) + + # ---------- Routen ---------- + + def _routen_registrieren(self) -> None: @self.router.get("/planung") - def seite(request: Request, user: User = Depends(require_user)): - """Platzhalterseite des Plugins.""" + def liste( + request: Request, + db: Session = Depends(get_db), + user: User = Depends(require_user), + status: str = "", + meldung: str = "", + fehler: str = "", + ): + """Planungsliste: alle Einträge mit Zuordnung und Statuswechsel.""" + abfrage = select(Planungseintrag) + if status in GUELTIGE_STATUS: + abfrage = abfrage.where(Planungseintrag.status == status) + eintraege = db.scalars( + abfrage.order_by( + Planungseintrag.aktualisiert_am.desc(), Planungseintrag.id.desc() + ) + ).all() + namen = { + benutzer.id: (benutzer.display_name or benutzer.username) + for benutzer in db.scalars(select(User)).all() + } return self.context.templates.TemplateResponse( request=request, name="planung/index.html", context={ "user": user, "titel": self.title, - "name": self.name, - "version": self.version, + "eintraege": eintraege, + "namen": namen, + "status_anzeige": STATUS_ANZEIGE, + "status_filter": status if status in GUELTIGE_STATUS else "", + "status_optionen": GUELTIGE_STATUS, + "kann_bearbeiten": lambda eintrag: self._darf_bearbeiten(user, eintrag), + "ist_redaktion": user.role in REDAKTION, + "meldung": meldung[:300], + "fehler": fehler[:300], + "anzahl": len(eintraege), }, ) - def navigation(self) -> list[NavEntry]: - return [NavEntry(label=self.title, url="/planung")] + @self.router.post("/planung/neu") + async def neu_anlegen( + request: Request, + db: Session = Depends(get_db), + user: User = Depends(require_user), + titel: str = Form(""), + verlag: str = Form(""), + ausgabe: str = Form(""), + bgg_id: str = Form(""), + verlag_wahl: str = Form(""), + verlag_bestaetigt: str = Form(""), + ): + """Händisches Nachtragen eines Titels (durchläuft die dedup-Prüfung).""" + roh_titel = titel.strip() + if not roh_titel: + return self._meldung("/planung", "Bitte einen Spieltitel angeben.", "fehler") + try: + id_wert = int(bgg_id.strip()) if bgg_id.strip() else None + except ValueError: + return self._meldung("/planung", "Die BGG-ID muss eine Zahl sein.", "fehler") + + dedup = self._hole_dedup(request) + ergebnis = ( + await dedup.check_titel(roh_titel, verlag.strip() or None, id_wert, user=user) + if dedup is not None + else None + ) + hat_verlagskonflikt = bool(ergebnis and ergebnis.hat_verlagskonflikt) + + # Verlags-Konflikt → Auswahl-Dialog statt sofortigem Anlegen. + if hat_verlagskonflikt and verlag_bestaetigt != "1": + return self._dialog_antwort( + request, + user, + titel=roh_titel, + ergebnis=ergebnis, + aktion="/planung/neu", + versteckt={ + "titel": roh_titel, + "ausgabe": ausgabe.strip(), + "bgg_id": bgg_id.strip(), + "verlag_bestaetigt": "1", + }, + ) + + gewaehlter_verlag = (verlag_wahl.strip() or verlag.strip()) or None + eintrag = Planungseintrag( + titel=roh_titel, + verlag=gewaehlter_verlag, + ausgabe=ausgabe.strip(), + bgg_id=id_wert, + rezensent_id=user.id, + status="offen", + quelle="manuell", + pruefung=(ergebnis.als_liste() or None) if ergebnis is not None else None, + ) + db.add(eintrag) + db.commit() + + details = { + "titel": eintrag.titel, + "verlag": eintrag.verlag, + "ausgabe": eintrag.ausgabe, + "quelle": eintrag.quelle, + "rezensent_id": eintrag.rezensent_id, + } + if ergebnis is not None and ergebnis.hat_konflikte: + details["dedup_konflikte"] = ergebnis.als_liste() + await self._audit(request, user, "erstellt", eintrag.id, details) + + if ergebnis is not None and ergebnis.hat_konflikte: + await self._benachrichtige(request, user, eintrag.titel, ergebnis) + meldung = ( + f"„{eintrag.titel}“ wurde eingetragen. Die Dedup-Prüfung hatte " + "Treffer — du hast eine Benachrichtigung erhalten." + ) + else: + meldung = f"„{eintrag.titel}“ wurde eingetragen." + return self._meldung("/planung", meldung) + + @self.router.post("/planung/uebernehmen/{neuheit_id}") + async def uebernehmen( + request: Request, + neuheit_id: int, + db: Session = Depends(get_db), + user: User = Depends(require_user), + verlag_wahl: str = Form(""), + verlag_bestaetigt: str = Form(""), + ): + """Verschiebung Neuheiten → Planung (durchläuft die dedup-Prüfung).""" + tabelle = _neuheiten_tabelle() + if tabelle is None: + return self._meldung( + "/planung", + "Neuheitenliste nicht verfügbar — Verschiebung nicht möglich.", + "fehler", + ) + zeile = db.execute( + select(tabelle).where(tabelle.c.id == neuheit_id) + ).first() + if zeile is None: + return self._meldung( + "/neuheiten", "Dieser Neuheiten-Eintrag existiert nicht mehr.", "fehler" + ) + if zeile.status != "neuheit": + return self._meldung( + "/neuheiten", + f"„{zeile.titel}“ ist nicht mehr als Neuheit verfügbar.", + "fehler", + ) + + dedup = self._hole_dedup(request) + ergebnis = ( + await dedup.check_titel(zeile.titel, zeile.verlag, zeile.bgg_id, user=user) + if dedup is not None + else None + ) + hat_verlagskonflikt = bool(ergebnis and ergebnis.hat_verlagskonflikt) + + # Verlags-Konflikt → Auswahl-Dialog statt sofortiger Übernahme. + if hat_verlagskonflikt and verlag_bestaetigt != "1": + return self._dialog_antwort( + request, + user, + titel=zeile.titel, + ergebnis=ergebnis, + aktion=f"/planung/uebernehmen/{neuheit_id}", + versteckt={"neuheit_id": str(neuheit_id), "verlag_bestaetigt": "1"}, + abbrechen_url="/neuheiten", + ) + + gewaehlter_verlag = (verlag_wahl.strip() or (zeile.verlag or "")) or None + eintrag = Planungseintrag( + titel=zeile.titel, + verlag=gewaehlter_verlag, + autor=zeile.autor, + bgg_id=zeile.bgg_id, + ausgabe="", + rezensent_id=user.id, + status="offen", + quelle="neuheiten", + pruefung=(ergebnis.als_liste() or None) if ergebnis is not None else None, + ) + db.add(eintrag) + db.execute( + update(tabelle) + .where(tabelle.c.id == neuheit_id) + .values(status="planung") + ) + db.commit() + + details = { + "titel": eintrag.titel, + "verlag": eintrag.verlag, + "ausgabe": eintrag.ausgabe, + "quelle": eintrag.quelle, + "rezensent_id": eintrag.rezensent_id, + "von": "neuheiten", + "neuheit_id": neuheit_id, + } + if ergebnis is not None and ergebnis.hat_konflikte: + details["dedup_konflikte"] = ergebnis.als_liste() + await self._audit(request, user, "verschoben", eintrag.id, details) + + if ergebnis is not None and ergebnis.hat_konflikte: + await self._benachrichtige(request, user, eintrag.titel, ergebnis) + meldung = ( + f"„{eintrag.titel}“ wurde in deine Planungsliste übernommen. " + "Die Dedup-Prüfung hatte Treffer — du hast eine Benachrichtigung erhalten." + ) + else: + meldung = f"„{eintrag.titel}“ wurde in deine Planungsliste übernommen." + return self._meldung("/planung", meldung) + + @self.router.post("/planung/{eintrag_id}/status") + async def status_wechseln( + request: Request, + eintrag_id: int, + db: Session = Depends(get_db), + user: User = Depends(require_user), + status: str = Form(""), + ): + """Statuswechsel (offen → in Bearbeitung → abgeschlossen).""" + eintrag = db.get(Planungseintrag, eintrag_id) + if eintrag is None: + return self._meldung("/planung", "Eintrag nicht gefunden.", "fehler") + self._pruefe_bearbeitbar(user, eintrag) + if status not in GUELTIGE_STATUS: + return self._meldung("/planung", "Unbekannter Status.", "fehler") + alt = eintrag.status + eintrag.status = status + db.commit() + await self._audit( + request, + user, + "geaendert", + eintrag.id, + {"alt": {"status": alt}, "neu": {"status": status}}, + ) + return self._meldung( + "/planung", + f"Status von „{eintrag.titel}“: {STATUS_ANZEIGE.get(status, status)}.", + ) + + @self.router.get("/planung/{eintrag_id}/bearbeiten") + def bearbeiten_formular( + request: Request, + eintrag_id: int, + db: Session = Depends(get_db), + user: User = Depends(require_user), + ): + eintrag = db.get(Planungseintrag, eintrag_id) + if eintrag is None: + return self._meldung("/planung", "Eintrag nicht gefunden.", "fehler") + self._pruefe_bearbeitbar(user, eintrag) + return self.context.templates.TemplateResponse( + request=request, + name="planung/bearbeiten.html", + context={ + "user": user, + "titel_headline": f"Eintrag bearbeiten — {eintrag.titel}", + "eintrag": eintrag, + "abbrechen_url": "/planung", + }, + ) + + @self.router.post("/planung/{eintrag_id}/bearbeiten") + async def bearbeiten_speichern( + request: Request, + eintrag_id: int, + db: Session = Depends(get_db), + user: User = Depends(require_user), + titel: str = Form(""), + verlag: str = Form(""), + ausgabe: str = Form(""), + notizen: str = Form(""), + ): + eintrag = db.get(Planungseintrag, eintrag_id) + if eintrag is None: + return self._meldung("/planung", "Eintrag nicht gefunden.", "fehler") + self._pruefe_bearbeitbar(user, eintrag) + roh_titel = titel.strip() + if not roh_titel: + return self._meldung("/planung", "Bitte einen Spieltitel angeben.", "fehler") + + alt = { + "titel": eintrag.titel, + "verlag": eintrag.verlag, + "ausgabe": eintrag.ausgabe, + "notizen": eintrag.notizen, + } + eintrag.titel = roh_titel + eintrag.verlag = verlag.strip() or None + eintrag.ausgabe = ausgabe.strip() + eintrag.notizen = notizen.strip() or None + neu = { + "titel": eintrag.titel, + "verlag": eintrag.verlag, + "ausgabe": eintrag.ausgabe, + "notizen": eintrag.notizen, + } + geaendert = [k for k in alt if alt[k] != neu[k]] + db.commit() + if geaendert: + # Nur geänderte Felder, im alt/neu-Format des Audit-Log-Plugins. + await self._audit( + request, + user, + "geaendert", + eintrag.id, + { + "alt": {k: alt[k] for k in geaendert}, + "neu": {k: neu[k] for k in geaendert}, + }, + ) + return self._meldung("/planung", f"„{eintrag.titel}“ wurde gespeichert.") + + @self.router.post("/planung/{eintrag_id}/loeschen") + async def loeschen( + request: Request, + eintrag_id: int, + db: Session = Depends(get_db), + user: User = Depends(require_user), + ): + eintrag = db.get(Planungseintrag, eintrag_id) + if eintrag is None: + return self._meldung("/planung", "Eintrag nicht gefunden.", "fehler") + self._pruefe_bearbeitbar(user, eintrag) + snapshot = { + "titel": eintrag.titel, + "verlag": eintrag.verlag, + "ausgabe": eintrag.ausgabe, + "status": eintrag.status, + "rezensent_id": eintrag.rezensent_id, + } + db.delete(eintrag) + db.commit() + await self._audit(request, user, "geloescht", eintrag_id, snapshot) + return self._meldung("/planung", f"„{snapshot['titel']}“ wurde gelöscht.") plugin = PlanungPlugin() diff --git a/plugins/planung/models.py b/plugins/planung/models.py new file mode 100644 index 0000000..5cd57c2 --- /dev/null +++ b/plugins/planung/models.py @@ -0,0 +1,66 @@ +"""Datenmodell des Plugins „planung“. + +Ein Planungseintrag ordnet ein Spiel einem Rezensenten und einer Ausgabe +zu. Einträge entstehen auf zwei Wegen — beide laufen durch die dedup- +Prüfung des dedup-Plugins: +- Verschiebung aus der Neuheitenliste (`quelle = "neuheiten"`), +- händisches Nachtragen im Formular (`quelle = "manuell"`). + +Bei Prüftreffern wird der Befund im JSON-Feld `pruefung` mitgespeichert. +""" +from __future__ import annotations + +from datetime import datetime + +from sqlalchemy import DateTime, ForeignKey, Integer, JSON, String, Text, func +from sqlalchemy.orm import Mapped, mapped_column + +from redaktionskern.db import Base + +#: Gültige Statuswerte in Ablaufreihenfolge. +STATUS_OFFEN = "offen" +STATUS_IN_BEARBEITUNG = "in_bearbeitung" +STATUS_ABGESCHLOSSEN = "abgeschlossen" + +GUELTIGE_STATUS: tuple[str, ...] = ( + STATUS_OFFEN, + STATUS_IN_BEARBEITUNG, + STATUS_ABGESCHLOSSEN, +) + +#: Deutsche Anzeigenamen der Statuswerte. +STATUS_ANZEIGE: dict[str, str] = { + STATUS_OFFEN: "Offen", + STATUS_IN_BEARBEITUNG: "In Bearbeitung", + STATUS_ABGESCHLOSSEN: "Abgeschlossen", +} + + +class Planungseintrag(Base): + """Ein Spiel in der Planungsliste, zugeordnet zu Rezensent und Ausgabe.""" + + __tablename__ = "planungsliste" + __table_args__ = {"extend_existing": True} + + id: Mapped[int] = mapped_column(primary_key=True) + titel: Mapped[str] = mapped_column(String(300)) + verlag: Mapped[str | None] = mapped_column(String(300)) + autor: Mapped[str | None] = mapped_column(String(300)) + #: BoardGameGeek-ID, sofern bekannt (Match-Kriterium der dedup-Prüfung). + bgg_id: Mapped[int | None] = mapped_column(Integer) + #: Magazin-Ausgabe, z. B. „3/2025“ (mehrere Ausgaben parallel möglich). + ausgabe: Mapped[str] = mapped_column(String(100), default="") + rezensent_id: Mapped[int] = mapped_column(ForeignKey("users.id")) + status: Mapped[str] = mapped_column(String(50), default=STATUS_OFFEN) + notizen: Mapped[str | None] = mapped_column(Text) + #: Woher stammt der Eintrag: "neuheiten" oder "manuell". + quelle: Mapped[str] = mapped_column(String(50), default="manuell") + #: Befund der dedup-Prüfung beim Anlegen (Liste von Konflikt-Dicts). + pruefung: Mapped[list | None] = mapped_column(JSON) + erstellt_am: Mapped[datetime] = mapped_column(DateTime, server_default=func.now()) + aktualisiert_am: Mapped[datetime] = mapped_column( + DateTime, server_default=func.now(), onupdate=func.now() + ) + + def __repr__(self) -> str: # pragma: no cover - Debug-Hilfe + return f"" diff --git a/plugins/planung/templates/planung/bearbeiten.html b/plugins/planung/templates/planung/bearbeiten.html new file mode 100644 index 0000000..e9aa913 --- /dev/null +++ b/plugins/planung/templates/planung/bearbeiten.html @@ -0,0 +1,41 @@ +{% extends "base.html" %} +{% block titel %}{{ titel_headline }} — Spiele-Redaktion{% endblock %} +{% block inhalt %} +

Eintrag bearbeiten

+

„{{ eintrag.titel }}“ · Rezensent: + {% if user.id == eintrag.rezensent_id %}du{% else %}{{ user.display_name }}{% endif %} +

+ +
+
+ + +
+
+
+ + +
+
+ + +
+
+
+ + +
+
+ + Abbrechen +
+
+{% endblock %} diff --git a/plugins/planung/templates/planung/index.html b/plugins/planung/templates/planung/index.html index cc09663..3091616 100644 --- a/plugins/planung/templates/planung/index.html +++ b/plugins/planung/templates/planung/index.html @@ -2,9 +2,139 @@ {% block titel %}{{ titel }} — Spiele-Redaktion{% endblock %} {% block inhalt %}

{{ titel }}

-

- Plugin {{ name }} - in Version {{ version }} ist geladen. - Diese Seite ist ein Platzhalter — die Funktion wird in einer späteren Phase implementiert. +

+ Planungsliste der Redaktion: wer reviewt welches Spiel für welche Ausgabe. + Jede Eintragung — aus den Neuheiten verschoben oder händisch nachgetragen — + wird automatisch durch die Dedup-Prüfung geprüft.

+ +{% if meldung %} +
{{ meldung }}
+{% endif %} +{% if fehler %} +
{{ fehler }}
+{% endif %} + +
+

Titel händisch nachtragen

+
+
+ + +
+
+ + +
+
+ + +
+
+ + +
+ +
+
+ +
+
+ + +
+

{{ anzahl }} Einträge

+
+ +
+ + + + + + + + + + + + + + {% for eintrag in eintraege %} + + + + + + + + + + {% else %} + + + + {% endfor %} + +
SpieltitelVerlagAusgabeRezensentStatusAktualisiertAktionen
+ {{ eintrag.titel }} + {% if eintrag.bgg_id %} + BGG {{ eintrag.bgg_id }} + {% endif %} + {% if eintrag.pruefung %} + ⚠ Prüfhinweis + {% endif %} + {{ eintrag.verlag or '—' }}{{ eintrag.ausgabe or '—' }}{{ namen.get(eintrag.rezensent_id, '—') }} + {% if eintrag.status == 'offen' %} + {{ status_anzeige[eintrag.status] }} + {% elif eintrag.status == 'in_bearbeitung' %} + {{ status_anzeige[eintrag.status] }} + {% else %} + {{ status_anzeige[eintrag.status] }} + {% endif %} + + {{ eintrag.aktualisiert_am.strftime('%d.%m.%Y %H:%M') if eintrag.aktualisiert_am else '—' }} + + {% if kann_bearbeiten(eintrag) %} +
+ {% if eintrag.status == 'offen' %} +
+ + +
+ {% endif %} + {% if eintrag.status != 'abgeschlossen' %} +
+ + +
+ {% endif %} + Bearbeiten +
+ +
+
+ {% else %} + nur {{ namen.get(eintrag.rezensent_id, '') }} + {% endif %} +
+ Noch keine Einträge — schiebe einen Titel aus den Neuheiten hierher oder trage ihn oben händisch nach. +
+
{% endblock %} diff --git a/plugins/planung/templates/planung/pruefung.html b/plugins/planung/templates/planung/pruefung.html new file mode 100644 index 0000000..642ffea --- /dev/null +++ b/plugins/planung/templates/planung/pruefung.html @@ -0,0 +1,55 @@ +{% extends "base.html" %} +{% block titel %}{{ titel_headline }} — Spiele-Redaktion{% endblock %} +{% block inhalt %} +

{{ titel_headline }}

+

+ Die automatische Dedup-Prüfung hat Treffer ergeben. Bitte prüfen, bevor + der Eintrag angelegt wird. +

+ +
+

⚠ {{ konflikte|length }} Treffer für „{{ spiel_titel }}“

+
    + {% for konflikt in konflikte %} +
  • + + {{ konflikt_anzeige.get(konflikt.art, konflikt.art) }} + + {{ konflikt.beschreibung }} +
    • + {% endfor %} +
+ {% if titel_empfehlung and titel_empfehlung != spiel_titel %} +

Empfohlener Titel: {{ titel_empfehlung }}

+ {% endif %} +
+ +
+ {% for name, wert in versteckt.items() %} + + {% endfor %} + +

Welcher Verlag soll geführt werden?

+
+ {% for option in verlags_optionen %} + + {% endfor %} +
+ +
+ + Abbrechen +
+
+{% endblock %} diff --git a/pyproject.toml b/pyproject.toml index 3b8e72b..a0cbd27 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -14,6 +14,7 @@ dependencies = [ "argon2-cffi>=23.1", "apscheduler>=3.11,<4", "httpx>=0.27", + "rapidfuzz>=3.14.5", ] [dependency-groups] diff --git a/tests/conftest.py b/tests/conftest.py index cab519d..b728807 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -22,6 +22,8 @@ def _hintergrundjobs_deaktiviert(monkeypatch): monkeypatch.setenv("SPIELE_BGG_SYNC_AKTIV", "1"). """ monkeypatch.setenv("SPIELE_BGG_SYNC_AKTIV", "0") + # Auch der BGG-Hilfsclient des dedup-Plugins bleibt in Tests offline. + monkeypatch.setenv("SPIELE_DEDUP_BGG_AKTIV", "0") @pytest.fixture diff --git a/tests/test_dedup.py b/tests/test_dedup.py new file mode 100644 index 0000000..d31bac2 --- /dev/null +++ b/tests/test_dedup.py @@ -0,0 +1,391 @@ +"""Tests: Plugin „dedup“ — Heuristik, vier Prüfungen, Protokoll, Prüfseite. + +Alle Prüfungen laufen gegen die echte SQLite-Testdatenbank; der optionale +BGG-Hilfsclient wird durch Fakes ersetzt (keine Netzwerk-Aufrufe). +""" +from __future__ import annotations + +import asyncio +import sys +import time + +import html + +import httpx +import pytest +from fastapi.testclient import TestClient +from sqlalchemy import func, select, text + +from tests.conftest import lege_benutzer_an, melde_an + + +# ---------------- Hilfen ---------------- + +def plugin_modul(app, name: str): + plugin_instanz = app.state.registry.get(name) + return sys.modules[type(plugin_instanz).__module__] + + +def pruef_modul(app): + """Das pruefung-Submodul (Heuristik-Funktionen) des dedup-Plugins.""" + return sys.modules[plugin_modul(app, "dedup").__name__ + ".pruefung"] + + +def sichtbar(antwort) -> str: + """Response-Text mit aufgelösten HTML-Entities (für Umlaut-Assertions).""" + return html.unescape(antwort.text) + + +def dedup_plugin(app): + return app.state.registry.get("dedup") + + +def pruefe(app, titel, verlag=None, bgg_id=None, *, user=None, hilfsclient=None): + """Führt eine check_titel-Prüfung aus (optional mit Fake-BGG-Client).""" + if hilfsclient is not None: + dedup_plugin(app).bgg_client_fabrik = lambda: hilfsclient + try: + return asyncio.run( + dedup_plugin(app).check_titel(titel, verlag, bgg_id, user=user) + ) + finally: + dedup_plugin(app).bgg_client_fabrik = None + + +def neuheit_anlegen(app, titel, verlag=None, bgg_id=1, status="neuheit"): + Neuheit = plugin_modul(app, "neuheiten").Neuheit + with app.state.session_factory() as db: + db.add(Neuheit(titel=titel, verlag=verlag, bgg_id=bgg_id, status=status)) + db.commit() + + +def planung_anlegen(app, titel, rezensent_id, status="offen", verlag=None, bgg_id=None): + Planungseintrag = plugin_modul(app, "planung").Planungseintrag + with app.state.session_factory() as db: + eintrag = Planungseintrag( + titel=titel, rezensent_id=rezensent_id, status=status, + verlag=verlag, bgg_id=bgg_id, + ) + db.add(eintrag) + db.commit() + return eintrag.id + + +def benutzer_id(app, username: str) -> int: + from redaktionskern.auth.models import User + + with app.state.session_factory() as db: + return db.scalar(select(User.id).where(User.username == username)) + + +def benutzer_objekt(app, username: str): + from redaktionskern.auth.models import User + + with app.state.session_factory() as db: + return db.scalar(select(User).where(User.username == username)) + + +def konflikt_arten(ergebnis) -> list[str]: + return [k.art for k in ergebnis.konflikte] + + +class FakeBgg: + """Ersetzt den BGG-Hilfsclient: feste Antworten, keine Netzwerk-Aufrufe.""" + + def __init__(self, alternativen_map=None, vorgaenger_map=None): + self._alternativen = alternativen_map or {} + self._vorgaenger = vorgaenger_map or {} + self.alternativen_aufrufe: list[int] = [] + self.vorgaenger_aufrufe: list[int] = [] + + def alternativen(self, bgg_id): + self.alternativen_aufrufe.append(bgg_id) + return list(self._alternativen.get(bgg_id, [])) + + def vorgaenger(self, bgg_id): + self.vorgaenger_aufrufe.append(bgg_id) + return list(self._vorgaenger.get(bgg_id, [])) + + def schliessen(self): + pass + + +# ---------------- Titel-Heuristik ---------------- + +def test_deutsche_titel_heuristik(app): + m = pruef_modul(app) + assert m.ist_deutscher_titel("Die Siedler von Catan") + assert m.ist_deutscher_titel("Ein Fest für Odin") + assert m.ist_deutscher_titel("Bärenpark") + assert m.ist_deutscher_titel("Das verrückte Labyrinth") + assert not m.ist_deutscher_titel("The Crew") + assert not m.ist_deutscher_titel("Terra Mystica") # neutral → kein Deutsch-Beleg + + +def test_fuzzy_match_erkennt_titel_varianten(app): + m = pruef_modul(app) + assert m.titel_aehnlich("Die Siedler von Catan", "Siedler von Catan, Die") + assert m.titel_aehnlich("Cascadia", "cascadia") + assert not m.titel_aehnlich("Cascadia", "Everdell") + assert not m.titel_aehnlich("", "Cascadia") + + +def test_bevorzuge_deutschen_titel_waehlt_hoechsten_score(app): + m = pruef_modul(app) + kandidaten = ["The Settlers of Catan", "Catan", "Die Siedler von Catan"] + assert m.bevorzuge_deutschen_titel(kandidaten) == "Die Siedler von Catan" + # Ein deutscher Kandidat schlägt einen neutralen Eingangstitel: + assert m.bevorzuge_deutschen_titel(["Terra Mystica", "Bärenpark"]) == "Bärenpark" + + +# ---------------- Migration & Grundlagen ---------------- + +def test_migration_legt_protokolltabelle_an(app): + with app.state.engine.connect() as conn: + tabellen = { + zeile[0] for zeile in conn.execute( + text("SELECT name FROM sqlite_master WHERE type='table'") + ) + } + protokoll = conn.execute( + text("SELECT version FROM schema_migrations WHERE plugin='dedup'") + ).fetchall() + assert "dedup_pruefungen" in tabellen + assert [z[0] for z in protokoll] == ["0001_pruefprotokoll"] + + +def test_leere_tabellen_liefern_keine_konflikte(app): + ergebnis = pruefe(app, "Ganz neues Spiel", "Irgendein Verlag", 4711) + assert not ergebnis.hat_konflikte + assert ergebnis.titel == "Ganz neues Spiel" + assert ergebnis.bgg_id == 4711 + + +# ---------------- Prüfung a) Verlags-Konflikt ---------------- + +def test_verlagskonflikt_gegen_neuheiten_eintrag(app): + neuheit_anlegen(app, "Stone Age", verlag="Hans im Glück", bgg_id=21) + ergebnis = pruefe(app, "Stone Age", "Kosmos", 21) + assert ergebnis.hat_verlagskonflikt + assert "Hans im Glück" in ergebnis.verlags_optionen + assert "Kosmos" in ergebnis.verlags_optionen + assert any(k.art == "verlag" for k in ergebnis.konflikte) + + +def test_kein_verlagskonflikt_bei_identischem_verlag(app): + neuheit_anlegen(app, "Stone Age", verlag="Kosmos", bgg_id=21) + ergebnis = pruefe(app, "Stone Age", "kosmos ", 21) # Groß-/Kleinschreibung egal + assert not ergebnis.hat_konflikte + + +def test_verlagskonflikt_ohne_bgg_id_ueber_fuzzy_match(app): + neuheit_anlegen(app, "Cascadia", verlag="Lookout Spiele") + ergebnis = pruefe(app, "Cascadia", "Feuerland Spiele", None) + assert ergebnis.hat_verlagskonflikt + assert "Lookout Spiele" in ergebnis.verlags_optionen + + +# ---------------- Prüfung b) Titel-Varianten / deutsche Version ---------------- + +def test_deutsche_version_wird_empfohlen(app): + neuheit_anlegen(app, "Die Siedler von Catan", verlag="Kosmos", bgg_id=13) + ergebnis = pruefe(app, "Settlers of Catan", "Kosmos", 13) + assert ergebnis.titel_empfehlung == "Die Siedler von Catan" + assert any( + k.art == "titel" and "empfohlen" in k.beschreibung.lower() + for k in ergebnis.konflikte + ) + + +def test_eigener_deutscher_titel_erzeugt_keinen_titelkonflikt(app): + neuheit_anlegen(app, "Catan", verlag="Kosmos", bgg_id=13) + ergebnis = pruefe(app, "Die Siedler von Catan", "Kosmos", 13) + assert ergebnis.titel_empfehlung == "Die Siedler von Catan" + assert "titel" not in konflikt_arten(ergebnis) + + +def test_bgg_alternativen_fliessen_in_die_empfehlung_ein(app): + neuheit_anlegen(app, "Catan", verlag="Kosmos", bgg_id=13) + fake = FakeBgg(alternativen_map={ + 13: ["The Settlers of Catan", "Die Siedler von Catan"], + }) + ergebnis = pruefe(app, "Settlers of Catan", "Kosmos", 13, hilfsclient=fake) + assert fake.alternativen_aufrufe == [13] + assert ergebnis.titel_empfehlung == "Die Siedler von Catan" + + +# ---------------- Prüfung c) Bereits besprochen / Vorgänger ---------------- + +def test_abgeschlossenes_spiel_gilt_als_besprochen(app): + lege_benutzer_an(app, "rez1", "rezensent") + lege_benutzer_an(app, "rez2", "rezensent") + rez1 = benutzer_id(app, "rez1") + planung_anlegen(app, "Cascadia", rez1, status="abgeschlossen") + + ergebnis = pruefe(app, "Cascadia") # ohne Benutzerkontext (z. B. Import-Prüfung) + assert "besprochen" in konflikt_arten(ergebnis) + besprochen = next(k for k in ergebnis.konflikte if k.art == "besprochen") + assert "rez1" in besprochen.details["rezensent"] or "Rez1" in besprochen.details["rezensent"] + + +def test_vorgaenger_wird_ueber_bgg_relation_erkannt(app): + lege_benutzer_an(app, "rez1", "rezensent") + rez1 = benutzer_id(app, "rez1") + planung_anlegen(app, "Catan Grundspiel", rez1, status="abgeschlossen", bgg_id=13) + fake = FakeBgg(vorgaenger_map={99: [(13, "Catan Grundspiel")]}) + + ergebnis = pruefe(app, "Catan Erweiterung", None, 99, hilfsclient=fake) + besprochen = [k for k in ergebnis.konflikte if k.art == "besprochen"] + assert besprochen + assert any("Vorgänger" in k.beschreibung for k in besprochen) + + +def test_vorgaenger_wird_zusaetzlich_fuzzy_gematcht(app): + lege_benutzer_an(app, "rez1", "rezensent") + rez1 = benutzer_id(app, "rez1") + planung_anlegen(app, "Catan Grundspiel", rez1, status="abgeschlossen") + fake = FakeBgg(vorgaenger_map={99: [(555, "Katan Grundspiel")]}) + + ergebnis = pruefe(app, "Catan Erweiterung", None, 99, hilfsclient=fake) + assert any( + k.art == "besprochen" and "Vorgänger" in k.beschreibung + for k in ergebnis.konflikte + ) + + +# ---------------- Prüfung d) Fremde Planungsliste ---------------- + +def test_fremder_planungseintrag_loest_konflikt_aus(app): + lege_benutzer_an(app, "rez1", "rezensent") + lege_benutzer_an(app, "rez2", "rezensent") + rez1 = benutzer_objekt(app, "rez1") + rez2 = benutzer_objekt(app, "rez2") + planung_anlegen(app, "Ark Nova", rez1.id) + + ergebnis = pruefe(app, "Ark Nova", user=rez2) + assert "planung" in konflikt_arten(ergebnis) + planungs_konflikt = next(k for k in ergebnis.konflikte if k.art == "planung") + assert rez1.display_name in planungs_konflikt.details["rezensent"] + + # Der eigene Eintrag des gleichen Rezensenten ist kein Konflikt: + ergebnis = pruefe(app, "Ark Nova", user=rez1) + assert "planung" not in konflikt_arten(ergebnis) + + +# ---------------- Protokoll ---------------- + +def test_pruefung_wird_im_eigenen_protokoll_gespeichert(app, client): + lege_benutzer_an(app, "anna", "redakteur") + with app.state.session_factory() as db: + from redaktionskern.auth.models import User + anna = db.scalar(select(User).where(User.username == "anna")) + + neuheit_anlegen(app, "Cascadia", verlag="Lookout Spiele") + ergebnis = pruefe(app, "Cascadia", "Anderer Verlag", None, user=anna) + assert ergebnis.hat_konflikte + + Pruefung = plugin_modul(app, "dedup").Pruefung + with app.state.session_factory() as db: + eintrag = db.scalar(select(Pruefung)) + assert eintrag is not None + assert eintrag.titel == "Cascadia" + assert eintrag.geprueft_durch == "anna" + assert eintrag.konflikte and eintrag.konflikte[0]["art"] == "verlag" + + +# ---------------- Prüfseite ---------------- + +def test_dedup_seite_erreichbar_nach_login(client): + melde_an(client) + antwort = client.get("/dedup") + assert antwort.status_code == 200 + assert "Titel prüfen" in sichtbar(antwort) + assert "Verlags-Konflikt" in antwort.text + + +def test_dedup_seite_anonym_wird_umgeleitet(client): + antwort = client.get("/dedup", follow_redirects=False) + assert antwort.status_code == 303 + assert antwort.headers["location"].startswith("/login") + + +def test_manuelle_pruefung_ueber_formular(client): + melde_an(client) + antwort = client.post("/dedup/pruefen", data={ + "titel": "Ganz neues Spiel", "verlag": "", "bgg_id": "", + }) + assert antwort.status_code == 200 + assert "Keine Treffer" in sichtbar(antwort) + + +def test_manuelle_pruefung_zeigt_treffer(client, app): + neuheit_anlegen(app, "Cascadia", verlag="Lookout Spiele") + melde_an(client) + antwort = client.post("/dedup/pruefen", data={ + "titel": "Cascadia", "verlag": "Feuerland", "bgg_id": "", + }) + assert antwort.status_code == 200 + text_html = sichtbar(antwort) + assert "Verlags-Konflikt" in text_html + assert "Lookout Spiele" in text_html + + +def test_manuelle_pruefung_validiert_eingaben(client): + melde_an(client) + leer = client.post("/dedup/pruefen", data={"titel": "", "verlag": "", "bgg_id": ""}) + assert "Bitte einen Spieltitel angeben" in leer.text + kaputt = client.post("/dedup/pruefen", data={"titel": "X", "verlag": "", "bgg_id": "abc"}) + assert "Zahl sein" in kaputt.text + + +# ---------------- BGG-Hilfsclient (Parsing, netzwerkfrei) ---------------- + +THING_XML = """ + + + + + + + + + +""" + + +def test_bgg_pruefclient_parst_alternativen_und_vorgaenger(): + from plugins.dedup.bgg import BggPruefClient + + def handler(request: httpx.Request) -> httpx.Response: + assert request.url.params["id"] == "99" + return httpx.Response(200, content=THING_XML.encode()) + + schlaf_aufrufe: list[float] = [] + client = BggPruefClient( + mindestabstand_sekunden=0.0, + transport=httpx.MockTransport(handler), + uhr=time.monotonic, + schlafen=lambda s: schlaf_aufrufe.append(s), + ) + try: + alternativen = client.alternativen(99) + vorgaenger = client.vorgaenger(99) + finally: + client.schliessen() + assert alternativen == ["Catan Expansion", "Siedler-Erweiterung"] + assert vorgaenger == [(13, "Catan Grundspiel")] + assert schlaf_aufrufe == [] + + +def test_bgg_pruefclient_toleroert_fehler(): + from plugins.dedup.bgg import BggPruefClient + + def handler(request: httpx.Request) -> httpx.Response: + raise httpx.ConnectError("offline") + + client = BggPruefClient(mindestabstand_sekunden=0.0, transport=httpx.MockTransport(handler)) + try: + assert client.alternativen(99) == [] + assert client.vorgaenger(99) == [] + finally: + client.schliessen() diff --git a/tests/test_planung.py b/tests/test_planung.py new file mode 100644 index 0000000..5fb4c89 --- /dev/null +++ b/tests/test_planung.py @@ -0,0 +1,575 @@ +"""Tests: Plugin „planung“ — Eintragswege, dedup-Verzahnung, Rollen, UI. + +Abhängigkeiten werden gemockt: das dedup-Plugin durch einen Stub mit +steuerbaren Prüfergebnissen, benachrichtigung und audit-log durch +aufzeichnende Stubs. Ein Test beweist zusätzlich die Integration mit den +echten Plugins (In-App-Nachricht + Audit-Eintrag in der Datenbank). +""" +from __future__ import annotations + +import html +import sys +from dataclasses import dataclass, field +from types import SimpleNamespace + +import pytest + +from fastapi.testclient import TestClient +from sqlalchemy import func, select, text + +from redaktionskern.app import create_app +from tests.conftest import ADMIN_PASSWORD, lege_benutzer_an, melde_an + + +# ---------------- Hilfen ---------------- + +def plugin_modul(app, name: str): + plugin_instanz = app.state.registry.get(name) or sys.modules.get( + f"spiele_redaktion_plugins.{name}" + ) + return sys.modules[type(plugin_instanz).__module__] + + +def neuheit_anlegen(app, titel, verlag=None, bgg_id=None): + Neuheit = plugin_modul(app, "neuheiten").Neuheit + with app.state.session_factory() as db: + eintrag = Neuheit(titel=titel, verlag=verlag, bgg_id=bgg_id) + db.add(eintrag) + db.commit() + return eintrag.id + + +def planung_anlegen(app, titel, rezensent_id, **kwargs): + Planungseintrag = plugin_modul(app, "planung").Planungseintrag + with app.state.session_factory() as db: + eintrag = Planungseintrag(titel=titel, rezensent_id=rezensent_id, **kwargs) + db.add(eintrag) + db.commit() + return eintrag.id + + +def planung_zaehlen(app) -> int: + Planungseintrag = plugin_modul(app, "planung").Planungseintrag + with app.state.session_factory() as db: + return db.scalar(select(func.count()).select_from(Planungseintrag)) + + +def sichtbar(antwort) -> str: + """Response-Text mit aufgelösten HTML-Entities (für Umlaut-Assertions).""" + return html.unescape(antwort.text) + + +def benutzer_objekt(app, username: str): + from redaktionskern.auth.models import User + + with app.state.session_factory() as db: + return db.scalar(select(User).where(User.username == username)) + + +# ---------------- Stubs (gemockte Abhängigkeiten) ---------------- + +@dataclass +class Aufgezeichnet: + """Ein aufgezeichneter Aufruf von audit.log / send_notification.""" + daten: dict = field(default_factory=dict) + + +class StubDedup: + """Ersetzt das dedup-Plugin: liefert gesteuerte Prüfergebnisse.""" + + name = "dedup" + + def __init__(self, modul): + self._modul = modul # echte Datenklassen für realistische Ergebnisse + self.aufrufe: list[dict] = [] + self.warteschlange: list = [] + self.standard_treffer = None + + def treffer_einreihen(self, ergebnis) -> None: + self.warteschlange.append(ergebnis) + + def konflikt(self, art, beschreibung, details=None, optionen=None, empfehlung=None, + titel="", verlag=None, bgg_id=None): + P, K = self._modul.PruefErgebnis, self._modul.TitelKonflikt + return P( + titel=titel, verlag=verlag, bgg_id=bgg_id, + konflikte=[K(art=art, beschreibung=beschreibung, details=details or {})], + verlags_optionen=list(optionen or []), + titel_empfehlung=empfehlung, + ) + + async def check_titel(self, titel, verlag=None, bgg_id=None, *, user=None): + self.aufrufe.append( + {"titel": titel, "verlag": verlag, "bgg_id": bgg_id, + "user_id": user.id if user is not None else None} + ) + if self.warteschlange: + ergebnis = self.warteschlange.pop(0) + ergebnis.titel = titel + ergebnis.verlag = verlag + ergebnis.bgg_id = bgg_id + return ergebnis + P = self._modul.PruefErgebnis + return P(titel=titel, verlag=verlag, bgg_id=bgg_id) + + +class StubBenachrichtigung: + name = "benachrichtigung" + + def __init__(self): + self.gesendet: list[Aufgezeichnet] = [] + + async def send_notification(self, user, titel, text, kategorie="allgemein"): + self.gesendet.append(Aufgezeichnet({ + "user_id": user.id, "titel": titel, "text": text, "kategorie": kategorie, + })) + return SimpleNamespace(zugestellt=["inapp"], fehlgeschlagen=[]) + + +class StubAudit: + name = "audit-log" + + def __init__(self): + self.eintraege: list[Aufgezeichnet] = [] + + async def log(self, actor, action, objekt_typ="", objekt_id=None, + details=None, **kwargs): + self.eintraege.append(Aufgezeichnet({ + "actor": actor, "action": action, "objekt_typ": objekt_typ, + "objekt_id": objekt_id, "details": details, + })) + + def log_sync(self, *args, **kwargs): # Kompatibilität zur echten API + import asyncio + + asyncio.run(self.log(*args, **kwargs)) + + +@pytest.fixture +def stubs(app): + """Ersetzt dedup/benachrichtigung/audit-log im Registry-Zustand der App.""" + modul = sys.modules[plugin_modul(app, "dedup").__name__ + ".pruefung"] + dedup_stub = StubDedup(modul) + benachrichtigung = StubBenachrichtigung() + audit = StubAudit() + registry_inhalt = app.state.registry._plugins + registry_inhalt["dedup"] = dedup_stub + registry_inhalt["benachrichtigung"] = benachrichtigung + registry_inhalt["audit-log"] = audit + return SimpleNamespace( + dedup=dedup_stub, benachrichtigung=benachrichtigung, audit=audit, + ) + + +# ---------------- Migration & Zugriff ---------------- + +def test_migration_legt_planungsliste_an(app): + with app.state.engine.connect() as conn: + tabellen = { + zeile[0] for zeile in conn.execute( + text("SELECT name FROM sqlite_master WHERE type='table'") + ) + } + protokoll = conn.execute( + text("SELECT version FROM schema_migrations WHERE plugin='planung'") + ).fetchall() + assert "planungsliste" in tabellen + assert [z[0] for z in protokoll] == ["0001_planungsliste"] + + +def test_anonym_wird_zum_login_umgeleitet(client): + antwort = client.get("/planung", follow_redirects=False) + assert antwort.status_code == 303 + assert antwort.headers["location"].startswith("/login") + + +def test_rezensent_sieht_planungsliste(app, client): + lege_benutzer_an(app, "rez1", "rezensent") + melde_an(client, "rez1", "test-12345678") + antwort = client.get("/planung") + assert antwort.status_code == 200 + text_html = sichtbar(antwort) + assert "Planungsliste" in text_html + assert "Titel händisch nachtragen" in text_html + + +# ---------------- Weg 1: händisches Nachtragen ---------------- + +def test_manuell_ohne_treffer_legt_eintrag_an(client, app, stubs): + lege_benutzer_an(app, "rez1", "rezensent") + melde_an(client, "rez1", "test-12345678") + + antwort = client.post("/planung/neu", data={ + "titel": "Ein ganz neues Spiel", "verlag": "Neu Verlag", + "ausgabe": "3/2025", "bgg_id": "", + }, follow_redirects=True) + + assert antwort.status_code == 200 + assert "wurde eingetragen" in antwort.text + Planungseintrag = plugin_modul(app, "planung").Planungseintrag + with app.state.session_factory() as db: + eintrag = db.scalar(select(Planungseintrag)) + assert eintrag.titel == "Ein ganz neues Spiel" + assert eintrag.verlag == "Neu Verlag" + assert eintrag.ausgabe == "3/2025" + assert eintrag.quelle == "manuell" + assert eintrag.status == "offen" + assert eintrag.pruefung is None + + # Dedup wurde befragt: + assert len(stubs.dedup.aufrufe) == 1 + assert stubs.dedup.aufrufe[0]["titel"] == "Ein ganz neues Spiel" + # Kein Treffer → keine Benachrichtigung, aber Audit-Eintrag: + assert stubs.benachrichtigung.gesendet == [] + assert [e.daten["action"] for e in stubs.audit.eintraege] == ["erstellt"] + assert stubs.audit.eintraege[0].daten["objekt_typ"] == "planungseintrag" + + +def test_leerer_titel_wird_abgewiesen(client, app, stubs): + lege_benutzer_an(app, "rez1", "rezensent") + melde_an(client, "rez1", "test-12345678") + antwort = client.post("/planung/neu", data={"titel": ""}, follow_redirects=True) + assert "Bitte einen Spieltitel angeben" in antwort.text + assert planung_zaehlen(app) == 0 + assert stubs.dedup.aufrufe == [] + + +def test_manuell_mit_treffer_benachrichtigt_und_auditiert(client, app, stubs): + lege_benutzer_an(app, "rez1", "rezensent") + rez1 = benutzer_objekt(app, "rez1") + stubs.dedup.standard_treffer = True + stubs.dedup.treffer_einreihen(stubs.dedup.konflikt( + "planung", "„Spiel X“ ist bereits in der Planungsliste von Anna.", + details={"rezensent": "Anna"}, + )) + melde_an(client, "rez1", "test-12345678") + + antwort = client.post("/planung/neu", data={ + "titel": "Spiel X", "verlag": "", "ausgabe": "", "bgg_id": "", + }, follow_redirects=True) + + assert antwort.status_code == 200 + assert "Benachrichtigung erhalten" in antwort.text + # Benachrichtigung an den eintragenden Rezensenten: + assert len(stubs.benachrichtigung.gesendet) == 1 + nachricht = stubs.benachrichtigung.gesendet[0].daten + assert nachricht["user_id"] == rez1.id + assert nachricht["kategorie"] == "dedup" + assert "Dedup-Prüfung" in nachricht["text"] + # Audit-Eintrag enthält den Befund: + erstellt = next(e for e in stubs.audit.eintraege if e.daten["action"] == "erstellt") + assert erstellt.daten["details"]["dedup_konflikte"][0]["art"] == "planung" + # Der Befund wird am Eintrag gespeichert: + Planungseintrag = plugin_modul(app, "planung").Planungseintrag + with app.state.session_factory() as db: + eintrag = db.scalar(select(Planungseintrag)) + assert eintrag.pruefung[0]["art"] == "planung" + + +def test_verlagskonflikt_oeffnet_auswahl_dialog(client, app, stubs): + lege_benutzer_an(app, "rez1", "rezensent") + stubs.dedup.treffer_einreihen(stubs.dedup.konflikt( + "verlag", "Gleiches Spiel ist bereits unter anderem Verlag geführt.", + optionen=["Hans im Glück", "Kosmos"], + )) + melde_an(client, "rez1", "test-12345678") + + antwort = client.post("/planung/neu", data={ + "titel": "Umstrittenes Spiel", "verlag": "Kosmos", "ausgabe": "", "bgg_id": "", + }) + + # Kein Redirect: der Auswahl-Dialog wird gerendert. + assert antwort.status_code == 200 + assert "Welcher Verlag" in antwort.text + assert "Hans im Glück" in antwort.text and "Kosmos" in antwort.text + assert 'action="/planung/neu"' in antwort.text + assert planung_zaehlen(app) == 0 # erst nach der Wahl wird angelegt + + +def test_verlagswahl_legt_eintrag_mit_gewaehltem_verlag_an(client, app, stubs): + lege_benutzer_an(app, "rez1", "rezensent") + stubs.dedup.treffer_einreihen(stubs.dedup.konflikt( + "verlag", "Gleiches Spiel ist bereits unter anderem Verlag geführt.", + optionen=["Hans im Glück", "Kosmos"], + )) + stubs.dedup.treffer_einreihen(stubs.dedup.konflikt( + "verlag", "Gleiches Spiel ist bereits unter anderem Verlag geführt.", + optionen=["Hans im Glück", "Kosmos"], + )) + melde_an(client, "rez1", "test-12345678") + + # Schritt 1: Dialog erscheint. + dialog = client.post("/planung/neu", data={ + "titel": "Umstrittenes Spiel", "verlag": "Kosmos", "ausgabe": "", "bgg_id": "", + }) + assert "Welcher Verlag" in dialog.text + + # Schritt 2: Bestätigte Verlagswahl legt den Eintrag an. + antwort = client.post("/planung/neu", data={ + "titel": "Umstrittenes Spiel", "verlag": "Kosmos", + "ausgabe": "", "bgg_id": "", + "verlag_wahl": "Hans im Glück", "verlag_bestaetigt": "1", + }, follow_redirects=True) + assert antwort.status_code == 200 + + Planungseintrag = plugin_modul(app, "planung").Planungseintrag + with app.state.session_factory() as db: + eintrag = db.scalar(select(Planungseintrag)) + assert eintrag is not None + assert eintrag.verlag == "Hans im Glück" + # Entscheidung und Befund sind auditiert: + erstellt = next(e for e in stubs.audit.eintraege if e.daten["action"] == "erstellt") + assert erstellt.daten["details"]["verlag"] == "Hans im Glück" + assert erstellt.daten["details"]["dedup_konflikte"][0]["art"] == "verlag" + assert len(stubs.benachrichtigung.gesendet) == 1 + + +# ---------------- Weg 2: Verschiebung aus den Neuheiten ---------------- + +def test_uebernehmen_verschiebt_neuheit_in_planung(client, app, stubs): + lege_benutzer_an(app, "rez1", "rezensent") + neuheit_id = neuheit_anlegen(app, "Azul Next Move", verlag="Next Move", bgg_id=500) + melde_an(client, "rez1", "test-12345678") + + antwort = client.post(f"/planung/uebernehmen/{neuheit_id}", follow_redirects=True) + assert antwort.status_code == 200 + assert "Azul Next Move" in antwort.text + assert "übernommen" in antwort.text + + Planungseintrag = plugin_modul(app, "planung").Planungseintrag + with app.state.session_factory() as db: + eintrag = db.scalar(select(Planungseintrag)) + status = db.execute( + text("SELECT status FROM neuheiten WHERE id=:id"), {"id": neuheit_id} + ).scalar() + assert eintrag.quelle == "neuheiten" + assert eintrag.bgg_id == 500 + assert eintrag.rezensent_id == benutzer_objekt(app, "rez1").id + assert status == "planung" # Neuheit gilt als verplant + + # dedup wurde mit den Neuheiten-Daten befragt; Audit als „verschoben“: + assert stubs.dedup.aufrufe == [ + {"titel": "Azul Next Move", "verlag": "Next Move", "bgg_id": 500, + "user_id": benutzer_objekt(app, "rez1").id} + ] + assert [e.daten["action"] for e in stubs.audit.eintraege] == ["verschoben"] + assert stubs.benachrichtigung.gesendet == [] + + +def test_uebernehmen_mit_verlagskonflikt_zeigt_dialog(client, app, stubs): + lege_benutzer_an(app, "rez1", "rezensent") + neuheit_id = neuheit_anlegen(app, "Umstritten", verlag="Verlag A", bgg_id=600) + stubs.dedup.treffer_einreihen(stubs.dedup.konflikt( + "verlag", "Gleiches Spiel ist bereits unter anderem Verlag geführt.", + optionen=["Verlag A", "Verlag B"], + )) + melde_an(client, "rez1", "test-12345678") + + dialog = client.post(f"/planung/uebernehmen/{neuheit_id}") + assert dialog.status_code == 200 + assert "Welcher Verlag" in dialog.text + assert 'action="/planung/uebernehmen/' in dialog.text + assert planung_zaehlen(app) == 0 + + antwort = client.post(f"/planung/uebernehmen/{neuheit_id}", data={ + "verlag_wahl": "Verlag B", "verlag_bestaetigt": "1", + }, follow_redirects=True) + assert antwort.status_code == 200 + Planungseintrag = plugin_modul(app, "planung").Planungseintrag + with app.state.session_factory() as db: + eintrag = db.scalar(select(Planungseintrag)) + status = db.execute( + text("SELECT status FROM neuheiten WHERE id=:id"), {"id": neuheit_id} + ).scalar() + assert eintrag.verlag == "Verlag B" + assert status == "planung" + + +def test_doppelte_uebernahme_wird_abgeblockt(client, app, stubs): + lege_benutzer_an(app, "rez1", "rezensent") + neuheit_id = neuheit_anlegen(app, "Azul", verlag="Next Move", bgg_id=500) + melde_an(client, "rez1", "test-12345678") + erste = client.post(f"/planung/uebernehmen/{neuheit_id}", follow_redirects=False) + assert erste.status_code == 303 + + zweite = client.post(f"/planung/uebernehmen/{neuheit_id}", follow_redirects=True) + assert "nicht mehr als Neuheit verfügbar" in zweite.text + assert planung_zaehlen(app) == 1 + + +def test_unbekannte_neuheit_fuehrt_zur_fehlermeldung(client, app, stubs): + lege_benutzer_an(app, "rez1", "rezensent") + melde_an(client, "rez1", "test-12345678") + antwort = client.post("/planung/uebernehmen/9999", follow_redirects=True) + assert "existiert nicht mehr" in antwort.text + assert planung_zaehlen(app) == 0 + + +# ---------------- Statuswechsel ---------------- + +def test_statuswechsel_eigener_eintrag_wird_auditiert(client, app, stubs): + lege_benutzer_an(app, "rez1", "rezensent") + rez1 = benutzer_objekt(app, "rez1") + eintrag_id = planung_anlegen(app, "Ark Nova", rez1.id) + melde_an(client, "rez1", "test-12345678") + + antwort = client.post(f"/planung/{eintrag_id}/status", + data={"status": "in_bearbeitung"}, follow_redirects=True) + assert antwort.status_code == 200 + Planungseintrag = plugin_modul(app, "planung").Planungseintrag + with app.state.session_factory() as db: + eintrag = db.get(Planungseintrag, eintrag_id) + assert eintrag.status == "in_bearbeitung" + geaendert = stubs.audit.eintraege[-1].daten + assert geaendert["action"] == "geaendert" + assert geaendert["details"]["alt"]["status"] == "offen" + assert geaendert["details"]["neu"]["status"] == "in_bearbeitung" + + +def test_statuswechsel_fremder_eintrag_403(client, app, stubs): + lege_benutzer_an(app, "rez1", "rezensent") + lege_benutzer_an(app, "rez2", "rezensent") + eintrag_id = planung_anlegen(app, "Ark Nova", benutzer_objekt(app, "rez1").id) + melde_an(client, "rez2", "test-12345678") + antwort = client.post(f"/planung/{eintrag_id}/status", data={"status": "abgeschlossen"}) + assert antwort.status_code == 403 + + +def test_redakteur_darf_status_fremder_eintraege_wechseln(client, app, stubs): + lege_benutzer_an(app, "rez1", "rezensent") + lege_benutzer_an(app, "red1", "redakteur") + eintrag_id = planung_anlegen(app, "Ark Nova", benutzer_objekt(app, "rez1").id) + melde_an(client, "red1", "test-12345678") + antwort = client.post(f"/planung/{eintrag_id}/status", + data={"status": "abgeschlossen"}, follow_redirects=True) + assert antwort.status_code == 200 + Planungseintrag = plugin_modul(app, "planung").Planungseintrag + with app.state.session_factory() as db: + assert db.get(Planungseintrag, eintrag_id).status == "abgeschlossen" + + +def test_unbekannter_status_wird_abgelehnt(client, app, stubs): + lege_benutzer_an(app, "rez1", "rezensent") + eintrag_id = planung_anlegen(app, "Ark Nova", benutzer_objekt(app, "rez1").id) + melde_an(client, "rez1", "test-12345678") + antwort = client.post(f"/planung/{eintrag_id}/status", + data={"status": "quatsch"}, follow_redirects=True) + assert "Unbekannter Status" in antwort.text + Planungseintrag = plugin_modul(app, "planung").Planungseintrag + with app.state.session_factory() as db: + assert db.get(Planungseintrag, eintrag_id).status == "offen" + + +# ---------------- Bearbeiten & Löschen ---------------- + +def test_eigener_eintrag_kann_bearbeitet_werden(client, app, stubs): + lege_benutzer_an(app, "rez1", "rezensent") + eintrag_id = planung_anlegen(app, "Ark Nova", benutzer_objekt(app, "rez1").id, + ausgabe="") + melde_an(client, "rez1", "test-12345678") + + formular = client.get(f"/planung/{eintrag_id}/bearbeiten") + assert formular.status_code == 200 + assert "Ark Nova" in formular.text + + antwort = client.post(f"/planung/{eintrag_id}/bearbeiten", data={ + "titel": "Ark Nova", "verlag": "Feuerland Spiele", + "ausgabe": "4/2025", "notizen": "Schwerpunkt-Thema", + }, follow_redirects=True) + assert antwort.status_code == 200 + Planungseintrag = plugin_modul(app, "planung").Planungseintrag + with app.state.session_factory() as db: + eintrag = db.get(Planungseintrag, eintrag_id) + assert eintrag.ausgabe == "4/2025" + assert eintrag.notizen == "Schwerpunkt-Thema" + geaendert = next( + e for e in stubs.audit.eintraege if e.daten["action"] == "geaendert" + ).daten + assert "alt" in geaendert["details"] and "neu" in geaendert["details"] + + +def test_fremder_eintrag_nicht_bearbeitbar_fuer_rezensenten(client, app, stubs): + lege_benutzer_an(app, "rez1", "rezensent") + lege_benutzer_an(app, "rez2", "rezensent") + eintrag_id = planung_anlegen(app, "Ark Nova", benutzer_objekt(app, "rez1").id) + melde_an(client, "rez2", "test-12345678") + assert client.get(f"/planung/{eintrag_id}/bearbeiten").status_code == 403 + assert client.post(f"/planung/{eintrag_id}/bearbeiten", data={ + "titel": "Hack", "verlag": "", "ausgabe": "", "notizen": "", + }).status_code == 403 + + +def test_eigener_eintrag_kann_geloescht_werden(client, app, stubs): + lege_benutzer_an(app, "rez1", "rezensent") + eintrag_id = planung_anlegen(app, "Weg von hier", benutzer_objekt(app, "rez1").id) + melde_an(client, "rez1", "test-12345678") + + antwort = client.post(f"/planung/{eintrag_id}/loeschen", follow_redirects=True) + assert antwort.status_code == 200 + assert "wurde gelöscht" in antwort.text + assert planung_zaehlen(app) == 0 + geloescht = next( + e for e in stubs.audit.eintraege if e.daten["action"] == "geloescht" + ).daten + assert geloescht["details"]["titel"] == "Weg von hier" + + +def test_fremder_eintrag_nicht_loeschbar_fuer_rezensenten(client, app, stubs): + lege_benutzer_an(app, "rez1", "rezensent") + lege_benutzer_an(app, "rez2", "rezensent") + eintrag_id = planung_anlegen(app, "Ark Nova", benutzer_objekt(app, "rez1").id) + melde_an(client, "rez2", "test-12345678") + antwort = client.post(f"/planung/{eintrag_id}/loeschen") + assert antwort.status_code == 403 + assert planung_zaehlen(app) == 1 + + +# ---------------- Liste / Zuordnung / Rechte im UI ---------------- + +def test_liste_zeigt_zuordnung_und_rechte(client, app, stubs): + lege_benutzer_an(app, "rez1", "rezensent", password="pw-rez1-123456") + lege_benutzer_an(app, "rez2", "rezensent", password="pw-rez2-123456") + own_id = planung_anlegen(app, "Mein Spiel", benutzer_objekt(app, "rez1").id) + fremd_id = planung_anlegen(app, "Fremdes Spiel", benutzer_objekt(app, "rez2").id) + + melde_an(client, "rez1", "pw-rez1-123456") + antwort = client.get("/planung") + text_html = antwort.text + assert "Mein Spiel" in text_html and "Fremdes Spiel" in text_html + # Eigene Aktionen sichtbar, fremde nicht: + assert f"/planung/{own_id}/bearbeiten" in text_html + assert f"/planung/{fremd_id}/bearbeiten" not in text_html + + +# ---------------- Integration mit den echten Plugins ---------------- + +def test_integration_echte_plugins_benachrichtigung_und_audit(settings): + """Ohne Stubs: Treffer löst echte In-App-Nachricht + Audit-Eintrag aus.""" + app = create_app(settings) + lege_benutzer_an(app, "rez1", "rezensent") + lege_benutzer_an(app, "rez2", "rezensent") + planung_anlegen(app, "Azul", benutzer_objekt(app, "rez2").id) # fremd → Treffer + neuheit_id = neuheit_anlegen(app, "Azul", verlag="Next Move", bgg_id=777) + + client = TestClient(app) + melde_an(client, "rez1", "test-12345678") + antwort = client.post(f"/planung/uebernehmen/{neuheit_id}", follow_redirects=True) + assert antwort.status_code == 200 + + # Echte In-App-Benachrichtigung für rez1: + benachrichtigungen = plugin_modul(app, "benachrichtigung").Benachrichtigung + with app.state.session_factory() as db: + nachrichten = db.scalars(select(benachrichtigungen)).all() + audit_zeilen = db.scalars( + select(plugin_modul(app, "audit-log").AuditEintrag) + ).all() + assert any(n.user_id == benutzer_objekt(app, "rez1").id and "Azul" in n.titel + for n in nachrichten) + assert any(a.action == "verschoben" and a.objekt_typ == "planungseintrag" + for a in audit_zeilen) + + # Und die echte dedup-Prüfung hat ihren Protokolleintrag bekommen: + pruefungen = plugin_modul(app, "dedup").Pruefung + with app.state.session_factory() as db: + protokoll = db.scalars(select(pruefungen)).all() + assert protokoll and protokoll[0].konflikte diff --git a/tests/test_plugin_loader.py b/tests/test_plugin_loader.py index fa22446..12ebd3f 100644 --- a/tests/test_plugin_loader.py +++ b/tests/test_plugin_loader.py @@ -18,7 +18,7 @@ ERWARTETE_STUBS = { } # Voll implementierte Plugins (keine Stubs mehr): -ERWARTETE_PLUGINS = ERWARTETE_STUBS | {"neuheiten"} +ERWARTETE_PLUGINS = ERWARTETE_STUBS | {"neuheiten", "dedup", "planung"} def test_alle_plugins_werden_geladen(app): @@ -41,7 +41,7 @@ def test_plugins_haben_navigation(app): # Voll implementierte Plugins tragen keinen Platzhalter-Text mehr auf ihrer # Seite; die Prüfung läuft weiter für alle übrigen Platzhalter. -VOLL_IMPLEMENTIERT = {"audit-log", "neuheiten", "benachrichtigung"} +VOLL_IMPLEMENTIERT = {"audit-log", "neuheiten", "benachrichtigung", "dedup", "planung"} PLATZHALTER_STUBS = ERWARTETE_STUBS - VOLL_IMPLEMENTIERT diff --git a/uv.lock b/uv.lock index fe60ced..13277b0 100644 --- a/uv.lock +++ b/uv.lock @@ -750,6 +750,85 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" }, ] +[[package]] +name = "rapidfuzz" +version = "3.14.5" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2c/21/ef6157213316e85790041254259907eb722e00b03480256c0545d98acd33/rapidfuzz-3.14.5.tar.gz", hash = "sha256:ba10ac57884ce82112f7ed910b67e7fb6072d8ef2c06e30dc63c0f604a112e0e", size = 57901753, upload-time = "2026-04-07T11:16:31.931Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e1/f9/3c41a7be8855803f4f6c713b472226a98d31d41869d98f64f4ca790510d6/rapidfuzz-3.14.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:e251126d48615e1f02b4a178f2cd0cd4f0332b8a019c01a2e10480f7552554b4", size = 1952372, upload-time = "2026-04-07T11:13:58.32Z" }, + { url = "https://files.pythonhosted.org/packages/9e/89/c2557e37531d03465193bff0ab9de70b468420a807d71a26a65100635459/rapidfuzz-3.14.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5ab449c9abd0d4e1f8145dce0798a4c822a1a1933d613c764a641bea88b8bdab", size = 1159782, upload-time = "2026-04-07T11:14:00.127Z" }, + { url = "https://files.pythonhosted.org/packages/1a/b2/ffeeb7eca1a897d51b998f4c0ef0281696c3b06abcca4f88f9def708ffe1/rapidfuzz-3.14.5-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cb2829fedd672dd7107267189dabe2bbe07972801d636014417c6861eb89e358", size = 1383677, upload-time = "2026-04-07T11:14:01.696Z" }, + { url = "https://files.pythonhosted.org/packages/6b/d0/4539e42a2d596e068f7738f279638a4a74edd1fbb6f8594e2458058979c6/rapidfuzz-3.14.5-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3d50e5861872935fece391351cbb5ba21d1bced277cf5e1143d207a0a35f1925", size = 3168906, upload-time = "2026-04-07T11:14:03.29Z" }, + { url = "https://files.pythonhosted.org/packages/5e/1c/3ec897eb9d8b05308aa8ef6ae4ed64b088ad521a3f9d8ff469e7e97bc2b0/rapidfuzz-3.14.5-cp311-cp311-manylinux_2_39_riscv64.whl", hash = "sha256:7092a216728f80c960bd6b3807275d1ee318b168986bd5dc523349581d4890b8", size = 1478176, upload-time = "2026-04-07T11:14:04.94Z" }, + { url = "https://files.pythonhosted.org/packages/ab/ba/970c03a12ce20a5399e22afe9f8932fd4cd1265b8a8461d0e63b00eb4eae/rapidfuzz-3.14.5-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:9669753caef7fdc6529f6adcc5883ed98d65976445d9322e7dbdb6b697feee13", size = 2402441, upload-time = "2026-04-07T11:14:07.228Z" }, + { url = "https://files.pythonhosted.org/packages/81/93/61d351cae60c1d0e21ba5ff1a1015ad045539ed215da9d6e302204ed887a/rapidfuzz-3.14.5-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:823b1b9d9230809d8edcc18872770764bfe8ef4357995e16744047c8ccf0e489", size = 2511628, upload-time = "2026-04-07T11:14:09.234Z" }, + { url = "https://files.pythonhosted.org/packages/87/52/374d2d4f60fd98155142a869323aa221e30868cfa1f15171a0f64070c247/rapidfuzz-3.14.5-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f0b2af76b7e7060c09e1a0dfa9410eb19369cbe6164509bff2ef94094b54d2b6", size = 4275480, upload-time = "2026-04-07T11:14:11.332Z" }, + { url = "https://files.pythonhosted.org/packages/d8/04/82e7989bc9ec20a15b720a335c5cb6b0724bf6582013898f90a3280cfccd/rapidfuzz-3.14.5-cp311-cp311-win32.whl", hash = "sha256:c5801a89604c65ab4cc9e91b23bc4076d0ca80efd8c976fb63843d7879a85d7f", size = 1725627, upload-time = "2026-04-07T11:14:13.217Z" }, + { url = "https://files.pythonhosted.org/packages/b9/b5/eca8ac5609bc9bcb02bb6ff87fa5983cc92b8772d66a431556ab8a8c178f/rapidfuzz-3.14.5-cp311-cp311-win_amd64.whl", hash = "sha256:d7ca16637c0ede8243f84074044bd0b2335a0341421f8227c85756de2d18c819", size = 1545977, upload-time = "2026-04-07T11:14:14.766Z" }, + { url = "https://files.pythonhosted.org/packages/ca/e1/dbf318de28f65fa2cdd0a9dfbdee380f8199eb83b19259bc4f8592551b4e/rapidfuzz-3.14.5-cp311-cp311-win_arm64.whl", hash = "sha256:8c90cdf8516d9057e502aa6003cea71cf5ec27cc44699ca52412b502a04761bb", size = 816827, upload-time = "2026-04-07T11:14:16.788Z" }, + { url = "https://files.pythonhosted.org/packages/d3/e3/574435c6aafb80254c191ef40d7aca2cb2bb97a095ec9395e9fa59ac307a/rapidfuzz-3.14.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:0d3378f471ef440473a396ce2f8e97ee12f89a78b495540e0a5617bbfe895638", size = 1944601, upload-time = "2026-04-07T11:14:18.771Z" }, + { url = "https://files.pythonhosted.org/packages/d0/1f/fbad3102a255ecc112ce9a7e779bacab7fd14398217be8868dc9082ba363/rapidfuzz-3.14.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1e910eebca9fd0eba245c0555e764597e8a0cccb673a92da2dc2397050725f48", size = 1164293, upload-time = "2026-04-07T11:14:20.534Z" }, + { url = "https://files.pythonhosted.org/packages/88/37/a3eb7ff6121ed3a5f199a8c38cc86c8e481816f879cb0e0b738b078c9a7e/rapidfuzz-3.14.5-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:01550fe5f60fd176aa66b7611289d46dc4aa4b1b904874c7b6d1d54e581c5ec1", size = 1371999, upload-time = "2026-04-07T11:14:22.63Z" }, + { url = "https://files.pythonhosted.org/packages/79/72/97a9728c711c7c1b06e107d3f0623880fb4ef90e147ed13c551a1730e7cc/rapidfuzz-3.14.5-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:48bee0b91bebfaec41e1081e351000659ab7570cc4598d617aa04d5bf827f9e6", size = 3145715, upload-time = "2026-04-07T11:14:24.508Z" }, + { url = "https://files.pythonhosted.org/packages/ed/54/d5caabbea233ac90c286c87c260e49d7641467e87438a18d858e41c82e91/rapidfuzz-3.14.5-cp312-cp312-manylinux_2_39_riscv64.whl", hash = "sha256:7e580cb04ad849ae9b786fa21383c6b994b6e6c1444ad1cb9f22392759d72741", size = 1456304, upload-time = "2026-04-07T11:14:26.515Z" }, + { url = "https://files.pythonhosted.org/packages/fc/a7/2d1a81250ac8c01a0100c026018e76f0e7a097ff63e4c553e02a6938c6fb/rapidfuzz-3.14.5-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:09d6c9ba091854f07817055d795d604179c12a8f308ba4c7d56f3719dfea1646", size = 2389089, upload-time = "2026-04-07T11:14:28.635Z" }, + { url = "https://files.pythonhosted.org/packages/65/0d/c47c3872203ae88e6506997c0b576ad731f5261daa25d559be09c9756658/rapidfuzz-3.14.5-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:1e989f86113be66574113b9c7bdf4793f3f863d248e47d911b355e05ca6b6b10", size = 2493404, upload-time = "2026-04-07T11:14:30.577Z" }, + { url = "https://files.pythonhosted.org/packages/8f/2f/71e0a5a3130792146c8a200a2dd1e52aa16f7c1074012e17f2601eea9a90/rapidfuzz-3.14.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:0ebd1a18e2e47bc0b292a07e6ed9c3642f8aaa672d12253885f599b50807a4f9", size = 4251709, upload-time = "2026-04-07T11:14:32.451Z" }, + { url = "https://files.pythonhosted.org/packages/86/45/d39874901abacef325adb5b34ae416817c8486dfb4fb87c7a9b74ec5b072/rapidfuzz-3.14.5-cp312-cp312-win32.whl", hash = "sha256:9981d38a703b86f0e315a3cd229fd1906fe1d91c989ed121fb975b3c849f89f5", size = 1710069, upload-time = "2026-04-07T11:14:34.37Z" }, + { url = "https://files.pythonhosted.org/packages/85/0b/f65572c53de8a1c704bda707f63a447b67bdbe95d7cdc70d18885e191df5/rapidfuzz-3.14.5-cp312-cp312-win_amd64.whl", hash = "sha256:d8375e3da319593389727c3187ccaf3e0e84199accc530866b8e0f2b79af05e9", size = 1540630, upload-time = "2026-04-07T11:14:36.287Z" }, + { url = "https://files.pythonhosted.org/packages/5e/c3/143be3a578f989758cae516f3270d5cbb49783a7bfdf57cc27a670e00456/rapidfuzz-3.14.5-cp312-cp312-win_arm64.whl", hash = "sha256:478b59bb018a6780d73f33e38d0b3ec5e968a6c1ed42876b993dd456b7aa20e8", size = 813137, upload-time = "2026-04-07T11:14:38.289Z" }, + { url = "https://files.pythonhosted.org/packages/11/66/252803f2010ba699618cdc048b6e1f7cc1f433c08b4a9a17579b92ab0142/rapidfuzz-3.14.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:ebd8fd343bf8492a1e60bcb6dc99f90f74f65d98d8241a6b3e1fed225b76ecd6", size = 1940205, upload-time = "2026-04-07T11:14:40.319Z" }, + { url = "https://files.pythonhosted.org/packages/ea/59/b2afd98e41af9cd54554a4c1c423d84cdd60e6b1c0a09496f033b55f60ec/rapidfuzz-3.14.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:6737b35d5af7479c5bf9710f7b17edd9d2c43128d974d25fb4ea653e42c64609", size = 1159639, upload-time = "2026-04-07T11:14:42.52Z" }, + { url = "https://files.pythonhosted.org/packages/a3/31/7aa7e62c4c516a7af322ed0c4f0774208b72d457d0cfec808bad0df12f4a/rapidfuzz-3.14.5-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b002c7994cc9f2bc9d9856f0fbaee6e8072c983873846c92f25cefba5b2a925f", size = 1367194, upload-time = "2026-04-07T11:14:44.25Z" }, + { url = "https://files.pythonhosted.org/packages/90/79/2fc252a63bc91d3c3b234d0a3a6ad4ebc460037a23cdcdaf9285f986e6c9/rapidfuzz-3.14.5-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:17a34330cd2a538c1ce5d400b61ba358c5b72c654b928ff87b362e88f8b864c7", size = 3151805, upload-time = "2026-04-07T11:14:46.21Z" }, + { url = "https://files.pythonhosted.org/packages/17/54/0c83508f2683ea70e2d05f8527eb07328acf7bb1e9d97a3bece5702378e7/rapidfuzz-3.14.5-cp313-cp313-manylinux_2_39_riscv64.whl", hash = "sha256:95d937e74c1a7a1287dfb03b62a827be08ede10a155cf1af73bbf47f2b73ee6e", size = 1455667, upload-time = "2026-04-07T11:14:47.991Z" }, + { url = "https://files.pythonhosted.org/packages/71/1b/070175e873177814d58850a01ebe80e20ae11e93eb4da894d563988660fa/rapidfuzz-3.14.5-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:46b92a9970dcc34f0096901c792644094cab49554ac3547f35e3aebbdf0a3610", size = 2388246, upload-time = "2026-04-07T11:14:50.098Z" }, + { url = "https://files.pythonhosted.org/packages/c9/dd/77caf7aaf9c2be050ad1f128d7c24ff0f59079aa62c5f62f9df41c0af45e/rapidfuzz-3.14.5-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:e012177c8e8a8a0754ae0d6027d63042aa5ff036d9f40f07cb3466a6082e21b8", size = 2494333, upload-time = "2026-04-07T11:14:52.303Z" }, + { url = "https://files.pythonhosted.org/packages/2c/e2/dd7e1f2aa31a8fbbfc16b0610af1d770ffaf1287490f3c8c5b1c52da264f/rapidfuzz-3.14.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a2ae6f53f99c9a0eca7a0afc5b4e45fc73bc1dd4ac74c00509031d76df80ed98", size = 4258579, upload-time = "2026-04-07T11:14:54.538Z" }, + { url = "https://files.pythonhosted.org/packages/9c/0a/ac99e1ba347ba0e85e0bb60b74231d55fb93c0eff43f2920ccb413d0be08/rapidfuzz-3.14.5-cp313-cp313-win32.whl", hash = "sha256:4a60f0057231188e3bd30216f7b4e0f279b11fa4ec818bb6c1d9f014d1562fbc", size = 1709231, upload-time = "2026-04-07T11:14:56.524Z" }, + { url = "https://files.pythonhosted.org/packages/cf/cb/0e251d731b3166378644238e8f0cf9e89858c024e19f75ca9f7e3ae83fd5/rapidfuzz-3.14.5-cp313-cp313-win_amd64.whl", hash = "sha256:11bfc2ed8fbe4ab86bd516fadefab126f90e6dcadffa761739fcb304707dfd35", size = 1538519, upload-time = "2026-04-07T11:14:58.635Z" }, + { url = "https://files.pythonhosted.org/packages/30/6f/4548132acc947db6d5346a248e44a8b3a22d608ef30e770fb578caaf2d00/rapidfuzz-3.14.5-cp313-cp313-win_arm64.whl", hash = "sha256:b486b5218808f6f4dc471b114b1054e63553db69705c97da0271f47bd706aedd", size = 812628, upload-time = "2026-04-07T11:15:00.552Z" }, + { url = "https://files.pythonhosted.org/packages/00/60/69b177577290c5eab892c6f75fe89c3aff3f9ae80298a78d9372b1cecb9a/rapidfuzz-3.14.5-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:39ef8658aaf67d51667e7bdaf7096f432333377d8302ac43c70b5df8a4cf89b8", size = 1970231, upload-time = "2026-04-07T11:15:02.603Z" }, + { url = "https://files.pythonhosted.org/packages/48/38/2fd790052659cc4e2907b63c25433f0987864b445c1aeec1a302ef5ad948/rapidfuzz-3.14.5-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:9ad37a0be705b544af6296da8edddc260d10a8ae5462530fc9991f66498bb1f9", size = 1194394, upload-time = "2026-04-07T11:15:04.572Z" }, + { url = "https://files.pythonhosted.org/packages/80/f4/28430ad8472fc3536e8ebd51a864a226e979cfe924c6e3f83d111373aa74/rapidfuzz-3.14.5-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d45e06f60729e07d9b20c205f7e5cff90b6ef2584e852eecf46e045aea69627d", size = 1377051, upload-time = "2026-04-07T11:15:06.728Z" }, + { url = "https://files.pythonhosted.org/packages/77/7e/9aeacabcfd1e77397968362e5b98fe14248b8307011136b17daf99752a8e/rapidfuzz-3.14.5-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e52da10236aa6212de71b9e170bace65b64b129c0dea7fc243d6c9ce976f5074", size = 3160565, upload-time = "2026-04-07T11:15:08.667Z" }, + { url = "https://files.pythonhosted.org/packages/56/f4/db4dd7be0cd2f2022117ac5407d905f435d60e48baaea313a567ad27e865/rapidfuzz-3.14.5-cp313-cp313t-manylinux_2_39_riscv64.whl", hash = "sha256:440d30faaf682ca496170a7f0cc5453ec942e3e079f0fd802c9a7f938dfb50a3", size = 1442113, upload-time = "2026-04-07T11:15:11.138Z" }, + { url = "https://files.pythonhosted.org/packages/a4/99/0e9f6aa57f3e32a767216f797e56dc96b720fcecfb9d8ee907ecc82f8d66/rapidfuzz-3.14.5-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:56227a61fd3d17b0cd9793132431f3a3d07c8654be96794ba9f89fe0fc8b2d09", size = 2396618, upload-time = "2026-04-07T11:15:13.154Z" }, + { url = "https://files.pythonhosted.org/packages/60/94/44a78e39ffce17cbdd3e2b53b696acc751d5d153be0f499d052b07a4d904/rapidfuzz-3.14.5-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:2e83cd2e25bb4edd97b689d9979d9c3acccdaaf26ceac08212ceece202febcfa", size = 2478220, upload-time = "2026-04-07T11:15:15.193Z" }, + { url = "https://files.pythonhosted.org/packages/dd/df/454311469a09a507e9d784a35796742bec22e4cebe75551e2da4e0e290fd/rapidfuzz-3.14.5-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:af3b859726cd3374287e405e14b9634563c078c5531a4f62375508addebddad1", size = 4265027, upload-time = "2026-04-07T11:15:17.28Z" }, + { url = "https://files.pythonhosted.org/packages/fc/01/175465a9ab3e3b70ba669058372f009d1d49c1746e2dcd56b69df188d3a5/rapidfuzz-3.14.5-cp313-cp313t-win32.whl", hash = "sha256:8ce1d850b3c0178440efde9e884d98421b5e87ff925f364d6d79e23910d7593f", size = 1766814, upload-time = "2026-04-07T11:15:19.687Z" }, + { url = "https://files.pythonhosted.org/packages/1b/a0/a9b84a47af06ebed94a1439eb2f02adebfb8628bcd30af1fe3e02f5ef56c/rapidfuzz-3.14.5-cp313-cp313t-win_amd64.whl", hash = "sha256:c84af70bcf34e99aee894e46a0f1ac77f17d0ef828179c387407642e2466d28a", size = 1582448, upload-time = "2026-04-07T11:15:21.98Z" }, + { url = "https://files.pythonhosted.org/packages/1e/f1/5937800238b3f8248e70860d79f69ba8f73e764fff47e36bc9e2f26dbcc6/rapidfuzz-3.14.5-cp313-cp313t-win_arm64.whl", hash = "sha256:aac0ad28c686a5e72b81668b906c030ee28050b244544b8af68e12fb32543895", size = 832932, upload-time = "2026-04-07T11:15:24.358Z" }, + { url = "https://files.pythonhosted.org/packages/81/41/aa3ffb3355e62e1bf91f6599b3092e866bc88487a07c524004943c7676df/rapidfuzz-3.14.5-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:1a31cc6d7d03e7318a0974c038959c59e19c752b81115f2e9138b3331cd64d45", size = 1943327, upload-time = "2026-04-07T11:15:26.266Z" }, + { url = "https://files.pythonhosted.org/packages/2d/e1/c2141f1840a41e07ad2db6f724945f8f8ff3065463899a22939152dd6e09/rapidfuzz-3.14.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0298d357e2bc59d572da4db0bc631009b6f8f6c9bc8c11e99a12b833f16b6575", size = 1161755, upload-time = "2026-04-07T11:15:28.659Z" }, + { url = "https://files.pythonhosted.org/packages/ca/07/66e753eeaa353161d1d331b7dd517bb349b0bacfebe8496d7b26be26f81f/rapidfuzz-3.14.5-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:59b3dba758661a318995655435c6ab20a04ade79fa51e75bc8dc107cac8df280", size = 1376571, upload-time = "2026-04-07T11:15:31.225Z" }, + { url = "https://files.pythonhosted.org/packages/c8/85/9535df0b78ba51f478c9ce7eb6d1f85535cc31fe356773b48fd9d3e563ca/rapidfuzz-3.14.5-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4900143d82071bdda533b00300c40b14b963ff826b3642cc463b6dd0f036585e", size = 3156468, upload-time = "2026-04-07T11:15:33.428Z" }, + { url = "https://files.pythonhosted.org/packages/81/ee/b667eb93bba6dc4e0de658edd778e1619dc4d6aab68fa5e5c7f075152735/rapidfuzz-3.14.5-cp314-cp314-manylinux_2_39_riscv64.whl", hash = "sha256:feedf219672eef83ea6be6f3bb093bba396a8560fc75be85ba225f082903df0a", size = 1458311, upload-time = "2026-04-07T11:15:35.557Z" }, + { url = "https://files.pythonhosted.org/packages/7d/ce/479074f5624364a48df3403c538797ef22d3ac49c19dc76c3f79fcdcc70c/rapidfuzz-3.14.5-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:419e4397a36e2665ec992d8d64c20ba4b2a42500c76ecadeca78a4f19cb9cc32", size = 2398228, upload-time = "2026-04-07T11:15:37.669Z" }, + { url = "https://files.pythonhosted.org/packages/0b/15/a8982f649150fffbdcd6f17565974501f6ab33b2795267bffbd4a7ba905b/rapidfuzz-3.14.5-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:97131ab2be39043054ee28d99e09efe316e6d53449b7e962dfcf3c2de8b2b246", size = 2497226, upload-time = "2026-04-07T11:15:39.857Z" }, + { url = "https://files.pythonhosted.org/packages/19/52/5267c03ef6759831b7d4625a0c9c06e87baa2fae084b61ac9c388858317b/rapidfuzz-3.14.5-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:593c00dac4e30231c35bf3b4f1da8ec0998762e9e94425586a5d636fcd57f9d0", size = 4262283, upload-time = "2026-04-07T11:15:42.279Z" }, + { url = "https://files.pythonhosted.org/packages/71/c0/2579f343a97f5254c43bb5853baccc01488357dcb64a27bcb869b7888a4a/rapidfuzz-3.14.5-cp314-cp314-win32.whl", hash = "sha256:0084b687b02b4e569b46d8d6d4ad25659528e6081cd6d067ca453a69035f07e4", size = 1744614, upload-time = "2026-04-07T11:15:44.498Z" }, + { url = "https://files.pythonhosted.org/packages/17/eb/8edfed1e80119dc9c35b11df4bc701eea85622ad681fff0263b6961d3224/rapidfuzz-3.14.5-cp314-cp314-win_amd64.whl", hash = "sha256:5dfa89d78f22cd773054caff44827b846161a29f2dcf7e78b8f90d086621e502", size = 1588971, upload-time = "2026-04-07T11:15:46.86Z" }, + { url = "https://files.pythonhosted.org/packages/f6/04/5676df93c85cfa57a3045d8047318df9f3cd58c7b8a99340dd95f874795e/rapidfuzz-3.14.5-cp314-cp314-win_arm64.whl", hash = "sha256:67f3f9d2b444268ab53e47d31bab89954888d23c04c6789f2c727e51fe4b1d13", size = 834985, upload-time = "2026-04-07T11:15:49.411Z" }, + { url = "https://files.pythonhosted.org/packages/f7/0d/4a8988cea658fe335048ddef8c876addff1b6daa3c9ca8ad65a5a2196e69/rapidfuzz-3.14.5-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:77eac0526899b3c3ad1454bb2b03cdb491d67358ec8ef0c9c48bd61b632b431d", size = 1972517, upload-time = "2026-04-07T11:15:51.819Z" }, + { url = "https://files.pythonhosted.org/packages/1c/a3/f5cfd9965a9d9a9e32249159797c47b5d6299ea6d1629f9126b25f1c10a3/rapidfuzz-3.14.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b9c6bd754d11f6e78ac54e3d86b4b11dc1ba2f13e5fc958899574532897f5a99", size = 1196056, upload-time = "2026-04-07T11:15:54.292Z" }, + { url = "https://files.pythonhosted.org/packages/64/07/561c2e40cfd10e6630a7b0ac5a2a813aef50d944bcd1f3d260319d659d5b/rapidfuzz-3.14.5-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:738c96944d076deeaff70e92b65696ab4f7ecb8081d7791c5403a3257dfaf8ff", size = 1374732, upload-time = "2026-04-07T11:15:56.584Z" }, + { url = "https://files.pythonhosted.org/packages/c2/39/123bb94fee40e2fb3b7c49b80827c7ef42d838e18def3fc2fef5a3cf817a/rapidfuzz-3.14.5-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f4c1bca487a17fe4226b4ffb2d30e799d2b274d692cffa76bd0746f56235fca3", size = 3166902, upload-time = "2026-04-07T11:15:58.768Z" }, + { url = "https://files.pythonhosted.org/packages/75/0a/45716fafc9fd2e028cf20b5ac5bc704887081cd312f84edb0e325599414b/rapidfuzz-3.14.5-cp314-cp314t-manylinux_2_39_riscv64.whl", hash = "sha256:af6a90a4ed2a48fa1a2d17e9d824e6c7c950bea5bad0b707c77fd55751e6bfef", size = 1452130, upload-time = "2026-04-07T11:16:01.453Z" }, + { url = "https://files.pythonhosted.org/packages/ca/49/4e96c413114398481c0a5b0086af32c364a18613c9a2ea578d17c4bea4ee/rapidfuzz-3.14.5-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:bf5018938208d4597b2e679a4f8cff9fd252f1df53583130ae56281a21801b64", size = 2396308, upload-time = "2026-04-07T11:16:03.588Z" }, + { url = "https://files.pythonhosted.org/packages/89/b7/49fea9fc6878d59bd259d01dd1972d9b86117992b1c66d9b16f0a65273c3/rapidfuzz-3.14.5-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:c0919d1f89ddf91129906705723118ea09754171e4116f5a5dbc667c7bc9b261", size = 2488210, upload-time = "2026-04-07T11:16:05.871Z" }, + { url = "https://files.pythonhosted.org/packages/0c/44/a1f732b93ffacbdad077b7c801149549b2938e1bece6addb5ad85ed74df8/rapidfuzz-3.14.5-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:93d8da883a35116d6813432177f35e570db5b0a5e30ecb0cbd7cb39c815735df", size = 4270621, upload-time = "2026-04-07T11:16:08.483Z" }, + { url = "https://files.pythonhosted.org/packages/bb/ce/ff942d19fce5385054650bb71a58495ddda299d94661ccc4e6e7fa44868b/rapidfuzz-3.14.5-cp314-cp314t-win32.whl", hash = "sha256:0f23e37019ec07712d58976b1ab2b889f8649a7f7c2f626a2f34ea9139e79279", size = 1803950, upload-time = "2026-04-07T11:16:10.873Z" }, + { url = "https://files.pythonhosted.org/packages/5c/0f/9aafc63f9661222b819b391c187eed29fc90ad5935f9690e5ecc2d2047a4/rapidfuzz-3.14.5-cp314-cp314t-win_amd64.whl", hash = "sha256:7d5ca9c7832e6879a707296d1463685f7c243a27846227044504741640caec66", size = 1632357, upload-time = "2026-04-07T11:16:13.1Z" }, + { url = "https://files.pythonhosted.org/packages/70/a6/51fc1b0e61e3326e1c68a61cfd0c6b3c34c843681c4b1eefbf0596f59162/rapidfuzz-3.14.5-cp314-cp314t-win_arm64.whl", hash = "sha256:3e91dcd2549b8f8d843f98ba03a17e01f3d8b72ce942adbbb6761bc58ffce813", size = 855409, upload-time = "2026-04-07T11:16:15.787Z" }, + { url = "https://files.pythonhosted.org/packages/d9/ee/e71853bf82846c5c2174b924b71d8e8099fb05ff87c958a720380b434ba3/rapidfuzz-3.14.5-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:578e6051f6d5e6200c259b47a103cf06bb875ab5814d17333fc0b5c290b22f4c", size = 1888603, upload-time = "2026-04-07T11:16:18.223Z" }, + { url = "https://files.pythonhosted.org/packages/36/82/40f67b730f32be2ebad9f62add1571c754f52249254b2e88af094b907eee/rapidfuzz-3.14.5-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:fbf1b8bb2695415b347f3727da1addca2acb82c9b97ac86bebf8b1bead1eb12d", size = 1120599, upload-time = "2026-04-07T11:16:20.682Z" }, + { url = "https://files.pythonhosted.org/packages/ef/9f/a3635cc4ec8fc6e14b46e7db1f7f8763d8c4bef33dcc124eea2e6cb2c8f3/rapidfuzz-3.14.5-pp311-pypy311_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8f4a8f5cc84c7ad6bffa0e9947b33eb343ad66e6b53e94fe54378a5508c5ed53", size = 1348524, upload-time = "2026-04-07T11:16:23.451Z" }, + { url = "https://files.pythonhosted.org/packages/cc/1b/2b229520f0b48464cfcd7aa758f74551d12c9bc4ab544022a60210aab064/rapidfuzz-3.14.5-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:97c6d85283629646fa87acc22c66b30ea9d4de7f6fdf887daa2e30fa041829b5", size = 3099302, upload-time = "2026-04-07T11:16:25.858Z" }, + { url = "https://files.pythonhosted.org/packages/aa/b5/363906b1064fc6fe611783a61764927bbd91919aaaabe8cba82151ca93ef/rapidfuzz-3.14.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:dfef96543ced67d9513a422755db422ae1dc34dade0a1485e0b43e7342ed3ebf", size = 1509889, upload-time = "2026-04-07T11:16:28.487Z" }, +] + [[package]] name = "spiele-redaktion" version = "0.1.0" @@ -762,6 +841,7 @@ dependencies = [ { name = "itsdangerous" }, { name = "jinja2" }, { name = "python-multipart" }, + { name = "rapidfuzz" }, { name = "sqlalchemy" }, { name = "uvicorn", extra = ["standard"] }, ] @@ -781,6 +861,7 @@ requires-dist = [ { name = "itsdangerous", specifier = ">=2.1" }, { name = "jinja2", specifier = ">=3.1" }, { name = "python-multipart", specifier = ">=0.0.9" }, + { name = "rapidfuzz", specifier = ">=3.14.5" }, { name = "sqlalchemy", specifier = ">=2.0" }, { name = "uvicorn", extras = ["standard"], specifier = ">=0.30" }, ]