realtimex-deeptutor 0.5.0.post1__py3-none-any.whl

src/utils/error_rate_tracker.py

@@ -0,0 +1,111 @@
+"""
+Error Rate Tracker - Track error rates per provider with alerting.
+"""
+
+from collections import defaultdict, deque
+import logging
+import threading
+import time
+from typing import Callable, Dict, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class ErrorRateTracker:
+    """
+    Tracks error rates per provider with sliding window.
+    """
+
+    def __init__(
+        self,
+        window_size: int = 60,
+        threshold: float = 0.5,
+        alert_callback: Optional[Callable[[str, float], None]] = None,
+    ):
+        self.window_size = window_size  # seconds
+        self.threshold = threshold  # failure rate threshold
+        self.alert_callback = alert_callback
+        self._lock = threading.RLock()  # Use RLock to allow reentrant locking
+        self._errors: Dict[str, deque[float]] = defaultdict(deque)
+        self._total_calls: Dict[str, deque[float]] = defaultdict(deque)
+        self._alerted: Dict[str, bool] = defaultdict(bool)  # to avoid repeated alerts
+
+    def record_call(self, provider: str, success: bool):
+        """Record a call for the provider."""
+        now = time.time()
+        with self._lock:
+            self._total_calls[provider].append(now)
+            if not success:
+                self._errors[provider].append(now)
+            self._cleanup_old_entries(provider, now)
+            self._check_alert(provider)
+
+    def get_error_rate(self, provider: str) -> float:
+        """Get current error rate for provider."""
+        now = time.time()
+        with self._lock:
+            self._cleanup_old_entries(provider, now)
+            total = len(self._total_calls[provider])
+            errors = len(self._errors[provider])
+            return errors / total if total > 0 else 0.0
+
+    def check_threshold(self, provider: str) -> bool:
+        """Check if error rate exceeds threshold."""
+        rate = self.get_error_rate(provider)
+        return rate > self.threshold
+
+    def _check_alert(self, provider: str):
+        """Check and trigger alert if needed."""
+        rate = self.get_error_rate(provider)
+        exceeds_threshold = rate > self.threshold
+        if exceeds_threshold and not self._alerted[provider]:
+            logger.warning(
+                f"Provider {provider} error rate {rate:.2%} exceeds threshold {self.threshold:.2%}"
+            )
+            if self.alert_callback:
+                self.alert_callback(provider, rate)
+            self._alerted[provider] = True
+        elif not exceeds_threshold:
+            self._alerted[provider] = False  # reset when below threshold
+
+    def _cleanup_old_entries(self, provider: str, now: float):
+        """Remove entries older than window_size."""
+        cutoff = now - self.window_size
+        while self._total_calls[provider] and self._total_calls[provider][0] <= cutoff:
+            self._total_calls[provider].popleft()
+        while self._errors[provider] and self._errors[provider][0] <= cutoff:
+            self._errors[provider].popleft()
+
+
+# Global instance
+tracker = ErrorRateTracker()
+
+# Set alert callback to circuit breaker
+try:
+    from .network.circuit_breaker import alert_callback as cb
+
+    tracker.alert_callback = cb
+except ImportError as e:
+    logging.getLogger(__name__).warning(
+        f"Circuit breaker module not available: {e}. Error rate tracking will work but circuit breaker integration is disabled."
+    )
+
+
+def record_provider_call(provider: str, success: bool):
+    """Global function to record a call."""
+    tracker.record_call(provider, success)
+
+
+def get_provider_error_rate(provider: str) -> float:
+    """Get error rate for provider."""
+    return tracker.get_error_rate(provider)
+
+
+def check_provider_threshold(provider: str) -> bool:
+    """Check if provider exceeds threshold."""
+    return tracker.check_threshold(provider)
+
+
+def set_alert_callback(callback: Callable[[str, float], None]):
+    """Set the alert callback for the tracker."""
+    tracker.alert_callback = callback

src/utils/error_utils.py

@@ -0,0 +1,82 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Error Utilities - Error formatting and handling utilities
+"""
+
+import json
+from typing import Optional
+
+
+def _find_json_block(message: str) -> Optional[str]:
+    """Extract potential JSON block from message by matching braces."""
+    start_idx = message.find("{")
+    if start_idx == -1:
+        return None
+
+    brace_count = 0
+    in_string = False
+    escape_next = False
+
+    for char_idx in range(start_idx, len(message)):
+        char = message[char_idx]
+
+        if escape_next:
+            escape_next = False
+            continue
+
+        if char == "\\":
+            escape_next = True
+            continue
+
+        if char == '"':
+            in_string = not in_string
+            continue
+
+        if not in_string:
+            if char == "{":
+                brace_count += 1
+            elif char == "}":
+                brace_count -= 1
+                if brace_count == 0:
+                    return message[start_idx : char_idx + 1]
+
+    return None
+
+
+def format_exception_message(exc: Exception) -> str:
+    """
+    Format exception message for better readability
+
+    Args:
+        exc: The exception to format
+
+    Returns:
+        Formatted error message
+    """
+    message = str(exc)
+
+    # Try to parse JSON error messages (common in API errors)
+    potential_json = _find_json_block(message)
+    if potential_json:
+        try:
+            error_data = json.loads(potential_json)
+
+            # Standard extraction logic
+            if isinstance(error_data, dict) and "error" in error_data:
+                error_info = error_data["error"]
+                if isinstance(error_info, dict):
+                    parts = []
+                    if "message" in error_info:
+                        parts.append(f"Message: {error_info['message']}")
+                    if "type" in error_info:
+                        parts.append(f"Type: {error_info['type']}")
+                    if "code" in error_info:
+                        parts.append(f"Code: {error_info['code']}")
+                    if parts:
+                        return " | ".join(parts)
+        except (json.JSONDecodeError, AttributeError):
+            pass
+
+    # Return original message if parsing fails
+    return message

src/utils/json_parser.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Robust JSON parsing utilities with automatic repair and markdown extraction.
+
+Provides safe JSON parsing that handles:
+- Markdown code block wrapping (```json...```)
+- Malformed JSON (missing commas, trailing commas, etc.)
+- Unescaped newlines and control characters
+- Empty responses
+"""
+
+import json
+import logging
+import re
+from typing import Any
+
+try:
+    from json_repair import repair_json
+except ImportError:
+    repair_json = None
+
+logger = logging.getLogger(__name__)
+
+
+def parse_json_response(
+    response: str,
+    logger_instance: logging.Logger | None = None,
+    fallback: Any = None,
+) -> Any:
+    """
+    Safely parse JSON from LLM responses with automatic repair.
+
+    Implements a three-tier parsing strategy:
+    1. Extract JSON from markdown code blocks if present
+    2. Direct JSON parsing
+    3. Automated repair using json-repair library with fallback
+
+    Args:
+        response: Raw string response from LLM
+        logger_instance: Logger instance for debugging (optional)
+        fallback: Value to return if all parsing fails (default: {})
+
+    Returns:
+        Parsed JSON object, or fallback value if parsing fails
+
+    Example:
+        >>> response = '```json\\n{"key": "value"}\\n```'
+        >>> data = parse_json_response(response)
+        >>> data
+        {'key': 'value'}
+    """
+    log = logger_instance or logger
+
+    if fallback is None:
+        fallback = {}
+
+    # Handle empty response
+    if not response or not response.strip():
+        log.warning("LLM returned empty response")
+        return fallback
+
+    # Extract from markdown code blocks if present
+    extracted_response = response
+    if "```" in response:
+        json_match = re.search(r"```(?:json)?\s*\n?(.*?)```", response, re.DOTALL)
+        if json_match:
+            extracted_response = json_match.group(1).strip()
+            log.debug("Extracted JSON from markdown code block")
+
+    # Strategy 1: Direct parsing
+    try:
+        return json.loads(extracted_response)
+    except json.JSONDecodeError as parse_error:
+        log.debug(f"Direct JSON parse failed: {parse_error}")
+
+    # Strategy 2: Try json-repair if available
+    if repair_json is None:
+        log.warning("json-repair library not installed, cannot repair malformed JSON")
+        log.debug(f"Response: {extracted_response[:200]}")
+        return fallback
+
+    try:
+        log.debug("Attempting JSON repair")
+        repaired = repair_json(extracted_response)
+        result = json.loads(repaired)
+        log.info("Successfully repaired malformed JSON")
+        return result
+    except Exception as repair_error:
+        log.error(f"JSON repair failed: {repair_error}")
+        log.debug(f"Response: {extracted_response[:200]}")
+        return fallback
+
+
+def safe_json_loads(data: str, fallback: Any = None) -> Any:
+    """
+    Simple wrapper for safe JSON loading.
+
+    Args:
+        data: JSON string
+        fallback: Value to return on failure (default: {})
+
+    Returns:
+        Parsed JSON or fallback value
+    """
+    try:
+        return json.loads(data)
+    except json.JSONDecodeError as e:
+        logger.warning(f"JSON parse error: {e}")
+        return fallback if fallback is not None else {}

src/utils/network/circuit_breaker.py

@@ -0,0 +1,79 @@
+"""
+Circuit Breaker - Simple circuit breaker for providers.
+"""
+
+import logging
+import threading
+import time
+from typing import Dict
+
+logger = logging.getLogger(__name__)
+
+
+class CircuitBreaker:
+    """
+    Simple circuit breaker that opens when error rate is high.
+    """
+
+    def __init__(self, failure_threshold: int = 5, recovery_timeout: int = 60):
+        self.failure_threshold = failure_threshold
+        self.recovery_timeout = recovery_timeout
+        self.failure_count: Dict[str, int] = {}
+        self.last_failure_time: Dict[str, float] = {}
+        self.state: Dict[str, str] = {}  # 'closed', 'open', 'half-open'
+        self.lock = threading.Lock()
+
+    def call(self, provider: str) -> bool:
+        """Check if call is allowed."""
+        with self.lock:
+            state = self.state.get(provider, "closed")
+            if state == "closed":
+                return True
+            elif state == "open":
+                if time.time() - self.last_failure_time.get(provider, 0) > self.recovery_timeout:
+                    self.state[provider] = "half-open"
+                    logger.info(f"Circuit breaker for {provider} entering half-open state")
+                    return True
+                return False
+            elif state == "half-open":
+                return True
+
+    def record_success(self, provider: str):
+        """Record successful call."""
+        with self.lock:
+            if self.state.get(provider) == "half-open":
+                self.state[provider] = "closed"
+                self.failure_count[provider] = 0
+                logger.info(f"Circuit breaker for {provider} closed")
+            elif self.state.get(provider) == "closed":
+                self.failure_count[provider] = 0
+
+    def record_failure(self, provider: str):
+        """Record failed call."""
+        with self.lock:
+            self.failure_count[provider] = self.failure_count.get(provider, 0) + 1
+            self.last_failure_time[provider] = time.time()
+            if self.failure_count[provider] >= self.failure_threshold:
+                self.state[provider] = "open"
+                logger.warning(
+                    f"Circuit breaker for {provider} opened due to {self.failure_count[provider]} failures"
+                )
+
+
+# Global instance
+circuit_breaker = CircuitBreaker()
+
+
+def alert_callback(provider: str, rate: float):
+    """Alert callback to trigger circuit breaker."""
+    circuit_breaker.record_failure(provider)
+
+
+def is_call_allowed(provider: str) -> bool:
+    """Check if call is allowed by circuit breaker."""
+    return circuit_breaker.call(provider)
+
+
+def record_call_success(provider: str):
+    """Record successful call."""
+    circuit_breaker.record_success(provider)