Files
tsumugu/backend/app/sourceregistry.py
T
StommerandClaude Sonnet 5.5 5e32ba547d
Deploy Development / deploy (push) Successful in 42s
Test Suite / pytest-backend (push) Successful in 5m50s
Test Suite / smoke-dev (push) Successful in 0s
Test Suite / frontend-build (push) Successful in 22s
Verlege die Paperless-Suchparameter und das Vorschaubild in das Modul und korrigiere das Handy-Layout der großen Auswahl.
Die gemeinsame Suchroute kennt keine Filternamen mehr; das Modul deklariert sie und unbekannte Parameter werden abgewiesen. Unvollständige Zusatzfeld-Zeilen werden gemeldet statt weggelassen. Vorschaubilder nur als Rastergrafik. Abschlussmatrix und API-Referenz nachgeführt.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-24 22:10:54 +02:00

168 lines
5.6 KiB
Python

"""Registered source modules. Unknown kinds are rejected, not guessed."""
from __future__ import annotations
from dataclasses import dataclass, field
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
# Query parameter of a search, mapped to the capability flag that must be true for it.
# The module owns its filter names. Anything not declared here is refused.
search_params: dict[str, str] = field(default_factory=dict)
# thumbnail(conn, owner_id, connector_id, item) -> (bytes, media type), when the module declares it.
thumbnail: 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