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

isa_model/core/cache/redis_cache.py

@@ -14,18 +14,27 @@ import pickle
 import asyncio
 import time
 import logging
+import os
 from typing import Any, Dict, Optional, Union, List, Callable
 from dataclasses import dataclass
 import redis.asyncio as redis
 import structlog
 from functools import wraps
 
+from ..config.config_manager import ConfigManager
+
 logger = structlog.get_logger(__name__)
 
 @dataclass
 class CacheConfig:
     """Configuration for Redis cache"""
-    redis_url: str = "redis://localhost:6379"
+    redis_url: str = None
+    
+    def __post_init__(self):
+        if self.redis_url is None:
+            config_manager = ConfigManager()
+            # Use Consul discovery for Redis URL with fallback
+            self.redis_url = config_manager.get_redis_url()
     default_ttl: int = 3600  # 1 hour
     model_cache_ttl: int = 3600  # 1 hour for model responses
     config_cache_ttl: int = 7200  # 2 hours for configurations
@@ -289,9 +298,9 @@ async def get_cache() -> RedisCache:
     global _cache
     
     if _cache is None:
-        import os
+        config_manager = ConfigManager()
         config = CacheConfig(
-            redis_url=os.getenv("REDIS_URL", "redis://localhost:6379"),
+            redis_url=os.getenv("REDIS_URL", config_manager.get_redis_url()),
             default_ttl=int(os.getenv("CACHE_DEFAULT_TTL", "3600")),
             model_cache_ttl=int(os.getenv("MODEL_CACHE_TTL", "3600")),
             compression_enabled=os.getenv("CACHE_COMPRESSION", "true").lower() == "true"

isa_model/core/config/config_manager.py

@@ -41,6 +41,38 @@ class ProviderConfig:
     models: List[Dict[str, Any]] = field(default_factory=list)
     metadata: Dict[str, Any] = field(default_factory=dict)
 
+@dataclass
+class ConsulConfig:
+    """Consul service discovery configuration"""
+    enabled: bool = True
+    host: str = "localhost"
+    port: int = 8500
+    timeout: int = 10
+    
+@dataclass
+class ServiceConfig:
+    """Service endpoint configuration with Consul discovery support"""
+    # Enable Consul discovery
+    use_consul_discovery: bool = True
+    
+    # Fallback URLs when Consul is unavailable
+    mcp_base_url: str = "http://localhost:8081"
+    ollama_base_url: str = "http://localhost:11434"
+    influxdb_url: str = "http://localhost:8086"
+    loki_url: str = "http://localhost:3100"
+    minio_endpoint: str = "localhost:9000"
+    redis_url: str = "redis://localhost:6379"
+    api_port: int = 8000
+    redis_port: int = 6379
+    
+    # Consul service names for discovery
+    mcp_service_name: str = "mcp"
+    ollama_service_name: str = "ollama"
+    influxdb_service_name: str = "influxdb"
+    loki_service_name: str = "loki"
+    minio_service_name: str = "minio"
+    redis_service_name: str = "redis"
+
 @dataclass
 class DatabaseConfig:
     """Database configuration"""
@@ -50,6 +82,7 @@ class DatabaseConfig:
     supabase_schema: Optional[str] = None
     fallback_to_sqlite: bool = False
     sqlite_path: str = "./isa_model.db"
+    default_database_url: str = "postgresql://postgres:postgres@127.0.0.1:54322/postgres?options=-c%20search_path%3Ddev"
     connection_pool_size: int = 10
     max_retries: int = 3
 
@@ -110,6 +143,8 @@ class GlobalConfig:
     debug: bool = False
     
     # Component configurations
+    consul: ConsulConfig = field(default_factory=ConsulConfig)
+    services: ServiceConfig = field(default_factory=ServiceConfig)
     database: DatabaseConfig = field(default_factory=DatabaseConfig)
     deployment: DeploymentConfig = field(default_factory=DeploymentConfig)
     api: APIConfig = field(default_factory=APIConfig)
@@ -143,8 +178,10 @@ class ConfigManager:
             self.global_config: Optional[GlobalConfig] = None
             self.provider_configs: Dict[str, ProviderConfig] = {}
             self.model_definitions: Dict[str, Dict[str, Any]] = {}
+            self._consul_discovery = None
             
             self._load_configuration()
+            self._initialize_consul_discovery()
             ConfigManager._initialized = True
     
     def _load_configuration(self):
@@ -220,6 +257,8 @@ class ConfigManager:
             self.global_config = GlobalConfig(
                 environment=environment,
                 debug=env_data.get('debug', False),
+                consul=ConsulConfig(**env_data.get('consul', {})),
+                services=ServiceConfig(**env_data.get('services', {})),
                 database=DatabaseConfig(**env_data.get('database', {})),
                 deployment=DeploymentConfig(**env_data.get('deployment', {})),
                 api=APIConfig(**env_data.get('api', {})),
@@ -265,6 +304,10 @@ class ConfigManager:
                 "api_key": ["YYDS_API_KEY"],
                 "api_base_url": ["YYDS_API_BASE", "YYDS_BASE_URL"],
             },
+            Provider.CEREBRAS: {
+                "api_key": ["CEREBRAS_API_KEY"],
+                "api_base_url": ["CEREBRAS_API_BASE", "CEREBRAS_BASE_URL"],
+            },
         }
         
         for provider, env_vars in provider_env_mapping.items():
@@ -344,7 +387,9 @@ class ConfigManager:
         # This can be enhanced later with deployment-specific YAML files
         deployment_env_mapping = {
             DeploymentPlatform.MODAL: {
-                "api_key": ["MODAL_TOKEN"],
+                "token_id": ["MODAL_TOKEN_ID"],
+                "token_secret": ["MODAL_TOKEN_SECRET"],
+                "environment": ["MODAL_ENVIRONMENT"],
                 "endpoint": ["MODAL_ENDPOINT"],
             },
             DeploymentPlatform.RUNPOD: {
@@ -428,6 +473,92 @@ class ConfigManager:
             
         logger.debug(f"Database configured for {env}: schema={schema}, url={supabase_url}")
     
+    def _initialize_consul_discovery(self):
+        """Initialize Consul service discovery client"""
+        if not self.global_config or not self.global_config.consul.enabled:
+            logger.info("Consul discovery disabled")
+            return
+            
+        try:
+            from ..discovery.consul_discovery import ConsulServiceDiscovery
+            self._consul_discovery = ConsulServiceDiscovery(
+                consul_host=self.global_config.consul.host,
+                consul_port=self.global_config.consul.port
+            )
+            
+            if self._consul_discovery.is_available():
+                logger.info("Consul service discovery initialized successfully")
+            else:
+                logger.warning("Consul not available, using fallback URLs")
+                self._consul_discovery = None
+                
+        except ImportError as e:
+            logger.warning(f"Consul discovery not available: {e}")
+            self._consul_discovery = None
+        except Exception as e:
+            logger.error(f"Failed to initialize Consul discovery: {e}")
+            self._consul_discovery = None
+    
+    def _apply_service_env_overrides(self):
+        """Apply service endpoint environment variable overrides"""
+        if not self.global_config:
+            return
+            
+        # Consul configuration overrides
+        consul_env_mapping = {
+            "enabled": ["CONSUL_ENABLED"],
+            "host": ["CONSUL_HOST"],
+            "port": ["CONSUL_PORT"],
+        }
+        
+        for setting, env_vars in consul_env_mapping.items():
+            for env_var in env_vars:
+                value = os.getenv(env_var)
+                if value:
+                    if setting == "enabled":
+                        setattr(self.global_config.consul, setting, value.lower() == "true")
+                    elif setting == "port":
+                        try:
+                            setattr(self.global_config.consul, setting, int(value))
+                        except ValueError:
+                            continue
+                    else:
+                        setattr(self.global_config.consul, setting, value)
+                    break
+        
+        # Service endpoint overrides
+        service_env_mapping = {
+            "use_consul_discovery": ["USE_CONSUL_DISCOVERY"],
+            "mcp_base_url": ["MCP_BASE_URL", "MCP_URL"],
+            "ollama_base_url": ["OLLAMA_BASE_URL", "OLLAMA_URL"],
+            "influxdb_url": ["INFLUXDB_URL", "INFLUX_URL"],
+            "loki_url": ["LOKI_URL"],
+            "minio_endpoint": ["MINIO_ENDPOINT", "MINIO_HOST"],
+            "redis_url": ["REDIS_URL"],
+            "redis_port": ["REDIS_PORT"],
+            "mcp_service_name": ["MCP_SERVICE_NAME"],
+            "ollama_service_name": ["OLLAMA_SERVICE_NAME"],
+            "influxdb_service_name": ["INFLUXDB_SERVICE_NAME"],
+            "loki_service_name": ["LOKI_SERVICE_NAME"],
+            "minio_service_name": ["MINIO_SERVICE_NAME"],
+            "redis_service_name": ["REDIS_SERVICE_NAME"],
+        }
+        
+        for setting, env_vars in service_env_mapping.items():
+            for env_var in env_vars:
+                value = os.getenv(env_var)
+                if value:
+                    if setting == "use_consul_discovery":
+                        setattr(self.global_config.services, setting, value.lower() == "true")
+                    elif setting in ["redis_port"]:
+                        try:
+                            setattr(self.global_config.services, setting, int(value))
+                        except ValueError:
+                            continue
+                    else:
+                        setattr(self.global_config.services, setting, value)
+                    break
+    
     def _apply_env_overrides(self):
         """Apply environment variable overrides"""
         if not self.global_config:
@@ -436,13 +567,15 @@ class ConfigManager:
         # Environment-based database configuration
         self._configure_database_for_environment()
         
-        # Other overrides
+        # Service configuration overrides
+        self._apply_service_env_overrides()
         
         # Serving overrides
-        port_env = os.getenv("PORT")
+        port_env = os.getenv("PORT") or os.getenv("API_PORT")
         if port_env:
             try:
                 self.global_config.serving.port = int(port_env)
+                self.global_config.services.api_port = int(port_env)
             except ValueError:
                 pass
         
@@ -458,6 +591,100 @@ class ConfigManager:
             raise RuntimeError("Configuration not loaded")
         return self.global_config
     
+    def get_service_config(self) -> ServiceConfig:
+        """Get service configuration"""
+        if not self.global_config:
+            raise RuntimeError("Configuration not loaded")
+        return self.global_config.services
+    
+    def get_consul_config(self) -> ConsulConfig:
+        """Get Consul configuration"""
+        if not self.global_config:
+            raise RuntimeError("Configuration not loaded")
+        return self.global_config.consul
+    
+    def discover_service_url(self, service_name: str, fallback_url: Optional[str] = None) -> str:
+        """Discover service URL using Consul or return fallback"""
+        if not self.global_config or not self.global_config.services.use_consul_discovery:
+            return fallback_url or self._get_fallback_service_url(service_name)
+            
+        if not self._consul_discovery or not self._consul_discovery.is_available():
+            logger.debug(f"Consul not available, using fallback for {service_name}")
+            return fallback_url or self._get_fallback_service_url(service_name)
+            
+        try:
+            discovered_url = self._consul_discovery.get_service_url(
+                service_name, 
+                fallback_url or self._get_fallback_service_url(service_name)
+            )
+            return discovered_url
+        except Exception as e:
+            logger.warning(f"Failed to discover {service_name}: {e}")
+            return fallback_url or self._get_fallback_service_url(service_name)
+    
+    def _get_fallback_service_url(self, service_name: str) -> str:
+        """Get fallback URL for service based on service name"""
+        if not self.global_config:
+            raise RuntimeError("Configuration not loaded")
+            
+        service_config = self.global_config.services
+        
+        # Map service names to fallback URLs
+        service_mapping = {
+            service_config.mcp_service_name: service_config.mcp_base_url,
+            service_config.ollama_service_name: service_config.ollama_base_url,
+            service_config.influxdb_service_name: service_config.influxdb_url,
+            service_config.loki_service_name: service_config.loki_url,
+            service_config.minio_service_name: f"http://{service_config.minio_endpoint}",
+            service_config.redis_service_name: service_config.redis_url,
+        }
+        
+        return service_mapping.get(service_name, f"http://localhost:8080")
+    
+    def get_mcp_url(self) -> str:
+        """Get MCP service URL (Consul discovery + fallback)"""
+        service_name = self.global_config.services.mcp_service_name
+        return self.discover_service_url(service_name, self.global_config.services.mcp_base_url)
+    
+    def get_ollama_url(self) -> str:
+        """Get Ollama service URL (Consul discovery + fallback)"""
+        service_name = self.global_config.services.ollama_service_name
+        return self.discover_service_url(service_name, self.global_config.services.ollama_base_url)
+    
+    def get_influxdb_url(self) -> str:
+        """Get InfluxDB service URL (Consul discovery + fallback)"""
+        service_name = self.global_config.services.influxdb_service_name
+        return self.discover_service_url(service_name, self.global_config.services.influxdb_url)
+    
+    def get_loki_url(self) -> str:
+        """Get Loki service URL (Consul discovery + fallback)"""
+        service_name = self.global_config.services.loki_service_name
+        return self.discover_service_url(service_name, self.global_config.services.loki_url)
+    
+    def get_minio_url(self) -> str:
+        """Get MinIO service URL (Consul discovery + fallback)"""
+        service_name = self.global_config.services.minio_service_name
+        fallback = f"http://{self.global_config.services.minio_endpoint}"
+        return self.discover_service_url(service_name, fallback)
+    
+    def get_redis_url(self) -> str:
+        """Get Redis service URL (Consul discovery + fallback)"""
+        service_name = self.global_config.services.redis_service_name
+        return self.discover_service_url(service_name, self.global_config.services.redis_url)
+    
+    def resolve_consul_url(self, url: str) -> str:
+        """Resolve consul:// URLs to actual service addresses"""
+        if not url or not url.startswith("consul://"):
+            return url
+            
+        if not self._consul_discovery:
+            # If Consul not available, try to extract service name and use fallback
+            parts = url.replace("consul://", "").split("/", 1)
+            service_name = parts[0]
+            return self._get_fallback_service_url(service_name)
+            
+        return self._consul_discovery.resolve_service_url(url)
+    
     def get_provider_config(self, provider: str) -> Optional[ProviderConfig]:
         """Get provider configuration"""
         return self.provider_configs.get(provider)

isa_model/core/config.py

@@ -48,6 +48,35 @@ class DeploymentConfig:
     metadata: Dict[str, Any] = field(default_factory=dict)
 
 
+@dataclass  
+class LocalGPUGlobalConfig:
+    """Global configuration for local GPU deployment"""
+    enable_local_gpu: bool = True
+    auto_detect_gpu: bool = True
+    workspace_dir: str = "./local_deployments"
+    preferred_backend: str = "api"  # cloud api only
+    
+    # Default resource settings
+    default_gpu_memory_fraction: float = 0.9
+    default_max_batch_size: int = 8
+    default_max_model_len: int = 2048
+    default_precision: str = "float16"
+    
+    # Health monitoring
+    health_check_interval: int = 30  # seconds
+    auto_restart_unhealthy: bool = True
+    max_consecutive_failures: int = 3
+    
+    # Service limits
+    max_concurrent_services: int = 3
+    max_services_per_gpu: int = 2
+    
+    # Performance settings
+    enable_model_compilation: bool = True
+    enable_memory_optimization: bool = True
+    cleanup_on_shutdown: bool = True
+
+
 @dataclass
 class GlobalConfig:
     """Global configuration settings"""
@@ -79,6 +108,18 @@ class GlobalConfig:
     enable_model_cache: bool = True
     cache_size_gb: int = 50
     cache_cleanup_interval: int = 3600  # 1 hour
+    
+    # Local GPU settings
+    enable_local_gpu: bool = True
+    local_gpu_memory_fraction: float = 0.9
+    local_workspace_dir: str = "./local_deployments"
+    auto_detect_gpu: bool = True
+    preferred_local_backend: str = "api"  # cloud api only
+    
+    # Local service defaults
+    local_health_check_interval: int = 30  # seconds
+    local_auto_restart_unhealthy: bool = True
+    local_max_concurrent_services: int = 3
 
 
 class ConfigManager:
@@ -121,6 +162,7 @@ class ConfigManager:
         """Initialize configuration manager"""
         if not self._initialized:
             self.global_config = GlobalConfig()
+            self.local_gpu_config = LocalGPUGlobalConfig()
             self.provider_configs: Dict[str, ProviderConfig] = {}
             self.deployment_configs: Dict[str, DeploymentConfig] = {}
             
@@ -153,6 +195,7 @@ class ConfigManager:
         env_files = [
             project_root / ".env",
             project_root / ".env.local",
+            project_root / "deployment" / "dev" / ".env",
             Path.cwd() / ".env",
         ]
         
@@ -197,6 +240,38 @@ class ConfigManager:
             for key, value in global_settings.items():
                 if hasattr(self.global_config, key):
                     setattr(self.global_config, key, value)
+        
+        # Load database configuration from environment
+        # Check multiple possible environment variable names for compatibility
+        supabase_url = os.getenv("SUPABASE_URL") or os.getenv("SUPABASE_LOCAL_URL")
+        supabase_key = os.getenv("SUPABASE_ANON_KEY") or os.getenv("SUPABASE_LOCAL_ANON_KEY")
+        
+        if supabase_url and supabase_key:
+            self.global_config.use_supabase = True
+            self.global_config.supabase_url = supabase_url
+            self.global_config.supabase_key = supabase_key
+            logger.debug(f"Supabase configured: URL={supabase_url[:30]}...")
+        else:
+            # Check if explicitly disabled
+            use_supabase_env = os.getenv("ISA_USE_SUPABASE", "").lower()
+            if use_supabase_env == "false":
+                self.global_config.use_supabase = False
+            logger.debug("Supabase not configured, using default storage")
+        
+        # Load local GPU configuration
+        local_gpu_settings = {
+            "enable_local_gpu": os.getenv("ISA_ENABLE_LOCAL_GPU", "true").lower() == "true",
+            "auto_detect_gpu": os.getenv("ISA_AUTO_DETECT_GPU", "true").lower() == "true",
+            "workspace_dir": os.getenv("ISA_LOCAL_WORKSPACE_DIR", "./local_deployments"),
+            "preferred_backend": os.getenv("ISA_PREFERRED_LOCAL_BACKEND", "api"),
+            "default_gpu_memory_fraction": float(os.getenv("ISA_GPU_MEMORY_FRACTION", "0.9")),
+            "health_check_interval": int(os.getenv("ISA_LOCAL_HEALTH_CHECK_INTERVAL", "30")),
+            "max_concurrent_services": int(os.getenv("ISA_MAX_CONCURRENT_SERVICES", "3")),
+        }
+        
+        for key, value in local_gpu_settings.items():
+            if hasattr(self.local_gpu_config, key):
+                setattr(self.local_gpu_config, key, value)
     
     def _load_provider_configs(self):
         """Load provider configurations from environment"""
@@ -310,6 +385,21 @@ class ConfigManager:
         """Get configuration for a specific deployment platform"""
         return self.deployment_configs.get(platform.value)
     
+    def get_local_gpu_config(self) -> LocalGPUGlobalConfig:
+        """Get local GPU global configuration"""
+        return self.local_gpu_config
+    
+    def is_local_gpu_enabled(self) -> bool:
+        """Check if local GPU deployment is enabled and available"""
+        if not self.local_gpu_config.enable_local_gpu:
+            return False
+        
+        try:
+            from ..utils.gpu_utils import check_cuda_availability
+            return check_cuda_availability()
+        except ImportError:
+            return False
+    
     def is_provider_enabled(self, provider: Provider) -> bool:
         """Check if a provider is enabled and configured"""
         config = self.get_provider_config(provider)

isa_model/core/database/direct_db_client.py

@@ -0,0 +1,114 @@
+"""
+Direct Database Client for Migrations
+
+Uses direct PostgreSQL connection for database operations like migrations.
+This bypasses Supabase API and connects directly to PostgreSQL for admin operations.
+"""
+
+import logging
+import asyncio
+from typing import Dict, List, Optional, Any, Tuple
+import asyncpg
+import os
+
+logger = logging.getLogger(__name__)
+
+class DirectDBClient:
+    """
+    Direct PostgreSQL client for database administration operations
+    """
+    
+    def __init__(self, database_url: Optional[str] = None):
+        """Initialize direct database client"""
+        self.database_url = database_url or os.getenv("DATABASE_URL")
+        if not self.database_url:
+            # Fallback to individual components
+            host = os.getenv("DB_HOST", "127.0.0.1")
+            port = os.getenv("DB_PORT", "54322")
+            database = os.getenv("DB_NAME", "postgres")
+            user = os.getenv("DB_USER", "postgres")
+            password = os.getenv("DB_PASSWORD", "postgres")
+            self.database_url = f"postgresql://{user}:{password}@{host}:{port}/{database}"
+        
+        self.connection = None
+    
+    async def connect(self) -> bool:
+        """Establish database connection"""
+        try:
+            self.connection = await asyncpg.connect(self.database_url)
+            logger.info("Direct database connection established")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to connect to database: {e}")
+            return False
+    
+    async def disconnect(self):
+        """Close database connection"""
+        if self.connection:
+            await self.connection.close()
+            self.connection = None
+    
+    async def execute_sql(self, sql: str) -> Dict[str, Any]:
+        """Execute raw SQL command"""
+        if not self.connection:
+            if not await self.connect():
+                return {"success": False, "error": "Failed to connect to database"}
+        
+        try:
+            await self.connection.execute(sql)
+            return {"success": True}
+        except Exception as e:
+            logger.error(f"SQL execution failed: {e}")
+            return {"success": False, "error": str(e)}
+    
+    async def execute_query(self, query: str, params: tuple = None) -> Dict[str, Any]:
+        """Execute SQL query with parameters and return results"""
+        if not self.connection:
+            if not await self.connect():
+                return {"success": False, "error": "Failed to connect to database"}
+        
+        try:
+            if params:
+                result = await self.connection.fetch(query, *params)
+            else:
+                result = await self.connection.fetch(query)
+            
+            # Convert asyncpg records to dicts
+            data = [dict(record) for record in result]
+            return {"success": True, "data": data}
+        except Exception as e:
+            logger.error(f"Query execution failed: {e}")
+            return {"success": False, "error": str(e)}
+    
+    async def execute_transaction(self, sql_commands: List[str]) -> Dict[str, Any]:
+        """Execute multiple SQL commands in a transaction"""
+        if not self.connection:
+            if not await self.connect():
+                return {"success": False, "error": "Failed to connect to database"}
+        
+        try:
+            async with self.connection.transaction():
+                for sql in sql_commands:
+                    await self.connection.execute(sql)
+            return {"success": True}
+        except Exception as e:
+            logger.error(f"Transaction failed: {e}")
+            return {"success": False, "error": str(e)}
+    
+    async def test_connection(self) -> bool:
+        """Test database connection"""
+        try:
+            if not self.connection:
+                if not await self.connect():
+                    return False
+            
+            await self.connection.fetchval("SELECT 1")
+            return True
+        except Exception as e:
+            logger.error(f"Connection test failed: {e}")
+            return False
+
+# Factory function
+def create_direct_db_client(database_url: Optional[str] = None) -> DirectDBClient:
+    """Create a direct database client"""
+    return DirectDBClient(database_url)