Initial commit

domain/services/rate_limit_service.py

@@ -0,0 +1,125 @@
+"""
+Rate Limit Service Interface - Domain Service für Rate Limiting
+"""
+
+from abc import ABC, abstractmethod
+from typing import Optional, List, Dict, Any
+from datetime import datetime, timedelta
+
+from domain.value_objects.action_timing import ActionTiming, ActionType
+from domain.entities.rate_limit_policy import RateLimitPolicy
+
+
+class IRateLimitService(ABC):
+    """
+    Interface für Rate Limit Service.
+    Definiert die Geschäftslogik für adaptives Rate Limiting.
+    """
+    
+    @abstractmethod
+    def calculate_delay(self, action_type: ActionType, context: Optional[Dict[str, Any]] = None) -> float:
+        """
+        Berechnet die optimale Verzögerung für eine Aktion.
+        
+        Args:
+            action_type: Typ der auszuführenden Aktion
+            context: Optionaler Kontext (z.B. Platform, Session-ID)
+            
+        Returns:
+            Verzögerung in Sekunden
+        """
+        pass
+    
+    @abstractmethod
+    def record_action(self, timing: ActionTiming) -> None:
+        """
+        Zeichnet eine ausgeführte Aktion für Analyse auf.
+        
+        Args:
+            timing: Timing-Informationen der Aktion
+        """
+        pass
+    
+    @abstractmethod
+    def detect_rate_limit(self, response: Any) -> bool:
+        """
+        Erkennt ob eine Response auf Rate Limiting hindeutet.
+        
+        Args:
+            response: HTTP Response oder Browser-Seite
+            
+        Returns:
+            True wenn Rate Limit erkannt wurde
+        """
+        pass
+    
+    @abstractmethod
+    def get_policy(self, action_type: ActionType) -> RateLimitPolicy:
+        """
+        Holt die aktuelle Rate Limit Policy für einen Action Type.
+        
+        Args:
+            action_type: Typ der Aktion
+            
+        Returns:
+            Rate Limit Policy
+        """
+        pass
+    
+    @abstractmethod
+    def update_policy(self, action_type: ActionType, policy: RateLimitPolicy) -> None:
+        """
+        Aktualisiert die Rate Limit Policy für einen Action Type.
+        
+        Args:
+            action_type: Typ der Aktion
+            policy: Neue Policy
+        """
+        pass
+    
+    @abstractmethod
+    def get_statistics(self, 
+                      action_type: Optional[ActionType] = None,
+                      timeframe: Optional[timedelta] = None) -> Dict[str, Any]:
+        """
+        Holt Statistiken über Rate Limiting.
+        
+        Args:
+            action_type: Optional - nur für spezifischen Action Type
+            timeframe: Optional - nur für bestimmten Zeitraum
+            
+        Returns:
+            Dictionary mit Statistiken
+        """
+        pass
+    
+    @abstractmethod
+    def reset_statistics(self) -> None:
+        """Setzt alle gesammelten Statistiken zurück."""
+        pass
+    
+    @abstractmethod
+    def is_action_allowed(self, action_type: ActionType) -> bool:
+        """
+        Prüft ob eine Aktion basierend auf Rate Limits erlaubt ist.
+        
+        Args:
+            action_type: Typ der Aktion
+            
+        Returns:
+            True wenn Aktion erlaubt ist
+        """
+        pass
+    
+    @abstractmethod
+    def wait_if_needed(self, action_type: ActionType) -> float:
+        """
+        Wartet die notwendige Zeit bevor eine Aktion ausgeführt werden kann.
+        
+        Args:
+            action_type: Typ der Aktion
+            
+        Returns:
+            Tatsächlich gewartete Zeit in Sekunden
+        """
+        pass