isa-model 0.3.4__py3-none-any.whl → 0.3.6__py3-none-any.whl

isa_model/serving/api/middleware/request_logger.py

@@ -0,0 +1,88 @@
+"""
+Request Logger Middleware
+
+Logs all incoming requests and responses for monitoring
+"""
+
+from fastapi import Request, Response
+from starlette.middleware.base import BaseHTTPMiddleware
+import time
+import logging
+import json
+from typing import Callable
+
+logger = logging.getLogger(__name__)
+
+class RequestLoggerMiddleware(BaseHTTPMiddleware):
+    """
+    Middleware to log HTTP requests and responses
+    """
+    
+    def __init__(self, app, log_body: bool = False):
+        super().__init__(app)
+        self.log_body = log_body
+    
+    async def dispatch(self, request: Request, call_next: Callable) -> Response:
+        """
+        Process request and log details
+        """
+        start_time = time.time()
+        
+        # Log request
+        request_info = {
+            "method": request.method,
+            "url": str(request.url),
+            "headers": dict(request.headers),
+            "client": request.client.host if request.client else None,
+            "timestamp": start_time
+        }
+        
+        # Optionally log request body (be careful with large images)
+        if self.log_body and request.method in ["POST", "PUT", "PATCH"]:
+            try:
+                body = await request.body()
+                if len(body) < 1024:  # Only log small bodies
+                    request_info["body_size"] = len(body)
+                else:
+                    request_info["body_size"] = len(body)
+                    request_info["body_preview"] = "Large body truncated"
+            except Exception as e:
+                request_info["body_error"] = str(e)
+        
+        logger.info(f"Request: {json.dumps(request_info, default=str)}")
+        
+        # Process request
+        try:
+            response = await call_next(request)
+            
+            # Calculate processing time
+            process_time = time.time() - start_time
+            
+            # Log response
+            response_info = {
+                "status_code": response.status_code,
+                "processing_time": process_time,
+                "url": str(request.url),
+                "method": request.method
+            }
+            
+            # Add processing time header
+            response.headers["X-Process-Time"] = str(process_time)
+            
+            if response.status_code >= 400:
+                logger.warning(f"Response: {json.dumps(response_info, default=str)}")
+            else:
+                logger.info(f"Response: {json.dumps(response_info, default=str)}")
+            
+            return response
+            
+        except Exception as e:
+            process_time = time.time() - start_time
+            error_info = {
+                "error": str(e),
+                "processing_time": process_time,
+                "url": str(request.url),
+                "method": request.method
+            }
+            logger.error(f"Request error: {json.dumps(error_info, default=str)}")
+            raise

isa_model/serving/api/routes/__init__.py

@@ -0,0 +1,5 @@
+"""
+API Routes Module
+
+Contains all API route definitions for different services
+"""

isa_model/serving/api/routes/health.py

@@ -0,0 +1,82 @@
+"""
+Health Check Routes
+
+System health and status endpoints
+"""
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+import time
+import psutil
+import torch
+from typing import Dict, Any
+
+router = APIRouter()
+
+class HealthResponse(BaseModel):
+    status: str
+    timestamp: float
+    version: str
+    uptime: float
+    system: Dict[str, Any]
+
+@router.get("/", response_model=HealthResponse)
+async def health_check():
+    """
+    Basic health check endpoint
+    """
+    return HealthResponse(
+        status="healthy",
+        timestamp=time.time(),
+        version="1.0.0",
+        uptime=time.time(),  # Simplified uptime
+        system={
+            "cpu_percent": psutil.cpu_percent(),
+            "memory_percent": psutil.virtual_memory().percent,
+            "gpu_available": torch.cuda.is_available(),
+            "gpu_count": torch.cuda.device_count() if torch.cuda.is_available() else 0
+        }
+    )
+
+@router.get("/detailed")
+async def detailed_health():
+    """
+    Detailed health check with system information
+    """
+    gpu_info = []
+    if torch.cuda.is_available():
+        for i in range(torch.cuda.device_count()):
+            gpu_info.append({
+                "device": i,
+                "name": torch.cuda.get_device_name(i),
+                "memory_allocated": torch.cuda.memory_allocated(i),
+                "memory_cached": torch.cuda.memory_reserved(i)
+            })
+    
+    return {
+        "status": "healthy",
+        "timestamp": time.time(),
+        "system": {
+            "cpu": {
+                "percent": psutil.cpu_percent(),
+                "count": psutil.cpu_count()
+            },
+            "memory": {
+                "percent": psutil.virtual_memory().percent,
+                "available": psutil.virtual_memory().available,
+                "total": psutil.virtual_memory().total
+            },
+            "gpu": {
+                "available": torch.cuda.is_available(),
+                "devices": gpu_info
+            }
+        }
+    }
+
+@router.get("/ready")
+async def readiness_probe():
+    """
+    Kubernetes readiness probe endpoint
+    """
+    # Add model loading checks here
+    return {"status": "ready", "timestamp": time.time()}

isa_model/serving/api/routes/llm.py

@@ -0,0 +1,19 @@
+"""
+LLM API Routes
+
+Endpoints for language model tasks (placeholder)
+"""
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+router = APIRouter()
+
+@router.get("/")
+async def llm_info():
+    """LLM service information"""
+    return {
+        "service": "llm",
+        "status": "placeholder", 
+        "description": "Language model processing endpoints"
+    }

isa_model/serving/api/routes/ui_analysis.py

@@ -0,0 +1,223 @@
+"""
+UI Analysis API Routes
+
+Endpoints for UI element detection and analysis
+"""
+
+from fastapi import APIRouter, HTTPException, UploadFile, File, Form
+from pydantic import BaseModel
+from typing import List, Dict, Any, Optional
+import base64
+import time
+import logging
+
+from ..schemas.ui_analysis import (
+    UIAnalysisRequest, 
+    UIAnalysisResponse, 
+    UIElement, 
+    ActionPlan
+)
+
+router = APIRouter()
+logger = logging.getLogger(__name__)
+
+class UIAnalysisService:
+    """
+    Placeholder for UI Analysis Service
+    Will be replaced with actual Modal deployment integration
+    """
+    
+    @staticmethod
+    async def analyze_ui(image_b64: str, task_type: str = "search") -> Dict[str, Any]:
+        """
+        Placeholder method for UI analysis
+        """
+        # TODO: Replace with actual Modal service call
+        return {
+            "success": True,
+            "service": "ui_analysis",
+            "total_execution_time": 2.5,
+            "final_output": {
+                "ui_elements": {
+                    "interactive_elements": [
+                        {
+                            "id": "ui_0",
+                            "type": "textbox",
+                            "content": "Search",
+                            "center": [400, 200],
+                            "bbox": [300, 180, 500, 220],
+                            "confidence": 0.95,
+                            "interactable": True
+                        }
+                    ],
+                    "summary": {
+                        "interactive_count": 1,
+                        "detection_confidence": 0.95
+                    }
+                },
+                "action_plan": {
+                    "action_plan": [
+                        {
+                            "step": 1,
+                            "action": "click",
+                            "target_coordinates": [400, 200],
+                            "actual_coordinates": [400, 200],
+                            "description": "Click search box",
+                            "confidence": 0.95
+                        }
+                    ]
+                },
+                "automation_ready": {
+                    "ready": True,
+                    "confidence": 0.95,
+                    "page_type": task_type,
+                    "steps_count": 1
+                }
+            }
+        }
+
+@router.post("/analyze", response_model=UIAnalysisResponse)
+async def analyze_ui_elements(request: UIAnalysisRequest):
+    """
+    Analyze UI elements in an image
+    
+    Args:
+        request: UI analysis request with image and task type
+        
+    Returns:
+        UI analysis results with detected elements and action plan
+    """
+    try:
+        start_time = time.time()
+        
+        # Validate task type
+        valid_task_types = ["login", "search", "content", "navigation"]
+        if request.task_type not in valid_task_types:
+            raise HTTPException(
+                status_code=400, 
+                detail=f"Invalid task_type. Must be one of: {valid_task_types}"
+            )
+        
+        # Call UI analysis service
+        result = await UIAnalysisService.analyze_ui(
+            request.image_b64, 
+            request.task_type
+        )
+        
+        if not result.get("success"):
+            raise HTTPException(
+                status_code=500,
+                detail=f"UI analysis failed: {result.get('error', 'Unknown error')}"
+            )
+        
+        # Convert to response model
+        final_output = result["final_output"]
+        
+        return UIAnalysisResponse(
+            success=True,
+            service="ui_analysis",
+            total_execution_time=result["total_execution_time"],
+            ui_elements=[
+                UIElement(**elem) 
+                for elem in final_output["ui_elements"]["interactive_elements"]
+            ],
+            action_plan=ActionPlan(
+                steps=final_output["action_plan"]["action_plan"]
+            ),
+            automation_ready=final_output["automation_ready"],
+            metadata={
+                "detection_method": "modal_omniparser",
+                "request_time": start_time,
+                "task_type": request.task_type
+            }
+        )
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"UI analysis error: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/upload")
+async def upload_and_analyze(
+    file: UploadFile = File(...),
+    task_type: str = Form("search")
+):
+    """
+    Upload image file and analyze UI elements
+    
+    Args:
+        file: Image file upload
+        task_type: Type of UI analysis task
+        
+    Returns:
+        UI analysis results
+    """
+    try:
+        # Validate file type
+        if not file.content_type.startswith('image/'):
+            raise HTTPException(
+                status_code=400,
+                detail="File must be an image"
+            )
+        
+        # Read and encode image
+        image_data = await file.read()
+        image_b64 = base64.b64encode(image_data).decode()
+        
+        # Create request
+        request = UIAnalysisRequest(
+            image_b64=image_b64,
+            task_type=task_type
+        )
+        
+        # Analyze
+        return await analyze_ui_elements(request)
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Upload and analyze error: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/detect")
+async def detect_elements_only(request: UIAnalysisRequest):
+    """
+    Detect UI elements only (without action planning)
+    
+    Args:
+        request: UI analysis request
+        
+    Returns:
+        UI elements detection results
+    """
+    try:
+        # Call UI analysis service for detection only
+        result = await UIAnalysisService.analyze_ui(
+            request.image_b64, 
+            request.task_type
+        )
+        
+        if not result.get("success"):
+            raise HTTPException(
+                status_code=500,
+                detail=f"UI detection failed: {result.get('error', 'Unknown error')}"
+            )
+        
+        # Return only UI elements
+        final_output = result["final_output"]
+        ui_elements = final_output["ui_elements"]["interactive_elements"]
+        
+        return {
+            "success": True,
+            "processing_time": result["total_execution_time"],
+            "ui_elements": ui_elements,
+            "element_count": len(ui_elements),
+            "task_type": request.task_type
+        }
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"UI detection error: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))

isa_model/serving/api/routes/unified.py

@@ -0,0 +1,202 @@
+"""
+Unified API Route - Single endpoint for all AI services
+
+This is the main API that handles all types of AI requests:
+- Vision tasks (image analysis, OCR, UI detection)
+- Text tasks (chat, generation, translation) 
+- Audio tasks (TTS, STT)
+- Image generation tasks
+- Embedding tasks
+"""
+
+from fastapi import APIRouter, HTTPException, UploadFile, File, Form
+from pydantic import BaseModel, Field
+from typing import Optional, Dict, Any, Union, List
+import logging
+import asyncio
+from pathlib import Path
+
+from isa_model.client import ISAModelClient
+
+logger = logging.getLogger(__name__)
+router = APIRouter()
+
+class UnifiedRequest(BaseModel):
+    """Unified request model for all AI services"""
+    input_data: Union[str, Dict[str, Any]] = Field(..., description="Input data (text, image URL, etc.)")
+    task: str = Field(..., description="Task to perform (chat, analyze_image, generate_speech, etc.)")
+    service_type: str = Field(..., description="Service type (text, vision, audio, image, embedding)")
+    model_hint: Optional[str] = Field(None, description="Optional model preference")
+    provider_hint: Optional[str] = Field(None, description="Optional provider preference")
+    parameters: Optional[Dict[str, Any]] = Field(default_factory=dict, description="Additional task parameters")
+
+class UnifiedResponse(BaseModel):
+    """Unified response model for all AI services"""
+    success: bool
+    result: Optional[Any] = None
+    error: Optional[str] = None
+    metadata: Dict[str, Any]
+
+# Global ISA client instance for server-side processing
+_isa_client = None
+
+def get_isa_client():
+    """Get or create ISA client for local processing"""
+    global _isa_client
+    if _isa_client is None:
+        _isa_client = ISAModelClient(mode="local")  # Use local mode
+    return _isa_client
+
+@router.get("/")
+async def unified_info():
+    """API information"""
+    return {
+        "service": "unified_api",
+        "status": "active",
+        "description": "Single endpoint for all AI services",
+        "supported_service_types": ["vision", "text", "audio", "image", "embedding"],
+        "version": "1.0.0"
+    }
+
+@router.post("/invoke", response_model=UnifiedResponse)
+async def unified_invoke(request: UnifiedRequest) -> UnifiedResponse:
+    """
+    **Unified API endpoint for all AI services**
+    
+    This single endpoint handles:
+    - Vision: image analysis, OCR, UI detection
+    - Text: chat, generation, translation
+    - Audio: TTS, STT, transcription
+    - Image: generation, img2img
+    - Embedding: text embedding, similarity
+    
+    **Uses ISAModelClient in local mode - all the complex logic is in client.py**
+    """
+    try:
+        # Get ISA client instance (local mode)
+        client = get_isa_client()
+        
+        # Use client's local invoke method directly
+        # This handles all the complexity: model selection, service routing, execution
+        result = await client._invoke_local(
+            input_data=request.input_data,
+            task=request.task,
+            service_type=request.service_type,
+            model_hint=request.model_hint,
+            provider_hint=request.provider_hint,
+            **request.parameters
+        )
+        
+        # Return the result in our API format
+        return UnifiedResponse(
+            success=result["success"],
+            result=result.get("result"),
+            error=result.get("error"),
+            metadata=result["metadata"]
+        )
+        
+    except Exception as e:
+        logger.error(f"Unified invoke failed: {e}")
+        return UnifiedResponse(
+            success=False,
+            error=str(e),
+            metadata={
+                "task": request.task,
+                "service_type": request.service_type,
+                "model_hint": request.model_hint,
+                "provider_hint": request.provider_hint
+            }
+        )
+
+@router.post("/invoke-file", response_model=UnifiedResponse)
+async def unified_invoke_file(
+    task: str = Form(...),
+    service_type: str = Form(...),
+    model_hint: Optional[str] = Form(None),
+    provider_hint: Optional[str] = Form(None),
+    file: UploadFile = File(...)
+) -> UnifiedResponse:
+    """
+    Unified file upload endpoint
+    
+    For tasks that require file input (images, audio, documents)
+    """
+    try:
+        # Read file data
+        file_data = await file.read()
+        
+        # Get ISA client instance (local mode)
+        client = get_isa_client()
+        
+        # Use client's local invoke method with binary data
+        result = await client._invoke_local(
+            input_data=file_data,  # Binary data
+            task=task,
+            service_type=service_type,
+            model_hint=model_hint,
+            provider_hint=provider_hint,
+            filename=file.filename,
+            content_type=file.content_type,
+            file_size=len(file_data)
+        )
+        
+        # Return the result in our API format
+        return UnifiedResponse(
+            success=result["success"],
+            result=result.get("result"),
+            error=result.get("error"),
+            metadata={
+                **result["metadata"],
+                "filename": file.filename,
+                "content_type": file.content_type,
+                "file_size": len(file_data)
+            }
+        )
+        
+    except Exception as e:
+        logger.error(f"File invoke failed: {e}")
+        return UnifiedResponse(
+            success=False,
+            error=str(e),
+            metadata={
+                "task": task,
+                "service_type": service_type,
+                "filename": file.filename if file else None
+            }
+        )
+
+@router.get("/models")
+async def get_available_models(service_type: Optional[str] = None):
+    """Get available models (optional filter by service type)"""
+    try:
+        client = get_isa_client()
+        return await client.get_available_models(service_type)
+    except Exception as e:
+        logger.error(f"Failed to get available models: {e}")
+        # Fallback static model list
+        return {
+            "models": [
+                {"service_type": "vision", "provider": "openai", "model_id": "gpt-4.1-mini"},
+                {"service_type": "text", "provider": "openai", "model_id": "gpt-4.1-mini"},
+                {"service_type": "audio", "provider": "openai", "model_id": "whisper-1"},
+                {"service_type": "audio", "provider": "openai", "model_id": "tts-1"},
+                {"service_type": "embedding", "provider": "openai", "model_id": "text-embedding-3-small"},
+                {"service_type": "image", "provider": "replicate", "model_id": "black-forest-labs/flux-schnell"}
+            ]
+        }
+
+@router.get("/health")
+async def health_check():
+    """Health check for unified API"""
+    try:
+        client = get_isa_client()
+        health_result = await client.health_check()
+        return {
+            "api": "healthy",
+            "client_health": health_result
+        }
+    except Exception as e:
+        return {
+            "api": "error",
+            "error": str(e)
+        }

isa_model/serving/api/routes/vision.py

@@ -0,0 +1,19 @@
+"""
+Vision API Routes
+
+Endpoints for general vision tasks (placeholder)
+"""
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+router = APIRouter()
+
+@router.get("/")
+async def vision_info():
+    """Vision service information"""
+    return {
+        "service": "vision",
+        "status": "placeholder",
+        "description": "General vision processing endpoints"
+    }

isa_model/serving/api/schemas/__init__.py

@@ -0,0 +1,17 @@
+"""
+API Schemas Module
+
+Pydantic models for API request and response validation
+"""
+
+from .ui_analysis import *
+from .common import *
+
+__all__ = [
+    "UIAnalysisRequest",
+    "UIAnalysisResponse", 
+    "UIElement",
+    "ActionPlan",
+    "BaseResponse",
+    "ErrorResponse"
+]

isa_model/serving/api/schemas/common.py

@@ -0,0 +1,33 @@
+"""
+Common API Schemas
+
+Base schemas used across different endpoints
+"""
+
+from pydantic import BaseModel
+from typing import Dict, Any, Optional
+import time
+
+class BaseResponse(BaseModel):
+    """Base response model"""
+    success: bool
+    timestamp: float = time.time()
+    
+class ErrorResponse(BaseResponse):
+    """Error response model"""
+    success: bool = False
+    error: str
+    detail: Optional[str] = None
+    
+class HealthStatus(BaseModel):
+    """Health status model"""
+    status: str
+    timestamp: float
+    version: str
+    
+class SystemInfo(BaseModel):
+    """System information model"""
+    cpu_percent: float
+    memory_percent: float
+    gpu_available: bool
+    gpu_count: int