isa-model 0.3.3__py3-none-any.whl → 0.3.5__py3-none-any.whl

isa_model/serving/__init__.py

@@ -0,0 +1,19 @@
+"""
+ISA Model Serving Module
+
+Core module for model inference services, including:
+- API service framework
+- Model worker processes
+- Caching layer
+- Performance optimization
+
+Difference from inference module:
+- inference: Client-side inference, calling third-party APIs
+- serving: Self-hosted model services, providing API services
+"""
+
+__version__ = "0.1.0"
+
+from .api.fastapi_server import create_app
+
+__all__ = ["create_app"]

isa_model/serving/api/__init__.py

@@ -0,0 +1,10 @@
+"""
+API Service Module
+
+FastAPI-based API service for model inference
+"""
+
+from .fastapi_server import create_app
+from .schemas import *
+
+__all__ = ["create_app"]

isa_model/serving/api/fastapi_server.py

@@ -0,0 +1,84 @@
+"""
+FastAPI Server for ISA Model Serving
+
+Main FastAPI application that serves model inference endpoints
+"""
+
+from fastapi import FastAPI, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+import time
+import logging
+from typing import Dict, Any
+
+from .routes import ui_analysis, vision, llm, health
+from .middleware.request_logger import RequestLoggerMiddleware
+
+logger = logging.getLogger(__name__)
+
+def create_app(config: Dict[str, Any] = None) -> FastAPI:
+    """
+    Create and configure FastAPI application
+    
+    Args:
+        config: Optional configuration dictionary
+        
+    Returns:
+        Configured FastAPI application
+    """
+    app = FastAPI(
+        title="ISA Model Serving API",
+        description="High-performance model inference API",
+        version="1.0.0",
+        docs_url="/docs",
+        redoc_url="/redoc"
+    )
+    
+    # Configure CORS
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],  # Configure appropriately for production
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+    
+    # Add custom middleware
+    app.add_middleware(RequestLoggerMiddleware)
+    
+    # Exception handlers
+    @app.exception_handler(Exception)
+    async def global_exception_handler(request: Request, exc: Exception):
+        logger.error(f"Global exception: {exc}", exc_info=True)
+        return JSONResponse(
+            status_code=500,
+            content={
+                "error": "Internal server error",
+                "detail": str(exc) if config and config.get("debug") else "An error occurred"
+            }
+        )
+    
+    # Include routers
+    app.include_router(health.router, prefix="/health", tags=["health"])
+    app.include_router(ui_analysis.router, prefix="/ui-analysis", tags=["ui-analysis"])
+    app.include_router(vision.router, prefix="/vision", tags=["vision"])
+    app.include_router(llm.router, prefix="/llm", tags=["llm"])
+    
+    # Root endpoint
+    @app.get("/")
+    async def root():
+        return {
+            "service": "isa-model-serving",
+            "version": "1.0.0",
+            "status": "running",
+            "timestamp": time.time()
+        }
+    
+    return app
+
+# Create default app instance
+app = create_app()
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)

isa_model/serving/api/middleware/__init__.py

@@ -0,0 +1,9 @@
+"""
+API Middleware Module
+
+Custom middleware for request processing
+"""
+
+from .request_logger import RequestLoggerMiddleware
+
+__all__ = ["RequestLoggerMiddleware"]

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/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