Initial commit

browser/playwright_extensions.py

@@ -0,0 +1,127 @@
+# browser/playwright_extensions.py
+
+"""
+Erweiterungen für den PlaywrightManager - Fügt zusätzliche Funktionalität hinzu
+"""
+
+import logging
+from typing import Dict, Any, Optional
+from browser.fingerprint_protection import FingerprintProtection
+
+logger = logging.getLogger("playwright_extensions")
+
+class PlaywrightExtensions:
+    """
+    Erweiterungsklasse für den PlaywrightManager.
+    Bietet zusätzliche Funktionalität, ohne die Hauptklasse zu verändern.
+    """
+
+    def __init__(self, playwright_manager):
+        """
+        Initialisiert die Erweiterungsklasse.
+
+        Args:
+            playwright_manager: Eine Instanz des PlaywrightManager
+        """
+        self.playwright_manager = playwright_manager
+        self.fingerprint_protection = None
+        self.enhanced_stealth_enabled = False
+
+    def enable_enhanced_fingerprint_protection(self, config: Optional[Dict[str, Any]] = None) -> bool:
+        """
+        Aktiviert den erweiterten Fingerprint-Schutz.
+
+        Args:
+            config: Optionale Konfiguration für den Fingerprint-Schutz
+
+        Returns:
+            bool: True bei Erfolg, False bei Fehler
+        """
+        try:
+            # Sicherstellen, dass der Browser gestartet wurde
+            if not hasattr(self.playwright_manager, 'context') or self.playwright_manager.context is None:
+                logger.warning("Browser muss zuerst gestartet werden, bevor der Fingerprint-Schutz aktiviert werden kann")
+                return False
+
+            # Basis-Stealth-Konfiguration aus dem PlaywrightManager verwenden
+            stealth_config = getattr(self.playwright_manager, 'stealth_config', {})
+
+            # Mit der benutzerdefinierten Konfiguration erweitern, falls vorhanden
+            if config:
+                stealth_config.update(config)
+
+            # Fingerprint-Schutz initialisieren
+            self.fingerprint_protection = FingerprintProtection(
+                context=self.playwright_manager.context,
+                stealth_config=stealth_config
+            )
+
+            # Schutzmaßnahmen auf den Kontext anwenden
+            self.fingerprint_protection.apply_to_context()
+
+            # Status aktualisieren
+            self.enhanced_stealth_enabled = True
+
+            logger.info("Erweiterter Fingerprint-Schutz aktiviert")
+            return True
+
+        except Exception as e:
+            logger.error(f"Fehler beim Aktivieren des erweiterten Fingerprint-Schutzes: {e}")
+            return False
+
+    def rotate_fingerprint(self, noise_level: Optional[float] = None) -> bool:
+        """
+        Rotiert den Browser-Fingerprint.
+
+        Args:
+            noise_level: Optionales neues Rauschniveau (0.0-1.0)
+
+        Returns:
+            bool: True bei Erfolg, False bei Fehler
+        """
+        if not self.enhanced_stealth_enabled or self.fingerprint_protection is None:
+            logger.warning("Erweiterter Fingerprint-Schutz ist nicht aktiviert")
+            return False
+
+        return self.fingerprint_protection.rotate_fingerprint(noise_level)
+
+    def get_fingerprint_status(self) -> Dict[str, Any]:
+        """
+        Gibt den aktuellen Status des Fingerprint-Schutzes zurück.
+
+        Returns:
+            Dict[str, Any]: Status des Fingerprint-Schutzes
+        """
+        if not self.enhanced_stealth_enabled or self.fingerprint_protection is None:
+            return {"active": False, "message": "Erweiterter Fingerprint-Schutz ist nicht aktiviert"}
+
+        return self.fingerprint_protection.get_fingerprint_status()
+
+    def hook_into_playwright_manager(self) -> None:
+        """
+        Hängt die Erweiterungsmethoden an den PlaywrightManager.
+        """
+        if not self.playwright_manager:
+            logger.error("Kein PlaywrightManager zum Anhängen der Erweiterungen")
+            return
+
+        # Originalstart-Methode speichern
+        original_start = self.playwright_manager.start
+
+        # Die start-Methode überschreiben, um den Fingerprint-Schutz automatisch zu aktivieren
+        def enhanced_start(*args, **kwargs):
+            result = original_start(*args, **kwargs)
+
+            # Wenn start erfolgreich war und erweiterter Schutz aktiviert ist,
+            # wenden wir den Fingerprint-Schutz auf den neuen Kontext an
+            if result and self.enhanced_stealth_enabled and self.fingerprint_protection:
+                self.fingerprint_protection.set_context(self.playwright_manager.context)
+                self.fingerprint_protection.apply_to_context()
+
+            return result
+
+        # Methoden dynamisch zum PlaywrightManager hinzufügen
+        self.playwright_manager.enable_enhanced_fingerprint_protection = self.enable_enhanced_fingerprint_protection
+        self.playwright_manager.rotate_fingerprint = self.rotate_fingerprint
+        self.playwright_manager.get_fingerprint_status = self.get_fingerprint_status
+        self.playwright_manager.start = enhanced_start