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

isa_model/inference/services/vision/vgg16_vision_service.py

@@ -0,0 +1,257 @@
+#!/usr/bin/env python3
+"""
+VGG16 Vision Service
+Computer vision service using VGG16 for image classification
+Based on the aircraft damage detection notebook implementation
+"""
+
+import os
+import numpy as np
+from typing import Dict, List, Any, Optional, Union, BinaryIO
+import logging
+from PIL import Image
+import io
+
+from .base_vision_service import BaseVisionService
+
+logger = logging.getLogger(__name__)
+
+def _lazy_import_vgg16_deps():
+    """Lazy import VGG16 dependencies"""
+    try:
+        import tensorflow as tf
+        from tensorflow.keras.applications import VGG16
+        from tensorflow.keras.layers import Dense, Dropout, Flatten
+        from tensorflow.keras.models import Sequential, Model
+        from tensorflow.keras.optimizers import Adam
+        from tensorflow.keras.preprocessing.image import ImageDataGenerator
+        
+        return {
+            'tf': tf,
+            'VGG16': VGG16,
+            'Dense': Dense,
+            'Dropout': Dropout,
+            'Flatten': Flatten,
+            'Sequential': Sequential,
+            'Model': Model,
+            'Adam': Adam,
+            'ImageDataGenerator': ImageDataGenerator,
+            'available': True
+        }
+    except ImportError as e:
+        logger.warning(f"VGG16 dependencies not available: {e}")
+        return {'available': False}
+
+class VGG16VisionService(BaseVisionService):
+    """
+    VGG16-based vision service for image classification
+    Provides an alternative implementation to VLM-based classification
+    """
+    
+    def __init__(self, model_path: Optional[str] = None, class_names: Optional[List[str]] = None):
+        """
+        Initialize VGG16 vision service
+        
+        Args:
+            model_path: Path to trained VGG16 model
+            class_names: List of class names for classification
+        """
+        super().__init__()
+        
+        self.model_path = model_path
+        self.class_names = class_names or ["class_0", "class_1"]
+        self.model = None
+        self.input_shape = (224, 224, 3)
+        
+        # Lazy load dependencies
+        self.vgg16_components = _lazy_import_vgg16_deps()
+        
+        if not self.vgg16_components['available']:
+            raise ImportError("TensorFlow and VGG16 dependencies are required")
+        
+        # Load model if path provided
+        if model_path and os.path.exists(model_path):
+            self._load_model(model_path)
+    
+    def _load_model(self, model_path: str):
+        """Load trained VGG16 model"""
+        try:
+            tf = self.vgg16_components['tf']
+            self.model = tf.keras.models.load_model(model_path)
+            logger.info(f"VGG16 model loaded from {model_path}")
+        except Exception as e:
+            logger.error(f"Error loading VGG16 model: {e}")
+            raise
+    
+    def _preprocess_image(self, image: Union[str, BinaryIO]) -> np.ndarray:
+        """
+        Preprocess image for VGG16 input
+        
+        Args:
+            image: Image path or binary data
+            
+        Returns:
+            Preprocessed image array
+        """
+        try:
+            # Handle different image input types
+            if isinstance(image, str):
+                # File path
+                pil_image = Image.open(image).convert('RGB')
+            elif hasattr(image, 'read'):
+                # Binary IO
+                image_data = image.read()
+                pil_image = Image.open(io.BytesIO(image_data)).convert('RGB')
+            else:
+                raise ValueError("Unsupported image format")
+            
+            # Resize to VGG16 input size
+            pil_image = pil_image.resize((self.input_shape[0], self.input_shape[1]))
+            
+            # Convert to array and normalize
+            image_array = np.array(pil_image) / 255.0
+            
+            # Add batch dimension
+            image_batch = np.expand_dims(image_array, axis=0)
+            
+            return image_batch, image_array
+            
+        except Exception as e:
+            logger.error(f"Error preprocessing image: {e}")
+            raise
+    
+    async def classify_image(self, 
+                           image: Union[str, BinaryIO], 
+                           categories: Optional[List[str]] = None) -> Dict[str, Any]:
+        """
+        Classify image using trained VGG16 model
+        
+        Args:
+            image: Image path or binary data
+            categories: Optional list of categories (uses model's classes if None)
+            
+        Returns:
+            Classification results
+        """
+        try:
+            if self.model is None:
+                return {
+                    "error": "No trained model available. Please load a model first.",
+                    "service": "VGG16VisionService"
+                }
+            
+            # Preprocess image
+            image_batch, image_array = self._preprocess_image(image)
+            
+            # Make prediction
+            predictions = self.model.predict(image_batch, verbose=0)
+            
+            # Use provided categories or default class names
+            class_names = categories or self.class_names
+            
+            # Process predictions based on model output
+            if len(predictions[0]) == 1:  # Binary classification
+                predicted_class_idx = int(predictions[0] > 0.5)
+                confidence = float(predictions[0][0]) if predicted_class_idx == 1 else float(1 - predictions[0][0])
+                
+                # Create probability distribution
+                probabilities = {
+                    class_names[0]: float(1 - predictions[0][0]),
+                    class_names[1]: float(predictions[0][0])
+                }
+            else:  # Multiclass classification
+                predicted_class_idx = np.argmax(predictions[0])
+                confidence = float(predictions[0][predicted_class_idx])
+                
+                # Create probability distribution
+                probabilities = {
+                    class_names[i]: float(predictions[0][i]) 
+                    for i in range(min(len(class_names), len(predictions[0])))
+                }
+            
+            predicted_class = class_names[predicted_class_idx] if predicted_class_idx < len(class_names) else f"class_{predicted_class_idx}"
+            
+            return {
+                "task": "classify",
+                "service": "VGG16VisionService",
+                "predicted_class": predicted_class,
+                "confidence": confidence,
+                "probabilities": probabilities,
+                "model_type": "VGG16",
+                "success": True
+            }
+            
+        except Exception as e:
+            logger.error(f"Error classifying image: {e}")
+            return {
+                "error": str(e),
+                "service": "VGG16VisionService",
+                "success": False
+            }
+    
+    async def analyze_image(self, 
+                          image: Union[str, BinaryIO], 
+                          prompt: Optional[str] = None,
+                          max_tokens: int = 1000) -> Dict[str, Any]:
+        """
+        Analyze image using VGG16 classification
+        
+        Args:
+            image: Image path or binary data
+            prompt: Optional prompt (used to guide interpretation)
+            max_tokens: Not used for classification
+            
+        Returns:
+            Analysis results
+        """
+        # For VGG16, analysis is essentially classification
+        classification_result = await self.classify_image(image)
+        
+        if classification_result.get("success"):
+            # Create analysis text based on classification
+            predicted_class = classification_result["predicted_class"]
+            confidence = classification_result["confidence"]
+            
+            analysis_text = f"The image has been classified as '{predicted_class}' with {confidence:.2%} confidence."
+            
+            if prompt:
+                analysis_text += f" Analysis context: {prompt}"
+            
+            return {
+                "task": "analyze",
+                "service": "VGG16VisionService",
+                "text": analysis_text,
+                "confidence": confidence,
+                "classification": classification_result,
+                "success": True
+            }
+        else:
+            return classification_result
+    
+    def set_class_names(self, class_names: List[str]):
+        """Set class names for classification"""
+        self.class_names = class_names
+    
+    def load_trained_model(self, model_path: str, class_names: Optional[List[str]] = None):
+        """
+        Load a trained VGG16 model
+        
+        Args:
+            model_path: Path to the trained model
+            class_names: Optional class names
+        """
+        self._load_model(model_path)
+        if class_names:
+            self.set_class_names(class_names)
+    
+    def get_service_info(self) -> Dict[str, Any]:
+        """Get service information"""
+        return {
+            "service_name": "VGG16VisionService",
+            "model_type": "VGG16",
+            "capabilities": ["classify", "analyze"],
+            "model_loaded": self.model is not None,
+            "input_shape": self.input_shape,
+            "class_names": self.class_names,
+            "dependencies_available": self.vgg16_components['available']
+        }

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