Files
tsumugu/backend/app/sourceregistry.py
T
LarsandClaude Sonnet 5.5 eb58dce4cd
Deploy Development / deploy (push) Successful in 40s
Test Suite / pytest-backend (push) Successful in 3m12s
Test Suite / smoke-dev (push) Successful in 0s
Test Suite / frontend-build (push) Successful in 21s
Führe die Konfigurationsansicht der Connectoren ein, damit Paperless und IMAP ihre Felder selbst deklarieren.
Das Modul liefert ein Feldmanifest und validiert es; ein leeres Geheimnisfeld behält das gespeicherte. Die Oberfläche rendert die Felder generisch in einer Detailansicht je Zugang mit Prüfstand, Fähigkeiten und Verwendung. Die providerspezifischen Formulare in Sources.jsx entfallen, die flachen API-Felder bleiben als Kompatibilität. Das Standardfach eines IMAP-Kontos öffnet der Picker zuerst.

Die Backend-Tests wurden in der Entwicklungsumgebung nicht ausgeführt; der Lauf auf develop steht aus.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-20 09:34:37 +02:00

163 lines
5.2 KiB
Python

"""Registered source modules. Unknown kinds are rejected, not guessed."""
from __future__ import annotations
from dataclasses import dataclass
from typing import Callable
from app.core.errors import unprocessable
FIELD_TYPES = ("text", "url", "number", "password", "select")
@dataclass(frozen=True)
class ConfigField:
"""One configuration field a module declares for its connector instances.
At most one field per module is a secret. Its value is stored apart from
the settings and is never handed out again.
"""
key: str
label: str
type: str = "text"
required: bool = False
secret: bool = False
default: str | int | None = None
options: tuple[tuple[str, str], ...] = ()
help: str = ""
placeholder: str = ""
minimum: int | None = None
maximum: int | None = None
max_length: int = 200
def public(self) -> dict:
return {
"key": self.key,
"label": self.label,
"type": self.type,
"required": self.required,
"secret": self.secret,
"default": self.default,
"options": [{"value": value, "label": label} for value, label in self.options],
"help": self.help,
"placeholder": self.placeholder,
"minimum": self.minimum,
"maximum": self.maximum,
"max_length": self.max_length,
}
@dataclass
class SourceModule:
kind: str
label: str
representation: str
capabilities: dict
probe: Callable
find: Callable
open_original: Callable
export_original: Callable
# A module either declares fields (generic validation) or parses the payload itself.
parse_config: Callable[[dict], tuple[str, dict, str]] | None = None
config_fields: tuple[ConfigField, ...] = ()
normalize_config: Callable[[dict, str], dict] | None = None
navigate: Callable | None = None
preview: Callable | None = None
facets: Callable | None = None
_MODULES: dict[str, SourceModule] = {}
def register_source(module: SourceModule) -> None:
if module.parse_config is None and not module.config_fields:
raise ValueError(f"Quelle {module.kind} braucht Konfigurationsfelder oder parse_config.")
if sum(1 for item in module.config_fields if item.secret) > 1:
raise ValueError(f"Quelle {module.kind} darf höchstens ein Geheimnisfeld haben.")
for item in module.config_fields:
if item.type not in FIELD_TYPES:
raise ValueError(f"Feldtyp {item.type} ist unbekannt.")
_MODULES[module.kind] = module
def unregister_source(kind: str) -> None:
_MODULES.pop(kind, None)
def registered_sources() -> list[SourceModule]:
return list(_MODULES.values())
def get_source(kind: str) -> SourceModule | None:
return _MODULES.get(kind)
def require_source(kind: str) -> SourceModule:
module = _MODULES.get(kind)
if module is None:
raise unprocessable("Diese Quelle ist nicht registriert.")
return module
def accepts_reference(source: str) -> bool:
return source == "url" or source in _MODULES
def _blank(value) -> bool:
return value is None or (isinstance(value, str) and not value.strip())
def _coerce(field: ConfigField, value):
if field.type == "number":
try:
number = int(str(value).strip())
except (TypeError, ValueError):
raise unprocessable(f"{field.label} muss eine ganze Zahl sein.") from None
if field.minimum is not None and number < field.minimum:
raise unprocessable(f"{field.label} ist zu klein.")
if field.maximum is not None and number > field.maximum:
raise unprocessable(f"{field.label} ist zu groß.")
return number
text = str(value) if field.secret else str(value).strip()
if len(text) > field.max_length:
raise unprocessable(f"{field.label} ist zu lang.")
if field.type == "select" and text not in {option for option, _label in field.options}:
raise unprocessable(f"{field.label} ist keine zulässige Auswahl.")
return text
def parse_fields(
fields: tuple[ConfigField, ...],
values: dict,
current_settings: dict | None = None,
current_secret: str = "",
) -> tuple[dict, str]:
"""Validate declared fields. Unknown keys are refused, a blank secret keeps the stored one."""
known = {item.key for item in fields}
extra = sorted(key for key, value in values.items() if key not in known and not _blank(value))
if extra:
raise unprocessable("Unbekanntes Konfigurationsfeld: " + ", ".join(extra[:3]) + ".")
current_settings = current_settings or {}
settings: dict = {}
secret = current_secret
for item in fields:
raw = values.get(item.key)
if item.secret:
if _blank(raw):
if not current_secret and item.required:
raise unprocessable(f"{item.label} fehlt.")
continue
secret = _coerce(item, raw)
continue
if _blank(raw):
raw = current_settings.get(item.key)
if _blank(raw):
raw = item.default
if _blank(raw):
if item.required:
raise unprocessable(f"{item.label} fehlt.")
continue
settings[item.key] = _coerce(item, raw)
return settings, secret