Architektur-Übersicht¶

Dieses Dokument bietet einen Überblick über die Architektur und Designentscheidungen von Weeb CLI.

Systemarchitektur¶

┌─────────────────────────────────────────────────────────┐
│                   CLI-Schicht (Typer)                    │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌─────────┐ │
│  │  Suche   │  │Downloads │  │Watchlist │  │Einst.   │ │
│  └──────────┘  └──────────┘  └──────────┘  └─────────┘ │
└─────────────────────────────────────────────────────────┘
                          │
┌─────────────────────────────────────────────────────────┐
│                   Service-Schicht                        │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌─────────┐ │
│  │Downloader│  │ Tracker  │  │  Player  │  │  Cache  │ │
│  └──────────┘  └──────────┘  └──────────┘  └─────────┘ │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐              │
│  │ Database │  │  Scraper │  │  Logger  │              │
│  └──────────┘  └──────────┘  └──────────┘              │
└─────────────────────────────────────────────────────────┘
                          │
┌─────────────────────────────────────────────────────────┐
│                  Provider-Schicht                        │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌─────────┐ │
│  │Türkisch  │  │ Englisch │  │  Deutsch │  │ Polnisch│ │
│  │Provider  │  │ Provider │  │ Provider │  │ Provider│ │
│  └──────────┘  └──────────┘  └──────────┘  └─────────┘ │
└─────────────────────────────────────────────────────────┘
                          │
┌─────────────────────────────────────────────────────────┐
│                    Datenschicht                          │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐              │
│  │  SQLite  │  │   Cache  │  │   Logs   │              │
│  │ Database │  │  Dateien │  │ Dateien  │              │
│  └──────────┘  └──────────┘  └──────────┘              │
└─────────────────────────────────────────────────────────┘

Design-Muster¶

1. Registry-Muster (Provider)¶

Provider werden automatisch mit Dekoratoren entdeckt und registriert:

@register_provider("animecix", lang="tr", region="TR")
class AnimecixProvider(BaseProvider):
    pass

Vorteile: - Einfaches Hinzufügen neuer Provider - Keine manuelle Registrierung erforderlich - Automatische Erkennung aus Dateisystem

2. Lazy Loading (Services)¶

Services verwenden Lazy Loading zur verzögerten Initialisierung:

@property
def db(self):
    if self._db is None:
        from weeb_cli.services.database import db
        self._db = db
    return self._db

Vorteile: - Schnellere Startzeit - Reduzierte Speichernutzung - Vermeidung zirkulärer Importe

3. Singleton-Muster (Globale Instanzen)¶

Globale Instanzen für gemeinsame Ressourcen:

config = Config()
i18n = I18n()
cache = CacheManager()

Vorteile: - Einzige Quelle der Wahrheit - Einfacher Zugriff in der gesamten Anwendung - Konsistenter Zustand

4. Strategy-Muster (Download-Methoden)¶

Mehrere Download-Strategien mit Fallback:

def _try_download(self, url, path, item):
    strategies = [
        self._download_aria2,
        self._download_ytdlp,
        self._download_ffmpeg,
        self._download_generic
    ]
    for strategy in strategies:
        if strategy(url, path, item):
            return True
    return False

Vorteile: - Graceful Degradation - Flexible Download-Methoden - Einfaches Hinzufügen neuer Strategien

Hauptkomponenten¶

CLI-Schicht¶

Technologie: Typer + Rich + Questionary

Verantwortlichkeiten: - Befehlszeilenargumente parsen - Interaktive Menüs anzeigen - Benutzereingaben verarbeiten - Fortschrittsindikatoren anzeigen

Service-Schicht¶

Kern-Services:

Database: SQLite mit WAL-Modus
Konfigurationsspeicherung
Fortschrittsverfolgung
Download-Warteschlange
Lokaler Bibliotheksindex
Downloader: Warteschlangenbasierter Download-Manager
Gleichzeitige Downloads
Mehrere Download-Methoden
Wiederholungslogik
Fortschrittsverfolgung
Tracker: Anime-Tracking-Integration
OAuth-Authentifizierung
Fortschrittssynchronisierung
Offline-Warteschlange
Player: MPV-Integration
IPC-Kommunikation
Fortschrittsüberwachung
Fortsetzungsfunktionalität
Cache: Zweistufiges Caching
Speicher-Cache
Datei-Cache
TTL-Unterstützung

Provider-Schicht¶

Struktur: - Sprachlich organisierte Verzeichnisse - Basis-Provider-Schnittstelle - Registry-System - Stream-Extraktoren

Provider-Lebenszyklus: 1. Erkennung (Dateisystem-Scan) 2. Registrierung (Dekorator) 3. Instanziierung (auf Anfrage) 4. Caching (Ergebnisse)

Datenschicht¶

Speicherung: - SQLite-Datenbank (~/.weeb-cli/weeb.db) - Cache-Dateien (~/.weeb-cli/cache/) - Log-Dateien (~/.weeb-cli/logs/) - Heruntergeladene Binärdateien (~/.weeb-cli/bin/)

Datenfluss¶

Suchfluss¶

Benutzereingabe → CLI → Scraper → Provider → Cache → API
                                      ↓
                                  Ergebnisse
                                      ↓
                                CLI-Anzeige

Download-Fluss¶

Benutzerauswahl → Warteschlangen-Manager → Download-Worker
                                                ↓
                                        Strategien versuchen
                                                ↓
                         ┌─────────────────────────┐
                         │  Aria2 → yt-dlp →       │
                         │  FFmpeg → Generic       │
                         └─────────────────────────┘
                                                ↓
                                        Fortschritt aktualisieren
                                                ↓
                                        In Datenbank speichern

Wiedergabefluss¶

Benutzerauswahl → Stream-Extraktion → Player (MPV)
                                          ↓
                                   IPC-Monitor
                                          ↓
                                  Fortschritt speichern
                                          ↓
                                  Tracker synchronisieren

Thread-Sicherheit¶

Locking-Strategie¶

Database: RLock für Verbindungsverwaltung
Download-Warteschlange: Lock für Warteschlangenoperationen
Cache: Kein Locking (Single-Threaded-Zugriff)

Gleichzeitige Operationen¶

Download-Worker laufen in separaten Threads
MPV-Monitor läuft in Daemon-Thread
Tracker-Sync läuft im Hintergrund

Fehlerbehandlung¶

Exception-Hierarchie¶

WeebCLIError (Basis)
├── ProviderError
├── DownloadError
├── NetworkError
├── AuthenticationError
├── DatabaseError
├── ValidationError
└── DependencyError

Fehlerwiederherstellung¶

Wiederholungslogik: Exponentieller Backoff für vorübergehende Fehler
Fallback: Alternative Methoden bei Primärausfall
Graceful Degradation: Mit reduzierter Funktionalität fortfahren
Benutzerbenachrichtigung: Klare Fehlermeldungen mit i18n

Leistungsoptimierungen¶

1. Caching¶

Suchergebnisse für 1 Stunde gecacht
Details für 6 Stunden gecacht
Zweistufig (Speicher + Datei) für Geschwindigkeit

2. Lazy Loading¶

Services bei erster Verwendung geladen
Provider bei Bedarf entdeckt
Datenbank-Verbindungspooling

3. Gleichzeitige Downloads¶

Mehrere Downloads parallel
Konfigurierbares Gleichzeitigkeitslimit
Ressourcenbewusste Planung

4. Datenbankoptimierung¶

WAL-Modus für gleichzeitigen Zugriff
Vorbereitete Anweisungen
Indizierte Abfragen
Batch-Operationen

Sicherheitsüberlegungen¶

1. Eingabebereinigung¶

Dateinamenbereinigung
URL-Validierung
SQL-Injection-Prävention (parametrisierte Abfragen)

2. Anmeldedatenspeicherung¶

OAuth-Token in Datenbank
Keine Klartext-Passwörter
Sichere Token-Aktualisierung

3. Netzwerksicherheit¶

HTTPS für API-Aufrufe
Zertifikatsüberprüfung
Timeout-Limits

Erweiterbarkeit¶

Neue Features hinzufügen¶

Neuer Provider: BaseProvider-Schnittstelle implementieren
Neuer Tracker: TrackerBase-Schnittstelle implementieren
Neuer Befehl: Typer-Befehl hinzufügen
Neuer Service: Service-Muster folgen

Plugin-System¶

Derzeit nicht implementiert, aber Architektur unterstützt: - Provider-Plugins - Extraktor-Plugins - Befehls-Plugins

Zukünftige Verbesserungen¶

Plugin-System: Dynamisches Plugin-Laden
API-Server: REST-API für Fernsteuerung
Web-UI: Browserbasierte Schnittstelle
Mobile App: Begleit-Mobile-Anwendung
Cloud-Sync: Geräteübergreifende Synchronisierung