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

isa_model/serving/api/cache_manager.py

@@ -0,0 +1,245 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Simple Cache Manager for ISA Model API
+Provides in-memory caching to improve API performance
+"""
+
+import time
+import logging
+from typing import Dict, Any, Optional, Callable
+from dataclasses import dataclass
+from threading import RLock
+import asyncio
+import hashlib
+import json
+
+logger = logging.getLogger(__name__)
+
+@dataclass
+class CacheEntry:
+    """Cache entry with data and metadata"""
+    data: Any
+    created_at: float
+    ttl: float
+    access_count: int = 0
+    last_accessed: float = None
+    
+    def is_expired(self) -> bool:
+        """Check if cache entry is expired"""
+        return time.time() - self.created_at > self.ttl
+    
+    def access(self) -> Any:
+        """Mark as accessed and return data"""
+        self.access_count += 1
+        self.last_accessed = time.time()
+        return self.data
+
+class APICache:
+    """
+    Simple in-memory cache for API responses
+    Thread-safe with automatic expiration
+    """
+    
+    def __init__(self, default_ttl: float = 300.0, max_size: int = 1000):
+        self.default_ttl = default_ttl  # 5 minutes default
+        self.max_size = max_size
+        self._cache: Dict[str, CacheEntry] = {}
+        self._lock = RLock()
+        self._stats = {
+            "hits": 0,
+            "misses": 0,
+            "evictions": 0,
+            "total_requests": 0
+        }
+    
+    def _generate_key(self, *args, **kwargs) -> str:
+        """Generate cache key from arguments"""
+        # Create a stable key from arguments
+        key_data = {
+            "args": args,
+            "kwargs": sorted(kwargs.items()) if kwargs else {}
+        }
+        key_string = json.dumps(key_data, sort_keys=True, default=str)
+        return hashlib.md5(key_string.encode()).hexdigest()
+    
+    def _cleanup_expired(self):
+        """Remove expired entries"""
+        with self._lock:
+            current_time = time.time()
+            expired_keys = [
+                key for key, entry in self._cache.items()
+                if entry.is_expired()
+            ]
+            
+            for key in expired_keys:
+                del self._cache[key]
+            
+            if expired_keys:
+                logger.debug(f"Cleaned up {len(expired_keys)} expired cache entries")
+    
+    def _evict_lru(self):
+        """Evict least recently used entries when cache is full"""
+        with self._lock:
+            if len(self._cache) >= self.max_size:
+                # Sort by last_accessed time (LRU)
+                sorted_entries = sorted(
+                    self._cache.items(),
+                    key=lambda x: x[1].last_accessed or x[1].created_at
+                )
+                
+                # Remove oldest 20% of entries
+                num_to_remove = max(1, len(sorted_entries) // 5)
+                for key, _ in sorted_entries[:num_to_remove]:
+                    del self._cache[key]
+                    self._stats["evictions"] += 1
+                
+                logger.debug(f"Evicted {num_to_remove} LRU cache entries")
+    
+    def get(self, key: str) -> Optional[Any]:
+        """Get cached value by key"""
+        with self._lock:
+            self._stats["total_requests"] += 1
+            
+            if key in self._cache:
+                entry = self._cache[key]
+                if not entry.is_expired():
+                    self._stats["hits"] += 1
+                    return entry.access()
+                else:
+                    # Remove expired entry
+                    del self._cache[key]
+            
+            self._stats["misses"] += 1
+            return None
+    
+    def set(self, key: str, value: Any, ttl: Optional[float] = None) -> None:
+        """Set cached value with optional TTL"""
+        with self._lock:
+            # Cleanup and eviction
+            self._cleanup_expired()
+            self._evict_lru()
+            
+            entry = CacheEntry(
+                data=value,
+                created_at=time.time(),
+                ttl=ttl or self.default_ttl,
+                last_accessed=time.time()
+            )
+            
+            self._cache[key] = entry
+    
+    def delete(self, key: str) -> bool:
+        """Delete cached value"""
+        with self._lock:
+            if key in self._cache:
+                del self._cache[key]
+                return True
+            return False
+    
+    def clear(self) -> None:
+        """Clear all cached values"""
+        with self._lock:
+            self._cache.clear()
+            logger.info("Cache cleared")
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """Get cache statistics"""
+        with self._lock:
+            hit_rate = (
+                self._stats["hits"] / self._stats["total_requests"]
+                if self._stats["total_requests"] > 0 else 0
+            )
+            
+            return {
+                "cache_size": len(self._cache),
+                "max_size": self.max_size,
+                "default_ttl": self.default_ttl,
+                "hit_rate": round(hit_rate * 100, 2),
+                **self._stats
+            }
+
+# Decorator for caching function results
+def cached(ttl: float = 300.0, cache_key_func: Optional[Callable] = None):
+    """
+    Decorator to cache function results
+    
+    Args:
+        ttl: Time to live in seconds
+        cache_key_func: Custom function to generate cache key
+    """
+    def decorator(func):
+        async def async_wrapper(*args, **kwargs):
+            # Generate cache key
+            if cache_key_func:
+                cache_key = cache_key_func(*args, **kwargs)
+            else:
+                cache_key = api_cache._generate_key(func.__name__, *args, **kwargs)
+            
+            # Try to get from cache
+            cached_result = api_cache.get(cache_key)
+            if cached_result is not None:
+                logger.debug(f"Cache hit for {func.__name__}")
+                return cached_result
+            
+            # Execute function and cache result
+            try:
+                result = await func(*args, **kwargs)
+                api_cache.set(cache_key, result, ttl)
+                logger.debug(f"Cached result for {func.__name__}")
+                return result
+            except Exception as e:
+                logger.error(f"Function {func.__name__} failed: {e}")
+                raise
+        
+        def sync_wrapper(*args, **kwargs):
+            # Generate cache key
+            if cache_key_func:
+                cache_key = cache_key_func(*args, **kwargs)
+            else:
+                cache_key = api_cache._generate_key(func.__name__, *args, **kwargs)
+            
+            # Try to get from cache
+            cached_result = api_cache.get(cache_key)
+            if cached_result is not None:
+                logger.debug(f"Cache hit for {func.__name__}")
+                return cached_result
+            
+            # Execute function and cache result
+            try:
+                result = func(*args, **kwargs)
+                api_cache.set(cache_key, result, ttl)
+                logger.debug(f"Cached result for {func.__name__}")
+                return result
+            except Exception as e:
+                logger.error(f"Function {func.__name__} failed: {e}")
+                raise
+        
+        # Return appropriate wrapper based on function type
+        if asyncio.iscoroutinefunction(func):
+            return async_wrapper
+        else:
+            return sync_wrapper
+    
+    return decorator
+
+# Global cache instance
+api_cache = APICache(default_ttl=300.0, max_size=1000)
+
+def get_api_cache() -> APICache:
+    """Get the global API cache instance"""
+    return api_cache
+
+# Cache key generators for common patterns
+def model_list_cache_key(service_type=None):
+    """Generate cache key for model list API"""
+    return f"models_list_{service_type or 'all'}"
+
+def provider_list_cache_key():
+    """Generate cache key for provider list API"""
+    return "providers_list"
+
+def custom_models_cache_key(model_type=None, provider=None):
+    """Generate cache key for custom models API"""
+    return f"custom_models_{model_type or 'all'}_{provider or 'all'}"

isa_model/serving/api/dependencies/__init__.py

@@ -0,0 +1 @@
+# Dependencies module

isa_model/serving/api/dependencies/auth.py

@@ -0,0 +1,194 @@
+"""
+Authentication and Authorization Dependencies
+
+FastAPI dependencies for handling authentication, authorization,
+and tenant access control. Integrates with existing auth middleware.
+"""
+
+from fastapi import HTTPException, Depends, Request
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from typing import Optional, Dict, Any
+import logging
+
+from ..middleware.tenant_context import get_tenant_context, require_tenant_context, TenantContext
+from ..middleware.auth import authenticate_api_key, require_admin_access as require_api_admin
+
+logger = logging.getLogger(__name__)
+
+class User:
+    """User model for authentication"""
+    def __init__(self, user_id: str, email: str, role: str = "member", organization_id: str = None):
+        self.user_id = user_id
+        self.email = email
+        self.role = role
+        self.organization_id = organization_id
+    
+    def is_admin(self) -> bool:
+        return self.role in ["admin", "owner"]
+    
+    def is_system_admin(self) -> bool:
+        return self.role == "system_admin"
+
+class Organization:
+    """Organization model"""
+    def __init__(self, organization_id: str, name: str, plan: str = "starter", status: str = "active"):
+        self.organization_id = organization_id
+        self.name = name
+        self.plan = plan
+        self.status = status
+
+async def get_current_user(
+    auth_data: Dict = Depends(authenticate_api_key)
+) -> Optional[User]:
+    """
+    Get current authenticated user from existing auth system.
+    Integrates with the existing API key authentication.
+    """
+    try:
+        if not auth_data.get("authenticated", True):  # Anonymous when auth disabled
+            return None
+            
+        # Get tenant context which should contain user info
+        tenant_context = get_tenant_context()
+        
+        # Create user from auth data and tenant context
+        user_id = tenant_context.user_id if tenant_context else auth_data.get("name", "anonymous")
+        organization_id = tenant_context.organization_id if tenant_context else None
+        
+        # Map API key scopes to user roles
+        scopes = auth_data.get("scopes", [])
+        if "admin" in scopes:
+            role = "admin"
+        elif "write" in scopes:
+            role = "member"
+        else:
+            role = "viewer"
+            
+        return User(
+            user_id=user_id,
+            email=f"{user_id}@example.com",  # TODO: Get from database
+            role=role,
+            organization_id=organization_id
+        )
+        
+    except Exception as e:
+        logger.error(f"Error getting current user: {e}")
+        return None
+
+async def require_authenticated_user(
+    current_user: Optional[User] = Depends(get_current_user)
+) -> User:
+    """
+    Require authenticated user or raise 401 error.
+    """
+    if not current_user:
+        raise HTTPException(
+            status_code=401,
+            detail="Authentication required"
+        )
+    return current_user
+
+async def get_current_organization() -> Optional[Organization]:
+    """
+    Get current organization from tenant context.
+    """
+    try:
+        tenant_context = get_tenant_context()
+        if tenant_context:
+            return Organization(
+                organization_id=tenant_context.organization_id,
+                name="Organization",  # TODO: Get from database
+                plan=tenant_context.plan,
+                status="active"
+            )
+        return None
+        
+    except Exception as e:
+        logger.error(f"Error getting current organization: {e}")
+        return None
+
+async def require_organization_access() -> Organization:
+    """
+    Require organization context or raise 401 error.
+    """
+    org = await get_current_organization()
+    if not org:
+        raise HTTPException(
+            status_code=401,
+            detail="Organization access required"
+        )
+    return org
+
+async def require_admin(
+    auth_data: Dict = Depends(require_api_admin),
+    current_user: User = Depends(get_current_user)
+) -> User:
+    """
+    Require admin role within organization.
+    Uses existing API key admin check plus tenant context.
+    """
+    if not current_user or not current_user.is_admin():
+        raise HTTPException(
+            status_code=403,
+            detail="Admin privileges required"
+        )
+    return current_user
+
+async def require_system_admin(
+    auth_data: Dict = Depends(require_api_admin)
+) -> Dict:
+    """
+    Require system admin role (for tenant management).
+    For now, maps to API key admin access.
+    """
+    # For system admin, require API key admin access
+    return auth_data
+
+def require_plan(min_plan: str):
+    """
+    Factory function to create dependency that requires specific plan level.
+    Usage: Depends(require_plan("pro"))
+    """
+    async def _check_plan():
+        tenant_context = get_tenant_context()
+        if not tenant_context:
+            raise HTTPException(
+                status_code=401,
+                detail="Authentication required"
+            )
+        
+        plan_hierarchy = {
+            "starter": 1,
+            "pro": 2,
+            "enterprise": 3
+        }
+        
+        current_plan_level = plan_hierarchy.get(tenant_context.plan, 0)
+        required_plan_level = plan_hierarchy.get(min_plan, 99)
+        
+        if current_plan_level < required_plan_level:
+            raise HTTPException(
+                status_code=403,
+                detail=f"Plan upgrade required. Current: {tenant_context.plan}, Required: {min_plan}"
+            )
+        
+        return tenant_context
+    
+    return _check_plan
+
+def check_resource_access(resource_type: str, action: str = "read"):
+    """
+    Factory function to create dependency that checks resource access permissions.
+    """
+    async def _check_access():
+        tenant_context = require_tenant_context()
+        
+        if not tenant_context.can_access_resource(resource_type, action):
+            raise HTTPException(
+                status_code=403,
+                detail=f"Access denied to {resource_type}"
+            )
+        
+        return tenant_context
+    
+    return _check_access

isa_model/serving/api/dependencies/database.py

@@ -0,0 +1,139 @@
+"""
+Database Connection Dependencies
+
+Provides database connections and transaction management
+with automatic tenant context handling.
+"""
+
+import asyncio
+import asyncpg
+import logging
+import os
+from contextlib import asynccontextmanager
+from typing import Optional
+
+from ..middleware.tenant_context import get_tenant_context
+
+logger = logging.getLogger(__name__)
+
+# Global connection pool
+_connection_pool: Optional[asyncpg.Pool] = None
+
+async def initialize_database_pool():
+    """Initialize the database connection pool"""
+    global _connection_pool
+    
+    if _connection_pool:
+        return _connection_pool
+    
+    database_url = os.getenv("DATABASE_URL")
+    if not database_url:
+        raise RuntimeError("DATABASE_URL environment variable not set")
+    
+    try:
+        _connection_pool = await asyncpg.create_pool(
+            database_url,
+            min_size=5,
+            max_size=20,
+            command_timeout=60,
+            server_settings={
+                'search_path': 'dev',
+                'timezone': 'UTC'
+            }
+        )
+        
+        logger.info("Database connection pool initialized")
+        return _connection_pool
+        
+    except Exception as e:
+        logger.error(f"Failed to initialize database pool: {e}")
+        raise
+
+async def close_database_pool():
+    """Close the database connection pool"""
+    global _connection_pool
+    
+    if _connection_pool:
+        await _connection_pool.close()
+        _connection_pool = None
+        logger.info("Database connection pool closed")
+
+@asynccontextmanager
+async def get_database_connection():
+    """
+    Get a database connection from the pool with automatic tenant context.
+    
+    This context manager automatically:
+    1. Gets a connection from the pool
+    2. Sets the tenant context if available
+    3. Handles transactions
+    4. Returns the connection to the pool
+    """
+    if not _connection_pool:
+        await initialize_database_pool()
+    
+    async with _connection_pool.acquire() as conn:
+        try:
+            # Set tenant context if available
+            tenant_context = get_tenant_context()
+            if tenant_context:
+                await conn.execute(
+                    "SELECT set_config('app.current_organization_id', $1, true)",
+                    tenant_context.organization_id
+                )
+                
+            yield conn
+            
+        except Exception as e:
+            logger.error(f"Database operation error: {e}")
+            raise
+        finally:
+            # Clear tenant context
+            try:
+                await conn.execute(
+                    "SELECT set_config('app.current_organization_id', '', true)"
+                )
+            except:
+                pass  # Ignore cleanup errors
+
+@asynccontextmanager 
+async def get_database_transaction():
+    """
+    Get a database connection with an explicit transaction.
+    """
+    async with get_database_connection() as conn:
+        async with conn.transaction():
+            yield conn
+
+async def execute_query(query: str, *args, fetch_type: str = "fetch"):
+    """
+    Execute a query with automatic connection management.
+    
+    Args:
+        query: SQL query
+        *args: Query parameters
+        fetch_type: 'fetch', 'fetchrow', 'fetchval', or 'execute'
+    """
+    async with get_database_connection() as conn:
+        if fetch_type == "fetch":
+            return await conn.fetch(query, *args)
+        elif fetch_type == "fetchrow":
+            return await conn.fetchrow(query, *args)
+        elif fetch_type == "fetchval":
+            return await conn.fetchval(query, *args)
+        elif fetch_type == "execute":
+            return await conn.execute(query, *args)
+        else:
+            raise ValueError(f"Invalid fetch_type: {fetch_type}")
+
+# FastAPI dependency functions
+
+async def get_db_connection():
+    """FastAPI dependency to get database connection"""
+    async with get_database_connection() as conn:
+        yield conn
+
+async def get_db_transaction():
+    """FastAPI dependency to get database transaction"""
+    async with get_database_transaction() as conn:
+        yield conn