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

isa_model/core/database/supabase_client.py

@@ -8,13 +8,31 @@ Provides a singleton Supabase client instance that:
 """
 
 import logging
+import os
 from typing import Optional
+from urllib.parse import urlparse
 from supabase import create_client, Client
+from supabase.lib.client_options import ClientOptions
+from dotenv import load_dotenv
+from functools import wraps
+import httpx
 
 from ..config.config_manager import ConfigManager
 
 logger = logging.getLogger(__name__)
 
+def require_client(default_return=None):
+    """Decorator to check if client is available before executing method"""
+    def decorator(func):
+        @wraps(func)
+        def wrapper(self, *args, **kwargs):
+            if self._client is None:
+                logger.error(f"Error in {func.__name__}: Supabase client not available")
+                return default_return
+            return func(self, *args, **kwargs)
+        return wrapper
+    return decorator
+
 class SupabaseClient:
     """Singleton Supabase client with environment-aware configuration"""
     
@@ -32,53 +50,144 @@ class SupabaseClient:
             self._initialize_client()
             SupabaseClient._initialized = True
     
+    def _configure_proxy_bypass(self):
+        """Configure proxy bypass for Supabase connections"""
+        # Check if URL is localhost or Docker internal
+        if self.url:
+            parsed_url = urlparse(self.url)
+            hostname = parsed_url.hostname or ''
+            
+            # Check if it's a local connection
+            is_local = hostname in ['localhost', '127.0.0.1', '0.0.0.0', 'host.docker.internal']
+            is_docker = hostname.startswith('172.') or hostname.startswith('192.168.')
+            
+            if is_local or is_docker:
+                logger.info(f"Detected local Supabase at {hostname}, configuring proxy bypass...")
+                
+                # Get current proxy settings
+                http_proxy = os.environ.get('HTTP_PROXY') or os.environ.get('http_proxy')
+                https_proxy = os.environ.get('HTTPS_PROXY') or os.environ.get('https_proxy')
+                
+                if http_proxy or https_proxy:
+                    # Temporarily disable proxy for this connection
+                    no_proxy = os.environ.get('NO_PROXY', '') or os.environ.get('no_proxy', '')
+                    
+                    # Add local addresses to no_proxy
+                    local_addresses = [
+                        'localhost', '127.0.0.1', '0.0.0.0',
+                        'host.docker.internal', '*.local',
+                        '172.*', '192.168.*', '10.*'  # Common Docker/local network ranges
+                    ]
+                    
+                    no_proxy_list = no_proxy.split(',') if no_proxy else []
+                    for addr in local_addresses:
+                        if addr not in no_proxy_list:
+                            no_proxy_list.append(addr)
+                    
+                    # Also add the specific hostname if it's not already there
+                    if hostname and hostname not in no_proxy_list:
+                        no_proxy_list.append(hostname)
+                    
+                    # Update environment variables
+                    updated_no_proxy = ','.join(no_proxy_list)
+                    os.environ['NO_PROXY'] = updated_no_proxy
+                    os.environ['no_proxy'] = updated_no_proxy
+                    
+                    logger.info(f"Updated NO_PROXY to: {updated_no_proxy}")
+                    
+                    # For httpx-based connections, we might need to unset proxy for local connections
+                    if is_local or is_docker:
+                        # Store original values to restore later if needed
+                        self._original_http_proxy = os.environ.pop('HTTP_PROXY', None)
+                        self._original_https_proxy = os.environ.pop('HTTPS_PROXY', None)
+                        os.environ.pop('http_proxy', None)
+                        os.environ.pop('https_proxy', None)
+                        logger.info("Temporarily disabled HTTP/HTTPS proxy for local Supabase connection")
+    
     def _initialize_client(self):
-        """Initialize the Supabase client with configuration from ConfigManager"""
+        """Initialize the Supabase client with flexible environment handling"""
         try:
-            # Get configuration from ConfigManager
-            config_manager = ConfigManager()
-            global_config = config_manager.get_global_config()
+            # Load environment variables with fallback strategy
+            load_dotenv()
+            
+            # Determine environment and load appropriate .env file
+            env = os.getenv("ENVIRONMENT", "development")
+            current_dir = os.path.dirname(os.path.abspath(__file__))
+            project_root = os.path.abspath(os.path.join(current_dir, '../../..'))
             
-            # Get database configuration
-            self.url = global_config.database.supabase_url
-            self.key = global_config.database.supabase_key
-            self.schema = global_config.database.supabase_schema or "public"
-            self.environment = global_config.environment.value
+            # Load environment-specific .env file
+            if env == "development":
+                env_file = os.path.join(project_root, "deployment/dev/.env")
+            elif env == "staging":
+                env_file = os.path.join(project_root, "deployment/staging/env/.env.staging")
+            elif env == "production":
+                env_file = os.path.join(project_root, "deployment/production/env/.env.production")
+            else:
+                env_file = os.path.join(project_root, f"deployment/{env}/.env.{env}")
+            
+            if os.path.exists(env_file):
+                load_dotenv(env_file)
+                logger.debug(f"Loaded environment from {env_file}")
+            
+            # Try multiple environment variable names for flexibility
+            self.url = (
+                os.getenv('SUPABASE_CLOUD_URL') or 
+                os.getenv('NEXT_PUBLIC_SUPABASE_URL') or 
+                os.getenv('SUPABASE_URL') or
+                os.getenv('SUPABASE_LOCAL_URL')
+            )
+            self.key = (
+                os.getenv('SUPABASE_CLOUD_SERVICE_ROLE_KEY') or 
+                os.getenv('SUPABASE_SERVICE_ROLE_KEY') or 
+                os.getenv('SUPABASE_LOCAL_SERVICE_ROLE_KEY') or
+                os.getenv('SUPABASE_ANON_KEY') or
+                os.getenv('SUPABASE_LOCAL_ANON_KEY')
+            )
+            
+            # Get schema from environment variable (with dev fallback)
+            # Force dev schema for local development
+            self.schema = os.getenv('DB_SCHEMA', 'dev')
+            self.environment = env
             
             if not self.url or not self.key:
-                raise ValueError("Supabase URL and key must be configured")
+                logger.warning("Missing Supabase credentials. Database operations will not be available.")
+                logger.warning(f"URL found: {bool(self.url)}, Key found: {bool(self.key)}")
+                self._client = None
+                return
             
             # Create the client
             self._client = create_client(self.url, self.key)
             
             logger.info(f"Supabase client initialized for {self.environment} environment (schema: {self.schema})")
             
+            # Skip connection test to avoid unnecessary database queries and error logs
+            # Database operations will fail gracefully when needed
+            logger.debug("Supabase client initialized (connection test skipped)")
+            
         except Exception as e:
             logger.error(f"Failed to initialize Supabase client: {e}")
-            raise
+            # Don't raise - allow graceful degradation
+            self._client = None
     
-    def get_client(self) -> Client:
+    def get_client(self) -> Optional[Client]:
         """Get the Supabase client instance"""
         if not self._client:
-            raise RuntimeError("Supabase client not initialized")
+            logger.warning("Supabase client not available - database operations will be skipped")
+            return None
         return self._client
     
+    @require_client(default_return=None)
     def table(self, table_name: str):
         """Get a table with the correct schema"""
-        if not self._client:
-            raise RuntimeError("Supabase client not initialized")
-        
         # Use the configured schema for the environment
         if self.schema and self.schema != "public":
             return self._client.schema(self.schema).table(table_name)
         else:
             return self._client.table(table_name)
     
+    @require_client(default_return=None)
     def rpc(self, function_name: str, params: Optional[dict] = None):
         """Call an RPC function with the correct schema"""
-        if not self._client:
-            raise RuntimeError("Supabase client not initialized")
-        
         # RPC functions typically use the public schema
         # But we can extend this if needed for schema-specific functions
         return self._client.rpc(function_name, params)
@@ -101,6 +210,32 @@ class SupabaseClient:
         except Exception as e:
             logger.warning(f"Database connection test failed: {e}")
             return False
+    
+    async def execute_sql(self, sql: str) -> dict:
+        """Execute raw SQL command"""
+        try:
+            result = self._client.rpc('execute_sql', {'sql': sql})
+            return {"success": True, "data": result.data}
+        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:
+        """Execute SQL query with parameters"""
+        try:
+            # For now, use rpc to execute queries
+            # In production, you might want to use prepared statements
+            if params:
+                # Simple parameter substitution (not recommended for production)
+                formatted_query = query % params
+            else:
+                formatted_query = query
+            
+            result = self._client.rpc('execute_query', {'query': formatted_query})
+            return {"success": True, "data": result.data}
+        except Exception as e:
+            logger.error(f"Query execution failed: {e}")
+            return {"success": False, "error": str(e)}
 
 # Global singleton instance
 _supabase_client = None

isa_model/core/dependencies.py

@@ -0,0 +1,316 @@
+"""
+Dependency management and checking utilities for ISA Model.
+
+This module provides utilities for checking optional dependencies
+and providing clear error messages when dependencies are missing.
+"""
+
+import importlib.util
+import logging
+from typing import Dict, List, Optional, Tuple
+from functools import wraps
+
+logger = logging.getLogger(__name__)
+
+
+class DependencyChecker:
+    """Utility class for checking and managing optional dependencies."""
+    
+    # Cache for dependency availability
+    _cache: Dict[str, bool] = {}
+    
+    # Dependency groups with their packages
+    DEPENDENCY_GROUPS = {
+        # LLM Services
+        "openai": ["openai"],
+        "cerebras": ["cerebras.cloud.sdk"],
+        "local_llm": ["torch", "transformers", "accelerate"],
+        "vllm": ["vllm"],
+        
+        # Vision Services
+        "vision_torch": ["torch", "torchvision", "PIL"],
+        "vision_tf": ["tensorflow", "keras"],
+        "vision_transformers": ["transformers", "PIL"],
+        
+        # Audio Services
+        "audio": ["librosa", "soundfile", "numba"],
+        "openai_audio": ["openai"],
+        
+        # Image Generation
+        "replicate": ["replicate"],
+        "image_gen": ["PIL", "requests"],
+        
+        # Training
+        "training_torch": ["torch", "datasets", "peft", "trl"],
+        "training_tf": ["tensorflow", "keras"],
+        
+        # Deployment
+        "modal": ["modal"],
+        "docker": ["docker"],
+        "kubernetes": ["kubernetes"],
+        
+        # Storage
+        "s3": ["boto3"],
+        "gcs": ["google.cloud.storage"],
+        "minio": ["minio"],
+        
+        # Monitoring
+        "mlflow": ["mlflow"],
+        "wandb": ["wandb"],
+        "influxdb": ["influxdb_client"],
+        "loki": ["python_logging_loki"],
+    }
+    
+    @classmethod
+    def check_dependency(cls, package: str) -> bool:
+        """
+        Check if a single package is available.
+        
+        Args:
+            package: Package name to check (e.g., 'torch', 'openai')
+            
+        Returns:
+            True if package is available, False otherwise
+        """
+        if package in cls._cache:
+            return cls._cache[package]
+        
+        spec = importlib.util.find_spec(package.split('.')[0])
+        available = spec is not None
+        cls._cache[package] = available
+        
+        if not available:
+            logger.debug(f"Package '{package}' is not available")
+        
+        return available
+    
+    @classmethod
+    def check_dependencies(cls, packages: List[str]) -> Tuple[bool, List[str]]:
+        """
+        Check if multiple packages are available.
+        
+        Args:
+            packages: List of package names to check
+            
+        Returns:
+            Tuple of (all_available, missing_packages)
+        """
+        missing = []
+        for package in packages:
+            if not cls.check_dependency(package):
+                missing.append(package)
+        
+        return len(missing) == 0, missing
+    
+    @classmethod
+    def check_group(cls, group: str) -> Tuple[bool, List[str]]:
+        """
+        Check if all packages in a dependency group are available.
+        
+        Args:
+            group: Name of the dependency group
+            
+        Returns:
+            Tuple of (all_available, missing_packages)
+        """
+        if group not in cls.DEPENDENCY_GROUPS:
+            raise ValueError(f"Unknown dependency group: {group}")
+        
+        packages = cls.DEPENDENCY_GROUPS[group]
+        return cls.check_dependencies(packages)
+    
+    @classmethod
+    def get_install_command(cls, group: Optional[str] = None, packages: Optional[List[str]] = None) -> str:
+        """
+        Get the pip install command for missing dependencies.
+        
+        Args:
+            group: Dependency group name
+            packages: List of package names
+            
+        Returns:
+            Pip install command string
+        """
+        if group:
+            # Map groups to pyproject.toml extras
+            extras_map = {
+                "openai": "cloud",
+                "cerebras": "cloud",
+                "local_llm": "local",
+                "vision_torch": "vision",
+                "vision_tf": "vision",
+                "audio": "audio",
+                "training_torch": "training",
+                "modal": "cloud",
+                "mlflow": "monitoring",
+            }
+            
+            if group in extras_map:
+                return f"pip install 'isa-model[{extras_map[group]}]'"
+        
+        if packages:
+            return f"pip install {' '.join(packages)}"
+        
+        return "pip install isa-model[all]"
+    
+    @classmethod
+    def require_dependencies(cls, packages: List[str] = None, group: str = None, 
+                           message: str = None):
+        """
+        Decorator to check dependencies before running a function.
+        
+        Args:
+            packages: List of required packages
+            group: Dependency group name
+            message: Custom error message
+        """
+        def decorator(func):
+            @wraps(func)
+            def wrapper(*args, **kwargs):
+                if group:
+                    available, missing = cls.check_group(group)
+                elif packages:
+                    available, missing = cls.check_dependencies(packages)
+                else:
+                    raise ValueError("Either packages or group must be specified")
+                
+                if not available:
+                    error_msg = message or f"Missing required dependencies: {', '.join(missing)}"
+                    install_cmd = cls.get_install_command(group=group, packages=missing)
+                    raise ImportError(f"{error_msg}\nInstall with: {install_cmd}")
+                
+                return func(*args, **kwargs)
+            return wrapper
+        return decorator
+
+
+# Convenience functions for checking common dependencies
+def is_torch_available() -> bool:
+    """Check if PyTorch is available."""
+    return DependencyChecker.check_dependency("torch")
+
+
+def is_tensorflow_available() -> bool:
+    """Check if TensorFlow is available."""
+    return DependencyChecker.check_dependency("tensorflow")
+
+
+def is_transformers_available() -> bool:
+    """Check if Transformers is available."""
+    return DependencyChecker.check_dependency("transformers")
+
+
+def is_openai_available() -> bool:
+    """Check if OpenAI SDK is available."""
+    return DependencyChecker.check_dependency("openai")
+
+
+def is_replicate_available() -> bool:
+    """Check if Replicate SDK is available."""
+    return DependencyChecker.check_dependency("replicate")
+
+
+def is_modal_available() -> bool:
+    """Check if Modal SDK is available."""
+    return DependencyChecker.check_dependency("modal")
+
+
+def is_cerebras_available() -> bool:
+    """Check if Cerebras SDK is available."""
+    return DependencyChecker.check_dependency("cerebras")
+
+
+# Conditional imports with proper error handling
+def import_torch():
+    """Import PyTorch with proper error handling."""
+    if not is_torch_available():
+        raise ImportError(
+            "PyTorch is not installed. "
+            "Install with: pip install 'isa-model[local]' or pip install torch"
+        )
+    import torch
+    return torch
+
+
+def import_transformers():
+    """Import Transformers with proper error handling."""
+    if not is_transformers_available():
+        raise ImportError(
+            "Transformers is not installed. "
+            "Install with: pip install 'isa-model[local]' or pip install transformers"
+        )
+    import transformers
+    return transformers
+
+
+def import_openai():
+    """Import OpenAI with proper error handling."""
+    if not is_openai_available():
+        raise ImportError(
+            "OpenAI SDK is not installed. "
+            "Install with: pip install 'isa-model[cloud]' or pip install openai"
+        )
+    import openai
+    return openai
+
+
+def import_replicate():
+    """Import Replicate with proper error handling."""
+    if not is_replicate_available():
+        raise ImportError(
+            "Replicate SDK is not installed. "
+            "Install with: pip install 'isa-model[cloud]' or pip install replicate"
+        )
+    import replicate
+    return replicate
+
+
+def import_cerebras():
+    """Import Cerebras with proper error handling."""
+    if not is_cerebras_available():
+        raise ImportError(
+            "Cerebras SDK is not installed. "
+            "Install with: pip install cerebras-cloud-sdk"
+        )
+    from cerebras.cloud.sdk import Cerebras
+    return Cerebras
+
+
+# Lazy loading utilities
+class LazyImport:
+    """Lazy import wrapper for optional dependencies."""
+    
+    def __init__(self, module_name: str, package_name: str = None, 
+                 install_hint: str = None):
+        """
+        Initialize lazy import wrapper.
+        
+        Args:
+            module_name: Full module name to import
+            package_name: Package name to check (defaults to module_name)
+            install_hint: Custom installation hint
+        """
+        self.module_name = module_name
+        self.package_name = package_name or module_name.split('.')[0]
+        self.install_hint = install_hint
+        self._module = None
+    
+    def __getattr__(self, name):
+        """Lazy load the module when accessed."""
+        if self._module is None:
+            if not DependencyChecker.check_dependency(self.package_name):
+                hint = self.install_hint or f"pip install {self.package_name}"
+                raise ImportError(
+                    f"{self.module_name} is not installed. Install with: {hint}"
+                )
+            
+            import importlib
+            self._module = importlib.import_module(self.module_name)
+        
+        return getattr(self._module, name)
+    
+    def __call__(self, *args, **kwargs):
+        """Support direct calling for classes."""
+        if self._module is None:
+            self.__getattr__('__call__')  # Trigger lazy loading
+        return self._module(*args, **kwargs)

isa_model/core/discovery/__init__.py

@@ -0,0 +1,19 @@
+"""
+Service Discovery Module for ISA Model Core
+
+Provides service discovery capabilities using Consul for dynamic service resolution.
+"""
+
+from .consul_discovery import (
+    ConsulServiceDiscovery,
+    get_consul_discovery,
+    discover_service,
+    resolve_url
+)
+
+__all__ = [
+    "ConsulServiceDiscovery",
+    "get_consul_discovery", 
+    "discover_service",
+    "resolve_url"
+]