isa-model 0.3.91__py3-none-any.whl → 0.4.0__py3-none-any.whl

isa_model/core/pricing_manager.py

@@ -15,7 +15,6 @@ from datetime import datetime, timedelta
 from dataclasses import dataclass, field
 
 from .types import Provider
-from .config import config_manager
 
 logger = logging.getLogger(__name__)
 
@@ -78,17 +77,7 @@ class PricingManager:
     
     def _load_pricing_data(self):
         """Load pricing data from configuration files"""
-        # Try to load from Supabase first
-        if self._load_from_supabase():
-            logger.info("Loaded pricing data from Supabase")
-            return
-        
-        # Try to load from provider configurations
-        if self._load_from_provider_configs():
-            logger.info("Loaded pricing data from provider configurations")
-            return
-        
-        # Try to load from specified config path
+        # Try to load from specified config path first
         if self.config_path and self.config_path.exists():
             self._load_from_file(self.config_path)
             return
@@ -168,7 +157,7 @@ class PricingManager:
         """Load default pricing data as fallback"""
         default_pricing = {
             "openai": {
-                "gpt-4o-mini": {"input": 0.000000150, "output": 0.000000600, "unit_type": "token"},
+                "gpt-4o-mini": {"input": 0.00000015, "output": 0.0000006, "unit_type": "token"},
                 "gpt-4o": {"input": 0.000005, "output": 0.000015, "unit_type": "token"},
                 "gpt-4-turbo": {"input": 0.00001, "output": 0.00003, "unit_type": "token"},
                 "gpt-4": {"input": 0.00003, "output": 0.00006, "unit_type": "token"},
@@ -198,242 +187,6 @@ class PricingManager:
         self._parse_pricing_data({"providers": default_pricing})
         logger.info("Loaded default pricing data")
     
-    def _load_from_supabase(self) -> bool:
-        """Try to load pricing data from Supabase models table"""
-        try:
-            global_config = config_manager.get_global_config()
-            if not global_config.use_supabase:
-                return False
-            
-            # Import Supabase client
-            try:
-                from supabase import create_client, Client
-            except ImportError:
-                logger.debug("Supabase library not available")
-                return False
-            
-            # Get Supabase credentials
-            supabase_url = global_config.supabase_url or os.getenv('SUPABASE_URL')
-            supabase_key = global_config.supabase_key or os.getenv('SUPABASE_ANON_KEY')
-            
-            if not supabase_url or not supabase_key:
-                logger.debug("Supabase credentials not configured")
-                return False
-            
-            # Create Supabase client
-            supabase: Client = create_client(supabase_url, supabase_key)
-            
-            # Query models table for pricing information
-            result = supabase.table('models').select('model_id, provider, metadata').execute()
-            
-            if not result.data:
-                logger.debug("No models found in Supabase")
-                return False
-            
-            self.pricing_data = {}
-            loaded_count = 0
-            
-            for model_record in result.data:
-                model_id = model_record.get('model_id')
-                provider = model_record.get('provider')
-                metadata = model_record.get('metadata', {})
-                
-                if not model_id or not provider:
-                    continue
-                
-                # Extract pricing from metadata
-                pricing = self._extract_pricing_from_supabase_metadata(metadata, provider, model_id)
-                if pricing:
-                    if provider not in self.pricing_data:
-                        self.pricing_data[provider] = {}
-                    self.pricing_data[provider][model_id] = pricing
-                    loaded_count += 1
-            
-            if loaded_count > 0:
-                logger.info(f"Loaded pricing for {loaded_count} models from Supabase")
-                return True
-            else:
-                logger.debug("No pricing data found in Supabase models")
-                return False
-            
-        except Exception as e:
-            logger.debug(f"Failed to load pricing from Supabase: {e}")
-            return False
-    
-    def _load_from_provider_configs(self) -> bool:
-        """Load pricing data from provider configuration files"""
-        try:
-            providers_dir = self._find_project_root() / "isa_model" / "core" / "config" / "providers"
-            if not providers_dir.exists():
-                return False
-            
-            self.pricing_data = {}
-            loaded_any = False
-            
-            # Load all provider config files
-            for config_file in providers_dir.glob("*.yaml"):
-                if self._load_provider_config_file(config_file):
-                    loaded_any = True
-            
-            return loaded_any
-            
-        except Exception as e:
-            logger.error(f"Failed to load pricing from provider configs: {e}")
-            return False
-    
-    def _load_provider_config_file(self, config_file: Path) -> bool:
-        """Load pricing data from a single provider config file"""
-        try:
-            with open(config_file, 'r') as f:
-                provider_data = yaml.safe_load(f)
-            
-            provider_name = provider_data.get("provider")
-            if not provider_name:
-                return False
-            
-            models = provider_data.get("models", [])
-            if not models:
-                return False
-            
-            self.pricing_data[provider_name] = {}
-            
-            for model in models:
-                model_id = model.get("model_id")
-                metadata = model.get("metadata", {})
-                
-                if not model_id:
-                    continue
-                
-                # Extract pricing information from metadata
-                pricing = self._extract_pricing_from_metadata(metadata, provider_name, model_id)
-                if pricing:
-                    self.pricing_data[provider_name][model_id] = pricing
-            
-            logger.debug(f"Loaded pricing for {len(self.pricing_data[provider_name])} models from {provider_name}")
-            return True
-            
-        except Exception as e:
-            logger.error(f"Failed to load provider config {config_file}: {e}")
-            return False
-    
-    def _extract_pricing_from_metadata(self, metadata: Dict[str, Any], provider: str, model_name: str) -> Optional[ModelPricing]:
-        """Extract pricing information from model metadata"""
-        try:
-            # Map different pricing field formats to our standard format
-            pricing_fields = {
-                "cost_per_1000_chars": ("character", 1000),
-                "cost_per_1000_tokens": ("token", 1000000),  # Convert to cost per 1M tokens
-                "cost_per_minute": ("minute", 1),
-                "cost_per_image": ("image", 1),
-                "cost_per_request": ("request", 1),
-            }
-            
-            input_cost = 0.0
-            output_cost = 0.0
-            unit_type = "token"
-            base_cost = 0.0
-            
-            for field, (unit, multiplier) in pricing_fields.items():
-                if field in metadata:
-                    cost = float(metadata[field])
-                    if unit == "character":
-                        # Convert cost per 1K chars to cost per 1K chars
-                        input_cost = cost
-                        unit_type = "character"
-                    elif unit == "token":
-                        # Cost per 1M tokens
-                        input_cost = cost
-                        unit_type = "token"
-                    elif unit == "minute":
-                        input_cost = cost
-                        unit_type = "minute"
-                    elif unit == "image":
-                        input_cost = cost
-                        unit_type = "image"
-                    elif unit == "request":
-                        base_cost = cost
-                    break
-            
-            # If no pricing found, skip this model
-            if input_cost == 0.0 and base_cost == 0.0:
-                return None
-            
-            return ModelPricing(
-                provider=provider,
-                model_name=model_name,
-                input_cost=input_cost,
-                output_cost=output_cost,
-                unit_type=unit_type,
-                base_cost=base_cost,
-                last_updated=datetime.now()
-            )
-            
-        except Exception as e:
-            logger.warning(f"Failed to extract pricing for {provider}/{model_name}: {e}")
-            return None
-    
-    def _extract_pricing_from_supabase_metadata(self, metadata: Dict[str, Any], provider: str, model_name: str) -> Optional[ModelPricing]:
-        """Extract pricing information from Supabase model metadata"""
-        try:
-            # Check for pricing information in metadata
-            pricing_info = metadata.get('pricing', {})
-            
-            # If no pricing object, look for direct pricing fields
-            if not pricing_info:
-                # Look for various pricing field formats in metadata
-                pricing_fields = [
-                    'cost_per_1000_chars', 'cost_per_1000_tokens', 'cost_per_minute', 
-                    'cost_per_image', 'cost_per_request', 'input_cost', 'output_cost',
-                    'cost_per_1k_tokens', 'cost_per_1k_chars'
-                ]
-                
-                for field in pricing_fields:
-                    if field in metadata:
-                        # Create a pricing object from the field
-                        if 'char' in field:
-                            pricing_info = {'input': metadata[field], 'unit_type': 'character'}
-                        elif 'token' in field:
-                            pricing_info = {'input': metadata[field], 'unit_type': 'token'}
-                        elif 'minute' in field:
-                            pricing_info = {'input': metadata[field], 'unit_type': 'minute'}
-                        elif 'image' in field:
-                            pricing_info = {'input': metadata[field], 'unit_type': 'image'}
-                        elif 'request' in field:
-                            pricing_info = {'base_cost': metadata[field], 'unit_type': 'request'}
-                        break
-            
-            if not pricing_info:
-                return None
-            
-            # Extract standard pricing fields
-            input_cost = float(pricing_info.get('input', pricing_info.get('input_cost', 0.0)))
-            output_cost = float(pricing_info.get('output', pricing_info.get('output_cost', 0.0)))
-            unit_type = pricing_info.get('unit_type', 'token')
-            base_cost = float(pricing_info.get('base_cost', 0.0))
-            infrastructure_cost_per_hour = float(pricing_info.get('infrastructure_cost_per_hour', 0.0))
-            currency = pricing_info.get('currency', 'USD')
-            
-            # If no pricing found, skip this model
-            if input_cost == 0.0 and output_cost == 0.0 and base_cost == 0.0:
-                return None
-            
-            return ModelPricing(
-                provider=provider,
-                model_name=model_name,
-                input_cost=input_cost,
-                output_cost=output_cost,
-                unit_type=unit_type,
-                base_cost=base_cost,
-                infrastructure_cost_per_hour=infrastructure_cost_per_hour,
-                currency=currency,
-                last_updated=datetime.now(),
-                metadata=pricing_info
-            )
-            
-        except Exception as e:
-            logger.warning(f"Failed to extract pricing from Supabase metadata for {provider}/{model_name}: {e}")
-            return None
-    
     def get_model_pricing(self, provider: str, model_name: str) -> Optional[ModelPricing]:
         """Get pricing information for a specific model"""
         self._refresh_if_needed()

isa_model/core/resilience/circuit_breaker.py

@@ -0,0 +1,366 @@
+"""
+Circuit Breaker Implementation for External Service Calls
+
+Provides resilience patterns including:
+- Circuit breaker for external API calls
+- Retry with exponential backoff
+- Timeout handling
+- Health monitoring
+"""
+
+import asyncio
+import time
+import logging
+import functools
+from typing import Dict, Any, Optional, Callable, Union, List
+from enum import Enum
+from dataclasses import dataclass, field
+from circuitbreaker import circuit
+import structlog
+
+logger = structlog.get_logger(__name__)
+
+class CircuitState(Enum):
+    CLOSED = "closed"      # Normal operation
+    OPEN = "open"          # Circuit breaker triggered, blocking calls
+    HALF_OPEN = "half_open"  # Testing if service is recovered
+
+@dataclass
+class CircuitBreakerConfig:
+    """Configuration for circuit breaker"""
+    failure_threshold: int = 5          # Number of failures before opening
+    recovery_timeout: int = 30          # Seconds before trying to recover
+    expected_exception: type = Exception  # Exception type that triggers circuit breaker
+    success_threshold: int = 3          # Successful calls needed to close circuit
+    timeout: float = 30.0               # Request timeout in seconds
+
+@dataclass
+class CircuitBreakerStats:
+    """Circuit breaker statistics"""
+    total_calls: int = 0
+    successful_calls: int = 0
+    failed_calls: int = 0
+    consecutive_failures: int = 0
+    consecutive_successes: int = 0
+    last_failure_time: Optional[float] = None
+    last_success_time: Optional[float] = None
+    state_changes: List[Dict[str, Any]] = field(default_factory=list)
+
+class EnhancedCircuitBreaker:
+    """Enhanced circuit breaker with monitoring and configuration"""
+    
+    def __init__(self, name: str, config: CircuitBreakerConfig):
+        self.name = name
+        self.config = config
+        self.stats = CircuitBreakerStats()
+        self.state = CircuitState.CLOSED
+        self.last_state_change = time.time()
+        
+        # Create underlying circuit breaker
+        self._circuit = circuit(
+            failure_threshold=config.failure_threshold,
+            recovery_timeout=config.recovery_timeout,
+            expected_exception=config.expected_exception
+        )
+        
+        logger.info("Circuit breaker initialized", name=name, config=config)
+    
+    def __call__(self, func: Callable):
+        """Decorator to wrap functions with circuit breaker"""
+        
+        @functools.wraps(func)
+        async def wrapper(*args, **kwargs):
+            return await self.call(func, *args, **kwargs)
+        
+        # Apply the circuit breaker decorator
+        wrapped_func = self._circuit(wrapper)
+        return wrapped_func
+    
+    async def call(self, func: Callable, *args, **kwargs):
+        """Execute function with circuit breaker protection"""
+        start_time = time.time()
+        
+        try:
+            # Record call attempt
+            self.stats.total_calls += 1
+            
+            # Check if circuit is open
+            if self.state == CircuitState.OPEN:
+                if time.time() - self.last_state_change < self.config.recovery_timeout:
+                    raise CircuitBreakerOpenException(
+                        f"Circuit breaker '{self.name}' is open"
+                    )
+                else:
+                    # Try to move to half-open state
+                    self._change_state(CircuitState.HALF_OPEN)
+            
+            # Execute the function with timeout
+            try:
+                if asyncio.iscoroutinefunction(func):
+                    result = await asyncio.wait_for(
+                        func(*args, **kwargs),
+                        timeout=self.config.timeout
+                    )
+                else:
+                    result = func(*args, **kwargs)
+                
+                # Record success
+                self._record_success()
+                
+                return result
+                
+            except asyncio.TimeoutError:
+                self._record_failure()
+                raise CircuitBreakerTimeoutException(
+                    f"Timeout after {self.config.timeout}s for '{self.name}'"
+                )
+            except self.config.expected_exception as e:
+                self._record_failure()
+                raise
+            
+        except Exception as e:
+            duration = time.time() - start_time
+            logger.error(
+                "Circuit breaker call failed",
+                name=self.name,
+                error=str(e),
+                duration=duration,
+                state=self.state.value
+            )
+            raise
+    
+    def _record_success(self):
+        """Record successful call"""
+        self.stats.successful_calls += 1
+        self.stats.consecutive_successes += 1
+        self.stats.consecutive_failures = 0
+        self.stats.last_success_time = time.time()
+        
+        # If we're in half-open state and have enough successes, close the circuit
+        if (self.state == CircuitState.HALF_OPEN and 
+            self.stats.consecutive_successes >= self.config.success_threshold):
+            self._change_state(CircuitState.CLOSED)
+        
+        logger.debug(
+            "Circuit breaker success",
+            name=self.name,
+            consecutive_successes=self.stats.consecutive_successes,
+            state=self.state.value
+        )
+    
+    def _record_failure(self):
+        """Record failed call"""
+        self.stats.failed_calls += 1
+        self.stats.consecutive_failures += 1
+        self.stats.consecutive_successes = 0
+        self.stats.last_failure_time = time.time()
+        
+        # Check if we should open the circuit
+        if (self.state == CircuitState.CLOSED and 
+            self.stats.consecutive_failures >= self.config.failure_threshold):
+            self._change_state(CircuitState.OPEN)
+        elif self.state == CircuitState.HALF_OPEN:
+            # Any failure in half-open state reopens the circuit
+            self._change_state(CircuitState.OPEN)
+        
+        logger.warning(
+            "Circuit breaker failure",
+            name=self.name,
+            consecutive_failures=self.stats.consecutive_failures,
+            state=self.state.value
+        )
+    
+    def _change_state(self, new_state: CircuitState):
+        """Change circuit breaker state"""
+        old_state = self.state
+        self.state = new_state
+        self.last_state_change = time.time()
+        
+        # Record state change
+        state_change = {
+            "from_state": old_state.value,
+            "to_state": new_state.value,
+            "timestamp": self.last_state_change,
+            "total_calls": self.stats.total_calls,
+            "consecutive_failures": self.stats.consecutive_failures
+        }
+        self.stats.state_changes.append(state_change)
+        
+        logger.warning(
+            "Circuit breaker state changed",
+            name=self.name,
+            from_state=old_state.value,
+            to_state=new_state.value,
+            consecutive_failures=self.stats.consecutive_failures
+        )
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """Get circuit breaker statistics"""
+        return {
+            "name": self.name,
+            "state": self.state.value,
+            "total_calls": self.stats.total_calls,
+            "successful_calls": self.stats.successful_calls,
+            "failed_calls": self.stats.failed_calls,
+            "success_rate": (
+                self.stats.successful_calls / self.stats.total_calls 
+                if self.stats.total_calls > 0 else 0
+            ),
+            "consecutive_failures": self.stats.consecutive_failures,
+            "consecutive_successes": self.stats.consecutive_successes,
+            "last_failure_time": self.stats.last_failure_time,
+            "last_success_time": self.stats.last_success_time,
+            "last_state_change": self.last_state_change,
+            "config": {
+                "failure_threshold": self.config.failure_threshold,
+                "recovery_timeout": self.config.recovery_timeout,
+                "timeout": self.config.timeout
+            }
+        }
+    
+    def reset(self):
+        """Reset circuit breaker to initial state"""
+        self.state = CircuitState.CLOSED
+        self.stats = CircuitBreakerStats()
+        self.last_state_change = time.time()
+        
+        logger.info("Circuit breaker reset", name=self.name)
+
+class CircuitBreakerOpenException(Exception):
+    """Exception raised when circuit breaker is open"""
+    pass
+
+class CircuitBreakerTimeoutException(Exception):
+    """Exception raised when call times out"""
+    pass
+
+# Global circuit breaker registry
+_circuit_breakers: Dict[str, EnhancedCircuitBreaker] = {}
+
+def get_circuit_breaker(
+    name: str, 
+    config: Optional[CircuitBreakerConfig] = None
+) -> EnhancedCircuitBreaker:
+    """Get or create a circuit breaker"""
+    if name not in _circuit_breakers:
+        if config is None:
+            config = CircuitBreakerConfig()
+        _circuit_breakers[name] = EnhancedCircuitBreaker(name, config)
+    
+    return _circuit_breakers[name]
+
+def circuit_breaker(
+    name: str,
+    failure_threshold: int = 5,
+    recovery_timeout: int = 30,
+    timeout: float = 30.0,
+    expected_exception: type = Exception
+):
+    """Decorator for applying circuit breaker to functions"""
+    config = CircuitBreakerConfig(
+        failure_threshold=failure_threshold,
+        recovery_timeout=recovery_timeout,
+        timeout=timeout,
+        expected_exception=expected_exception
+    )
+    
+    breaker = get_circuit_breaker(name, config)
+    return breaker
+
+# Predefined circuit breakers for common services
+def openai_circuit_breaker():
+    """Circuit breaker for OpenAI API calls"""
+    return circuit_breaker(
+        name="openai",
+        failure_threshold=3,
+        recovery_timeout=60,
+        timeout=120.0  # OpenAI can be slow
+    )
+
+def replicate_circuit_breaker():
+    """Circuit breaker for Replicate API calls"""
+    return circuit_breaker(
+        name="replicate",
+        failure_threshold=3,
+        recovery_timeout=45,
+        timeout=300.0  # Replicate can be very slow for image generation
+    )
+
+def database_circuit_breaker():
+    """Circuit breaker for database calls"""
+    return circuit_breaker(
+        name="database",
+        failure_threshold=5,
+        recovery_timeout=20,
+        timeout=10.0
+    )
+
+def redis_circuit_breaker():
+    """Circuit breaker for Redis calls"""
+    return circuit_breaker(
+        name="redis",
+        failure_threshold=3,
+        recovery_timeout=15,
+        timeout=5.0
+    )
+
+# Health check for all circuit breakers
+async def check_circuit_breakers_health() -> Dict[str, Any]:
+    """Check health of all circuit breakers"""
+    health_status = {
+        "circuit_breakers": {},
+        "total_breakers": len(_circuit_breakers),
+        "open_breakers": 0,
+        "status": "healthy"
+    }
+    
+    for name, breaker in _circuit_breakers.items():
+        stats = breaker.get_stats()
+        health_status["circuit_breakers"][name] = stats
+        
+        if stats["state"] == "open":
+            health_status["open_breakers"] += 1
+    
+    # Overall health status
+    if health_status["open_breakers"] > 0:
+        health_status["status"] = "degraded"
+    
+    return health_status
+
+# Utility functions for retry with exponential backoff
+async def retry_with_backoff(
+    func: Callable,
+    max_retries: int = 3,
+    base_delay: float = 1.0,
+    max_delay: float = 60.0,
+    exponential_base: float = 2.0,
+    exceptions: tuple = (Exception,)
+):
+    """Retry function with exponential backoff"""
+    
+    for attempt in range(max_retries + 1):
+        try:
+            if asyncio.iscoroutinefunction(func):
+                return await func()
+            else:
+                return func()
+        except exceptions as e:
+            if attempt == max_retries:
+                logger.error(
+                    "All retry attempts failed",
+                    attempts=attempt + 1,
+                    error=str(e)
+                )
+                raise
+            
+            delay = min(base_delay * (exponential_base ** attempt), max_delay)
+            
+            logger.warning(
+                "Retry attempt failed, backing off",
+                attempt=attempt + 1,
+                max_retries=max_retries,
+                delay=delay,
+                error=str(e)
+            )
+            
+            await asyncio.sleep(delay)