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

isa_model/core/models/model_manager.py

@@ -7,7 +7,7 @@ from huggingface_hub.errors import HfHubHTTPError
 from .model_storage import ModelStorage, LocalModelStorage
 from .model_repo import ModelRegistry, ModelType, ModelCapability
 from .model_billing_tracker import ModelBillingTracker, ModelOperationType
-from ..pricing_manager import PricingManager
+from .model_statistics_tracker import ModelStatisticsTracker
 from ..config import ConfigManager
 
 logger = logging.getLogger(__name__)
@@ -28,38 +28,56 @@ class ModelManager:
                  storage: Optional[ModelStorage] = None,
                  registry: Optional[ModelRegistry] = None,
                  billing_tracker: Optional[ModelBillingTracker] = None,
-                 pricing_manager: Optional[PricingManager] = None,
+                 statistics_tracker: Optional[ModelStatisticsTracker] = None,
                  config_manager: Optional[ConfigManager] = None):
         self.storage = storage or LocalModelStorage()
         self.registry = registry or ModelRegistry()
         self.billing_tracker = billing_tracker or ModelBillingTracker(model_registry=self.registry)
-        self.pricing_manager = pricing_manager or PricingManager()
+        self.statistics_tracker = statistics_tracker or ModelStatisticsTracker(model_registry=self.registry)
         self.config_manager = config_manager or ConfigManager()
     
     def get_model_pricing(self, provider: str, model_name: str) -> Dict[str, float]:
         """获取模型定价信息"""
-        pricing = self.pricing_manager.get_model_pricing(provider, model_name)
-        if pricing:
-            return {"input": pricing.input_cost, "output": pricing.output_cost}
+        try:
+            models = self.config_manager.get_models_by_provider(provider)
+            for model in models:
+                if model.get("model_id") == model_name:
+                    metadata = model.get("metadata", {})
+                    if "cost_per_1000_tokens" in metadata:
+                        return {"input": metadata["cost_per_1000_tokens"], "output": metadata["cost_per_1000_tokens"]}
+                    elif "cost_per_minute" in metadata:
+                        return {"input": metadata["cost_per_minute"], "output": 0.0}
+                    elif "cost_per_1000_chars" in metadata:
+                        return {"input": metadata["cost_per_1000_chars"], "output": 0.0}
+        except Exception as e:
+            logger.warning(f"Failed to get pricing for {provider}/{model_name}: {e}")
         return {"input": 0.0, "output": 0.0}
     
     def calculate_cost(self, provider: str, model_name: str, input_tokens: int, output_tokens: int) -> float:
         """计算请求成本"""
-        return self.pricing_manager.calculate_cost(
-            provider=provider,
-            model_name=model_name,
-            input_units=input_tokens,
-            output_units=output_tokens
-        )
+        pricing = self.get_model_pricing(provider, model_name)
+        if pricing["input"] > 0:
+            return (input_tokens + output_tokens) * pricing["input"] / 1000.0
+        return 0.0
     
     def get_cheapest_model(self, provider: str, model_type: str = "llm") -> Optional[str]:
         """获取最便宜的模型"""
-        result = self.pricing_manager.get_cheapest_model(
-            provider=provider, 
-            unit_type="token",
-            min_input_units=1000  # Assume 1K tokens for comparison
-        )
-        return result["model_name"] if result else None
+        try:
+            models = self.config_manager.get_models_by_provider(provider)
+            cheapest_model = None
+            lowest_cost = float('inf')
+            
+            for model in models:
+                if model.get("model_type") == model_type:
+                    pricing = self.get_model_pricing(provider, model["model_id"])
+                    if pricing["input"] > 0 and pricing["input"] < lowest_cost:
+                        lowest_cost = pricing["input"]
+                        cheapest_model = model["model_id"]
+            
+            return cheapest_model
+        except Exception as e:
+            logger.warning(f"Failed to find cheapest model for {provider}: {e}")
+            return None
 
     async def get_model(self, 
                        model_id: str, 

isa_model/core/models/model_repo.py

@@ -13,7 +13,7 @@ from enum import Enum
 from datetime import datetime
 
 try:
-    from supabase import create_client, Client
+    from ..database.supabase_client import get_supabase_client, get_supabase_table
     SUPABASE_AVAILABLE = True
 except ImportError:
     SUPABASE_AVAILABLE = False
@@ -32,6 +32,10 @@ class ModelCapability(str, Enum):
     IMAGE_GENERATION = "image_generation"
     IMAGE_ANALYSIS = "image_analysis"
     AUDIO_TRANSCRIPTION = "audio_transcription"
+    AUDIO_REALTIME = "audio_realtime"
+    SPEECH_TO_TEXT = "speech_to_text"
+    TEXT_TO_SPEECH = "text_to_speech"
+    CONVERSATION = "conversation"
     IMAGE_UNDERSTANDING = "image_understanding"
     UI_DETECTION = "ui_detection"
     OCR = "ocr"
@@ -55,62 +59,64 @@ class ModelRegistry:
         if not SUPABASE_AVAILABLE:
             raise ImportError("supabase-py is required. Install with: pip install supabase")
         
-        # Get configuration from unified ConfigManager
-        self.config_manager = ConfigManager()
-        global_config = self.config_manager.get_global_config()
-        
-        # Get Supabase configuration from database config
-        self.supabase_url = global_config.database.supabase_url or os.getenv("SUPABASE_URL")
-        self.supabase_key = global_config.database.supabase_key or os.getenv("SUPABASE_ANON_KEY") or os.getenv("SERVICE_ROLE_KEY")
-        
-        if not self.supabase_url or not self.supabase_key:
-            raise ValueError("SUPABASE_URL and SUPABASE_ANON_KEY (or SERVICE_ROLE_KEY) must be configured")
-        
-        # Initialize Supabase client
-        self.supabase: Client = create_client(self.supabase_url, self.supabase_key)
+        # Get centralized Supabase client
+        self.supabase_client = get_supabase_client()
+        self.schema = self.supabase_client.get_schema()
+        self.environment = self.supabase_client.get_environment()
         
         # Verify connection
         self._ensure_tables()
         
-        logger.info("Model registry initialized with Supabase backend")
+        logger.info(f"Model registry initialized with centralized Supabase client (env: {self.environment}, schema: {self.schema})")
+    
+    def _table(self, table_name: str):
+        """Get table with correct schema"""
+        return self.supabase_client.table(table_name)
     
     def _ensure_tables(self):
         """Ensure required tables exist in Supabase"""
         try:
             # Check if models table exists by trying to query it
-            result = self.supabase.table('models').select('model_id').limit(1).execute()
-            logger.debug("Models table verified")
+            result = self._table('models').select('model_id').limit(1).execute()
+            logger.debug(f"Models table verified in {self.schema} schema")
         except Exception as e:
-            logger.warning(f"Models table might not exist: {e}")
+            logger.warning(f"Models table might not exist in {self.schema} schema: {e}")
             # In production, tables should be created via Supabase migrations
     
     def register_model(self, 
                       model_id: str,
                       model_type: ModelType,
                       capabilities: List[ModelCapability],
-                      metadata: Dict[str, Any]) -> bool:
+                      metadata: Dict[str, Any],
+                      provider: Optional[str] = None) -> bool:
         """Register a model with its capabilities and metadata"""
         try:
             current_time = datetime.now().isoformat()
             
+            # Extract provider from metadata or use parameter
+            provider_value = provider or metadata.get('provider')
+            if not provider_value:
+                raise ValueError("Provider must be specified either as parameter or in metadata")
+            
             # Prepare model data
             model_data = {
                 'model_id': model_id,
                 'model_type': model_type.value,
+                'provider': provider_value,
                 'metadata': json.dumps(metadata),
                 'created_at': current_time,
                 'updated_at': current_time
             }
             
             # Insert or update model
-            result = self.supabase.table('models').upsert(model_data).execute()
+            result = self._table('models').upsert(model_data).execute()
             
             if not result.data:
                 logger.error(f"Failed to insert model {model_id}")
                 return False
             
             # Delete existing capabilities
-            self.supabase.table('model_capabilities').delete().eq('model_id', model_id).execute()
+            self._table('model_capabilities').delete().eq('model_id', model_id).execute()
             
             # Insert new capabilities
             if capabilities:
@@ -123,7 +129,7 @@ class ModelRegistry:
                     for capability in capabilities
                 ]
                 
-                cap_result = self.supabase.table('model_capabilities').insert(capability_data).execute()
+                cap_result = self._table('model_capabilities').insert(capability_data).execute()
                 
                 if not cap_result.data:
                     logger.error(f"Failed to insert capabilities for {model_id}")
@@ -140,7 +146,7 @@ class ModelRegistry:
         """Unregister a model"""
         try:
             # Delete model (capabilities will be cascade deleted)
-            result = self.supabase.table('models').delete().eq('model_id', model_id).execute()
+            result = self._table('models').delete().eq('model_id', model_id).execute()
             
             if result.data:
                 logger.info(f"Unregistered model {model_id}")
@@ -155,7 +161,7 @@ class ModelRegistry:
         """Get model information"""
         try:
             # Get model info
-            model_result = self.supabase.table('models').select('*').eq('model_id', model_id).execute()
+            model_result = self._table('models').select('*').eq('model_id', model_id).execute()
             
             if not model_result.data:
                 return None
@@ -163,7 +169,7 @@ class ModelRegistry:
             model_row = model_result.data[0]
             
             # Get capabilities
-            cap_result = self.supabase.table('model_capabilities').select('capability').eq('model_id', model_id).execute()
+            cap_result = self._table('model_capabilities').select('capability').eq('model_id', model_id).execute()
             capabilities = [cap['capability'] for cap in cap_result.data]
             
             model_info = {
@@ -184,14 +190,14 @@ class ModelRegistry:
     def get_models_by_type(self, model_type: ModelType) -> Dict[str, Dict[str, Any]]:
         """Get all models of a specific type"""
         try:
-            models_result = self.supabase.table('models').select('*').eq('model_type', model_type.value).execute()
+            models_result = self._table('models').select('*').eq('model_type', model_type.value).execute()
             
             result = {}
             for model in models_result.data:
                 model_id = model["model_id"]
                 
                 # Get capabilities for this model
-                cap_result = self.supabase.table('model_capabilities').select('capability').eq('model_id', model_id).execute()
+                cap_result = self._table('model_capabilities').select('capability').eq('model_id', model_id).execute()
                 capabilities = [cap['capability'] for cap in cap_result.data]
                 
                 result[model_id] = {
@@ -212,21 +218,21 @@ class ModelRegistry:
         """Get all models with a specific capability"""
         try:
             # Get model IDs with specific capability
-            cap_result = self.supabase.table('model_capabilities').select('model_id').eq('capability', capability.value).execute()
+            cap_result = self._table('model_capabilities').select('model_id').eq('capability', capability.value).execute()
             model_ids = [row['model_id'] for row in cap_result.data]
             
             if not model_ids:
                 return {}
             
             # Get model details
-            models_result = self.supabase.table('models').select('*').in_('model_id', model_ids).execute()
+            models_result = self._table('models').select('*').in_('model_id', model_ids).execute()
             
             result = {}
             for model in models_result.data:
                 model_id = model["model_id"]
                 
                 # Get all capabilities for this model
-                all_caps_result = self.supabase.table('model_capabilities').select('capability').eq('model_id', model_id).execute()
+                all_caps_result = self._table('model_capabilities').select('capability').eq('model_id', model_id).execute()
                 capabilities = [cap['capability'] for cap in all_caps_result.data]
                 
                 result[model_id] = {
@@ -246,7 +252,7 @@ class ModelRegistry:
     def has_capability(self, model_id: str, capability: ModelCapability) -> bool:
         """Check if a model has a specific capability"""
         try:
-            result = self.supabase.table('model_capabilities').select('model_id').eq('model_id', model_id).eq('capability', capability.value).execute()
+            result = self._table('model_capabilities').select('model_id').eq('model_id', model_id).eq('capability', capability.value).execute()
             
             return len(result.data) > 0
             
@@ -257,14 +263,14 @@ class ModelRegistry:
     def list_models(self) -> Dict[str, Dict[str, Any]]:
         """List all registered models"""
         try:
-            models_result = self.supabase.table('models').select('*').order('created_at', desc=True).execute()
+            models_result = self._table('models').select('*').order('created_at', desc=True).execute()
             
             result = {}
             for model in models_result.data:
                 model_id = model["model_id"]
                 
                 # Get capabilities for this model
-                cap_result = self.supabase.table('model_capabilities').select('capability').eq('model_id', model_id).execute()
+                cap_result = self._table('model_capabilities').select('capability').eq('model_id', model_id).execute()
                 capabilities = [cap['capability'] for cap in cap_result.data]
                 
                 result[model_id] = {
@@ -285,18 +291,18 @@ class ModelRegistry:
         """Get registry statistics"""
         try:
             # Count total models
-            total_result = self.supabase.table('models').select('model_id', count='exact').execute()
+            total_result = self._table('models').select('model_id', count='exact').execute()
             total_models = total_result.count if total_result.count is not None else 0
             
             # Count by type (manual aggregation since RPC might not exist)
-            models_result = self.supabase.table('models').select('model_type').execute()
+            models_result = self._table('models').select('model_type').execute()
             type_counts = {}
             for model in models_result.data:
                 model_type = model['model_type']
                 type_counts[model_type] = type_counts.get(model_type, 0) + 1
             
             # Count by capability
-            caps_result = self.supabase.table('model_capabilities').select('capability').execute()
+            caps_result = self._table('model_capabilities').select('capability').execute()
             capability_counts = {}
             for cap in caps_result.data:
                 capability = cap['capability']
@@ -316,7 +322,7 @@ class ModelRegistry:
         """Search models by name or metadata"""
         try:
             # Search in model_id and metadata
-            models_result = self.supabase.table('models').select('*').or_(
+            models_result = self._table('models').select('*').or_(
                 f'model_id.ilike.%{query}%,metadata.ilike.%{query}%'
             ).order('created_at', desc=True).execute()
             
@@ -325,7 +331,7 @@ class ModelRegistry:
                 model_id = model["model_id"]
                 
                 # Get capabilities for this model
-                cap_result = self.supabase.table('model_capabilities').select('capability').eq('model_id', model_id).execute()
+                cap_result = self._table('model_capabilities').select('capability').eq('model_id', model_id).execute()
                 capabilities = [cap['capability'] for cap in cap_result.data]
                 
                 result[model_id] = {

isa_model/core/models/model_statistics_tracker.py

@@ -0,0 +1,234 @@
+"""
+Model Statistics Tracker - Aggregated Usage Tracking
+
+Replaces the detailed ModelBillingTracker with efficient daily aggregation.
+Instead of storing every individual request, we aggregate usage by model per day.
+"""
+
+import logging
+from datetime import datetime, timezone, date
+from typing import Dict, Any, Optional, List
+from decimal import Decimal
+
+logger = logging.getLogger(__name__)
+
+class ModelStatisticsTracker:
+    """Tracks aggregated model usage statistics efficiently"""
+    
+    def __init__(self, model_registry=None):
+        """Initialize the statistics tracker"""
+        self.model_registry = model_registry
+        self._daily_cache = {}  # Cache for today's statistics
+        
+    def track_usage(self,
+                   model_id: str,
+                   provider: str,
+                   service_type: str,
+                   operation_type: str = "inference",
+                   operation: str = "",
+                   input_tokens: Optional[int] = None,
+                   output_tokens: Optional[int] = None,
+                   total_tokens: Optional[int] = None,
+                   input_units: Optional[float] = None,
+                   output_units: Optional[float] = None,
+                   cost_usd: float = 0.0,
+                   metadata: Optional[Dict[str, Any]] = None) -> bool:
+        """
+        Track model usage by updating daily aggregated statistics
+        
+        Args:
+            model_id: Model identifier
+            provider: Provider name (openai, anthropic, etc.)
+            service_type: Type of service (llm, vision, embedding, etc.)
+            operation_type: Type of operation (usually "inference")
+            operation: Specific operation name
+            input_tokens: Number of input tokens
+            output_tokens: Number of output tokens  
+            total_tokens: Total tokens (input + output)
+            input_units: Input units for non-token services
+            output_units: Output units for non-token services
+            cost_usd: Cost in USD
+            metadata: Additional metadata
+            
+        Returns:
+            bool: True if tracking succeeded
+        """
+        try:
+            today = date.today()
+            cache_key = f"{model_id}_{provider}_{service_type}_{operation_type}_{today}"
+            
+            # Get current stats from cache or database
+            if cache_key not in self._daily_cache:
+                self._daily_cache[cache_key] = self._get_daily_stats(
+                    model_id, provider, service_type, operation_type, today
+                )
+            
+            # Update statistics
+            stats = self._daily_cache[cache_key]
+            stats['total_requests'] += 1
+            stats['total_input_tokens'] += input_tokens or 0
+            stats['total_output_tokens'] += output_tokens or 0
+            stats['total_tokens'] += total_tokens or (input_tokens or 0) + (output_tokens or 0)
+            stats['total_input_units'] += Decimal(str(input_units or 0))
+            stats['total_output_units'] += Decimal(str(output_units or 0))
+            stats['total_cost_usd'] += Decimal(str(cost_usd))
+            stats['last_updated'] = datetime.now(timezone.utc)
+            
+            # Save to database immediately (upsert)
+            self._save_daily_stats(stats)
+            
+            logger.debug(f"Tracked usage: {model_id} - {operation_type} - ${cost_usd:.6f}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to track model usage: {e}")
+            return False
+    
+    def _get_daily_stats(self, model_id: str, provider: str, service_type: str, 
+                        operation_type: str, target_date: date) -> Dict[str, Any]:
+        """Get or create daily statistics record"""
+        try:
+            if not self.model_registry or not hasattr(self.model_registry, 'supabase_client'):
+                # Return empty stats if no database connection
+                return self._create_empty_stats(model_id, provider, service_type, operation_type, target_date)
+            
+            result = self.model_registry.supabase_client.table('model_statistics').select('*').eq(
+                'model_id', model_id
+            ).eq('provider', provider).eq('service_type', service_type).eq(
+                'operation_type', operation_type
+            ).eq('date', target_date.isoformat()).execute()
+            
+            if result.data and len(result.data) > 0:
+                # Convert to proper types
+                stats = result.data[0].copy()
+                stats['total_input_units'] = Decimal(str(stats.get('total_input_units', 0)))
+                stats['total_output_units'] = Decimal(str(stats.get('total_output_units', 0)))
+                stats['total_cost_usd'] = Decimal(str(stats.get('total_cost_usd', 0)))
+                return stats
+            else:
+                # Create new record
+                return self._create_empty_stats(model_id, provider, service_type, operation_type, target_date)
+                
+        except Exception as e:
+            logger.error(f"Failed to get daily stats: {e}")
+            return self._create_empty_stats(model_id, provider, service_type, operation_type, target_date)
+    
+    def _create_empty_stats(self, model_id: str, provider: str, service_type: str, 
+                           operation_type: str, target_date: date) -> Dict[str, Any]:
+        """Create empty statistics record"""
+        return {
+            'model_id': model_id,
+            'provider': provider,
+            'service_type': service_type,
+            'operation_type': operation_type,
+            'date': target_date.isoformat(),
+            'total_requests': 0,
+            'total_input_tokens': 0,
+            'total_output_tokens': 0,
+            'total_tokens': 0,
+            'total_input_units': Decimal('0'),
+            'total_output_units': Decimal('0'),
+            'total_cost_usd': Decimal('0'),
+            'last_updated': datetime.now(timezone.utc),
+            'created_at': datetime.now(timezone.utc)
+        }
+    
+    def _save_daily_stats(self, stats: Dict[str, Any]) -> bool:
+        """Save daily statistics to database"""
+        try:
+            if not self.model_registry or not hasattr(self.model_registry, 'supabase_client'):
+                logger.warning("No Supabase client available for statistics saving")
+                return False
+            
+            # Convert Decimal to float for JSON serialization
+            save_data = stats.copy()
+            save_data['total_input_units'] = float(stats['total_input_units'])
+            save_data['total_output_units'] = float(stats['total_output_units'])
+            save_data['total_cost_usd'] = float(stats['total_cost_usd'])
+            # Handle datetime conversion for last_updated
+            if isinstance(stats['last_updated'], str):
+                save_data['last_updated'] = stats['last_updated']
+            else:
+                save_data['last_updated'] = stats['last_updated'].isoformat()
+            
+            # Handle datetime conversion for created_at
+            created_at = stats.get('created_at', datetime.now(timezone.utc))
+            if isinstance(created_at, str):
+                save_data['created_at'] = created_at
+            else:
+                save_data['created_at'] = created_at.isoformat()
+            
+            # Upsert to handle duplicates
+            result = self.model_registry.supabase_client.table('model_statistics').upsert(
+                save_data,
+                on_conflict='model_id,provider,service_type,operation_type,date'
+            ).execute()
+            
+            if result.data:
+                logger.debug(f"Updated statistics for {stats['model_id']} on {stats['date']}")
+                return True
+            else:
+                logger.warning("Failed to save statistics to database")
+                return False
+                
+        except Exception as e:
+            logger.error(f"Failed to save daily statistics: {e}")
+            return False
+    
+    def get_model_summary(self, model_id: str = None, days: int = 30) -> List[Dict[str, Any]]:
+        """Get usage summary for a model or all models"""
+        try:
+            if not self.model_registry or not hasattr(self.model_registry, 'supabase_client'):
+                return []
+            
+            query = self.model_registry.supabase_client.table('model_statistics').select('*')
+            
+            if model_id:
+                query = query.eq('model_id', model_id)
+            
+            if days > 0:
+                from datetime import timedelta
+                start_date = (date.today() - timedelta(days=days)).isoformat()
+                query = query.gte('date', start_date)
+            
+            result = query.order('date', desc=True).execute()
+            return result.data or []
+            
+        except Exception as e:
+            logger.error(f"Failed to get model summary: {e}")
+            return []
+    
+    def get_daily_totals(self, target_date: date = None) -> Dict[str, Any]:
+        """Get total usage for a specific date"""
+        if target_date is None:
+            target_date = date.today()
+            
+        try:
+            if not self.model_registry or not hasattr(self.model_registry, 'supabase_client'):
+                return {}
+            
+            result = self.model_registry.supabase_client.table('model_statistics').select(
+                'total_requests,total_input_tokens,total_output_tokens,total_cost_usd'
+            ).eq('date', target_date.isoformat()).execute()
+            
+            if not result.data:
+                return {'total_requests': 0, 'total_cost': 0.0}
+            
+            totals = {
+                'total_requests': sum(row.get('total_requests', 0) for row in result.data),
+                'total_input_tokens': sum(row.get('total_input_tokens', 0) for row in result.data),
+                'total_output_tokens': sum(row.get('total_output_tokens', 0) for row in result.data),
+                'total_cost': sum(float(row.get('total_cost_usd', 0)) for row in result.data),
+                'date': target_date.isoformat()
+            }
+            
+            return totals
+            
+        except Exception as e:
+            logger.error(f"Failed to get daily totals: {e}")
+            return {'total_requests': 0, 'total_cost': 0.0}
+    
+    def clear_cache(self):
+        """Clear the daily cache"""
+        self._daily_cache.clear()
+        logger.debug("Statistics cache cleared")

isa_model/core/models/model_storage.py

@@ -57,7 +57,6 @@ class LocalModelStorage(ModelStorage):
                 self.metadata = json.load(f)
         else:
             self.metadata = {}
-            self._save_metadata()
     
     def _save_metadata(self):
         """Save model metadata to file"""