isa-model 0.3.91__py3-none-any.whl → 0.4.3__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/repositories/__init__.py

@@ -0,0 +1,9 @@
+"""
+Core Repository Layer
+
+Provides data persistence and retrieval for core operations.
+"""
+
+from .config_repository import ConfigRepository
+
+__all__ = ["ConfigRepository"]