Popup Fenster nach Vorne

views/tabs/generator_tab_factory.py

@@ -0,0 +1,185 @@
+"""
+Factory Pattern für die Erstellung plattform-spezifischer Generator-Tabs.
+Clean Architecture Implementation für erweiterbare Tab-Generierung.
+"""
+
+import logging
+from typing import Optional, Dict, Type
+from PyQt5.QtWidgets import QWidget
+
+# Base imports
+from views.tabs.generator_tab import GeneratorTab
+
+logger = logging.getLogger("generator_tab_factory")
+
+
+class GeneratorTabFactory:
+    """
+    Factory-Klasse zur Erstellung plattform-spezifischer Generator-Tabs.
+    
+    Diese Factory verwendet das Strategy Pattern intern, um verschiedene
+    Tab-Implementierungen basierend auf der Plattform zu erstellen.
+    Neue Plattformen können einfach durch Hinzufügen zur Registry erweitert werden.
+    """
+    
+    # Registry für plattform-spezifische Tabs
+    # Key: Plattform-Name (lowercase), Value: Tab-Klasse
+    _tab_registry: Dict[str, Type[QWidget]] = {}
+    
+    @classmethod
+    def register_tab(cls, platform: str, tab_class: Type[QWidget]) -> None:
+        """
+        Registriert eine Tab-Klasse für eine bestimmte Plattform.
+        
+        Args:
+            platform: Name der Plattform (wird zu lowercase konvertiert)
+            tab_class: Die Tab-Klasse für diese Plattform
+        """
+        platform_lower = platform.lower()
+        cls._tab_registry[platform_lower] = tab_class
+        logger.info(f"Tab-Klasse {tab_class.__name__} für Plattform '{platform}' registriert")
+    
+    @classmethod
+    def create_tab(cls, platform: str, language_manager: Optional[object] = None) -> QWidget:
+        """
+        Erstellt einen Generator-Tab für die angegebene Plattform.
+        
+        Diese Methode verwendet Lazy Loading für plattform-spezifische Tabs,
+        um zirkuläre Imports zu vermeiden und die Performance zu optimieren.
+        
+        Args:
+            platform: Name der Plattform
+            language_manager: Optionaler Language Manager für Internationalisierung
+            
+        Returns:
+            QWidget: Der erstellte Generator-Tab
+            
+        Raises:
+            ValueError: Wenn die Plattform nicht unterstützt wird
+        """
+        platform_lower = platform.lower()
+        
+        # Lazy Loading und Registrierung für bekannte Plattformen
+        if platform_lower not in cls._tab_registry:
+            cls._lazy_load_platform_tab(platform_lower)
+        
+        # Tab-Klasse aus Registry holen
+        tab_class = cls._tab_registry.get(platform_lower)
+        
+        if tab_class:
+            logger.info(f"Erstelle {tab_class.__name__} für Plattform '{platform}'")
+            try:
+                return tab_class(platform, language_manager)
+            except Exception as e:
+                logger.error(f"Fehler beim Erstellen des Tabs für '{platform}': {e}")
+                logger.info(f"Fallback auf generischen GeneratorTab für '{platform}'")
+                return GeneratorTab(platform, language_manager)
+        else:
+            # Fallback auf generischen Tab
+            logger.info(f"Verwende generischen GeneratorTab für Plattform '{platform}'")
+            return GeneratorTab(platform, language_manager)
+    
+    @classmethod
+    def _lazy_load_platform_tab(cls, platform: str) -> None:
+        """
+        Lädt plattform-spezifische Tab-Klassen lazy (bei Bedarf).
+        
+        Dies vermeidet zirkuläre Imports und verbessert die Startzeit,
+        indem nur benötigte Module geladen werden.
+        
+        Args:
+            platform: Name der Plattform (lowercase)
+        """
+        try:
+            if platform == "facebook":
+                from views.tabs.facebook_generator_tab import FacebookGeneratorTab
+                cls.register_tab("facebook", FacebookGeneratorTab)
+                
+            elif platform == "instagram":
+                # Instagram verwendet möglicherweise einen spezifischen Tab
+                # Vorerst den generischen Tab verwenden
+                cls.register_tab("instagram", GeneratorTab)
+                
+            elif platform == "tiktok":
+                # TikTok könnte einen eigenen Tab haben
+                # Prüfe ob TikTokGeneratorTab existiert
+                try:
+                    from views.tabs.tiktok_generator_tab import TikTokGeneratorTab
+                    cls.register_tab("tiktok", TikTokGeneratorTab)
+                except ImportError:
+                    # Fallback auf generischen Tab
+                    cls.register_tab("tiktok", GeneratorTab)
+                    
+            elif platform == "x":
+                # X (Twitter) Tab
+                try:
+                    from views.tabs.x_generator_tab import XGeneratorTab
+                    cls.register_tab("x", XGeneratorTab)
+                except ImportError:
+                    cls.register_tab("x", GeneratorTab)
+                    
+            else:
+                # Unbekannte Plattform - verwende generischen Tab
+                cls.register_tab(platform, GeneratorTab)
+                
+        except ImportError as e:
+            logger.warning(f"Konnte spezifischen Tab für '{platform}' nicht laden: {e}")
+            # Registriere generischen Tab als Fallback
+            cls.register_tab(platform, GeneratorTab)
+    
+    @classmethod
+    def get_supported_platforms(cls) -> list:
+        """
+        Gibt eine Liste der unterstützten Plattformen zurück.
+        
+        Returns:
+            list: Liste der Plattform-Namen
+        """
+        # Bekannte Plattformen, die lazy geladen werden können
+        known_platforms = ["facebook", "instagram", "tiktok", "x"]
+        
+        # Bereits registrierte Plattformen hinzufügen
+        registered = list(cls._tab_registry.keys())
+        
+        # Kombiniere und entferne Duplikate
+        all_platforms = list(set(known_platforms + registered))
+        all_platforms.sort()
+        
+        return all_platforms
+    
+    @classmethod
+    def is_platform_supported(cls, platform: str) -> bool:
+        """
+        Prüft, ob eine Plattform unterstützt wird.
+        
+        Args:
+            platform: Name der Plattform
+            
+        Returns:
+            bool: True wenn unterstützt, sonst False
+        """
+        return platform.lower() in cls.get_supported_platforms()
+    
+    @classmethod
+    def clear_registry(cls) -> None:
+        """
+        Löscht die Tab-Registry.
+        Hauptsächlich für Tests und Cleanup.
+        """
+        cls._tab_registry.clear()
+        logger.debug("Tab-Registry gelöscht")
+
+
+# Convenience-Funktion für direkten Import
+def create_generator_tab(platform: str, language_manager: Optional[object] = None) -> QWidget:
+    """
+    Convenience-Funktion zum Erstellen eines Generator-Tabs.
+    
+    Args:
+        platform: Name der Plattform
+        language_manager: Optionaler Language Manager
+        
+    Returns:
+        QWidget: Der erstellte Generator-Tab
+    """
+    return GeneratorTabFactory.create_tab(platform, language_manager)