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

isa_model/deployment/cloud/modal/register_models.py

@@ -0,0 +1,321 @@
+ """
+Model Registration Script for UI Analysis Pipeline
+
+Registers the latest versions of UI analysis models in the core model registry
+Prepares models for Modal deployment with proper version management
+"""
+
+import asyncio
+from pathlib import Path
+import sys
+import os
+
+# Add project root to path
+project_root = Path(__file__).parent.parent.parent.parent
+sys.path.insert(0, str(project_root))
+
+from isa_model.core.model_manager import ModelManager
+from isa_model.core.model_repo import ModelRegistry, ModelType, ModelCapability
+
+async def register_ui_analysis_models():
+    """Register UI analysis models with latest versions"""
+    
+    # Initialize model manager and registry
+    model_manager = ModelManager()
+    
+    print("🔧 Registering UI Analysis Models...")
+    
+    # Debug: Check available capabilities
+    print("Available capabilities:")
+    for cap in ModelCapability:
+        print(f"  - {cap.name}: {cap.value}")
+    print()
+    
+    # Model definitions with latest versions from HuggingFace
+    models_to_register = [
+        {
+            "model_id": "omniparser-v2.0",
+            "repo_id": "microsoft/OmniParser",
+            "model_type": ModelType.VISION,
+            "capabilities": [
+                ModelCapability.UI_DETECTION,
+                ModelCapability.IMAGE_ANALYSIS,
+                ModelCapability.IMAGE_UNDERSTANDING
+            ],
+            "revision": "main",  # Latest version
+            "metadata": {
+                "description": "Microsoft OmniParser v2.0 - Advanced UI element detection",
+                "provider": "microsoft",
+                "model_family": "omniparser",
+                "version": "2.0",
+                "paper": "https://arxiv.org/abs/2408.00203",
+                "huggingface_url": "https://huggingface.co/microsoft/OmniParser",
+                "use_case": "UI element detection and parsing",
+                "input_format": "image",
+                "output_format": "structured_elements",
+                "gpu_memory_mb": 8192,
+                "inference_time_ms": 500
+            }
+        },
+        {
+            "model_id": "table-transformer-v1.1-detection",
+            "repo_id": "microsoft/table-transformer-detection",
+            "model_type": ModelType.VISION,
+            "capabilities": [
+                ModelCapability.TABLE_DETECTION,
+                ModelCapability.IMAGE_ANALYSIS
+            ],
+            "revision": "main",
+            "metadata": {
+                "description": "Microsoft Table Transformer v1.1 - Table detection model",
+                "provider": "microsoft",
+                "model_family": "table-transformer",
+                "version": "1.1",
+                "paper": "https://arxiv.org/abs/2110.00061",
+                "huggingface_url": "https://huggingface.co/microsoft/table-transformer-detection",
+                "use_case": "Table detection in documents and images",
+                "input_format": "image",
+                "output_format": "bounding_boxes",
+                "gpu_memory_mb": 4096,
+                "inference_time_ms": 300
+            }
+        },
+        {
+            "model_id": "table-transformer-v1.1-structure",
+            "repo_id": "microsoft/table-transformer-structure-recognition",
+            "model_type": ModelType.VISION,
+            "capabilities": [
+                ModelCapability.TABLE_STRUCTURE_RECOGNITION,
+                ModelCapability.IMAGE_ANALYSIS
+            ],
+            "revision": "main",
+            "metadata": {
+                "description": "Microsoft Table Transformer v1.1 - Table structure recognition",
+                "provider": "microsoft",
+                "model_family": "table-transformer",
+                "version": "1.1",
+                "paper": "https://arxiv.org/abs/2110.00061",
+                "huggingface_url": "https://huggingface.co/microsoft/table-transformer-structure-recognition",
+                "use_case": "Table structure recognition and cell extraction",
+                "input_format": "image",
+                "output_format": "table_structure",
+                "gpu_memory_mb": 4096,
+                "inference_time_ms": 400
+            }
+        },
+        {
+            "model_id": "paddleocr-v3.0",
+            "repo_id": "PaddlePaddle/PaddleOCR",
+            "model_type": ModelType.VISION,
+            "capabilities": [
+                ModelCapability.OCR,
+                ModelCapability.IMAGE_ANALYSIS
+            ],
+            "revision": "release/2.8",
+            "metadata": {
+                "description": "PaddleOCR v3.0 - Multilingual OCR model",
+                "provider": "paddlepaddle",
+                "model_family": "paddleocr",
+                "version": "3.0",
+                "github_url": "https://github.com/PaddlePaddle/PaddleOCR",
+                "huggingface_url": "https://huggingface.co/PaddlePaddle/PaddleOCR",
+                "use_case": "Text extraction from images",
+                "input_format": "image",
+                "output_format": "text_with_coordinates",
+                "languages": ["en", "ch", "multilingual"],
+                "gpu_memory_mb": 2048,
+                "inference_time_ms": 200
+            }
+        },
+        {
+            "model_id": "yolov8n-fallback",
+            "repo_id": "ultralytics/yolov8",
+            "model_type": ModelType.VISION,
+            "capabilities": [
+                ModelCapability.IMAGE_ANALYSIS,
+                ModelCapability.UI_DETECTION  # As fallback
+            ],
+            "revision": "main",
+            "metadata": {
+                "description": "YOLOv8 Nano - Fallback object detection model",
+                "provider": "ultralytics",
+                "model_family": "yolo",
+                "version": "8.0",
+                "github_url": "https://github.com/ultralytics/ultralytics",
+                "use_case": "General object detection (fallback for UI elements)",
+                "input_format": "image",
+                "output_format": "bounding_boxes",
+                "gpu_memory_mb": 1024,
+                "inference_time_ms": 50
+            }
+        }
+    ]
+    
+    # Register each model
+    registration_results = []
+    
+    for model_config in models_to_register:
+        print(f"\n📝 Registering {model_config['model_id']}...")
+        
+        try:
+            # Register model in registry (without downloading)
+            success = model_manager.registry.register_model(
+                model_id=model_config['model_id'],
+                model_type=model_config['model_type'],
+                capabilities=model_config['capabilities'],
+                metadata={
+                    **model_config['metadata'],
+                    'repo_id': model_config['repo_id'],
+                    'revision': model_config['revision'],
+                    'registered_at': 'auto',
+                    'download_status': 'not_downloaded'
+                }
+            )
+            
+            if success:
+                print(f"✅ Successfully registered {model_config['model_id']}")
+                registration_results.append({
+                    'model_id': model_config['model_id'],
+                    'status': 'success'
+                })
+            else:
+                print(f"❌ Failed to register {model_config['model_id']}")
+                registration_results.append({
+                    'model_id': model_config['model_id'],
+                    'status': 'failed'
+                })
+                
+        except Exception as e:
+            print(f"❌ Error registering {model_config['model_id']}: {e}")
+            registration_results.append({
+                'model_id': model_config['model_id'],
+                'status': 'error',
+                'error': str(e)
+            })
+    
+    # Print summary
+    print(f"\n📊 Registration Summary:")
+    successful = [r for r in registration_results if r['status'] == 'success']
+    failed = [r for r in registration_results if r['status'] != 'success']
+    
+    print(f"✅ Successfully registered: {len(successful)} models")
+    for result in successful:
+        print(f"   - {result['model_id']}")
+    
+    if failed:
+        print(f"❌ Failed to register: {len(failed)} models")
+        for result in failed:
+            error_msg = f" ({result.get('error', 'unknown error')})" if 'error' in result else ""
+            print(f"   - {result['model_id']}{error_msg}")
+    
+    return registration_results
+
+async def verify_model_registry():
+    """Verify registered models and their capabilities"""
+    
+    model_manager = ModelManager()
+    
+    print(f"\n🔍 Verifying Model Registry...")
+    
+    # Check models by capability
+    capabilities_to_check = [
+        ModelCapability.UI_DETECTION,
+        ModelCapability.OCR,
+        ModelCapability.TABLE_DETECTION,
+        ModelCapability.TABLE_STRUCTURE_RECOGNITION
+    ]
+    
+    for capability in capabilities_to_check:
+        models = model_manager.registry.get_models_by_capability(capability)
+        print(f"\n📋 Models with {capability.value} capability:")
+        
+        if models:
+            for model_id, model_info in models.items():
+                metadata = model_info.get('metadata', {})
+                version = metadata.get('version', 'unknown')
+                provider = metadata.get('provider', 'unknown')
+                print(f"   ✅ {model_id} (v{version}, {provider})")
+        else:
+            print(f"   ❌ No models found for {capability.value}")
+    
+    # Print overall stats
+    stats = model_manager.registry.get_stats()
+    print(f"\n📈 Registry Statistics:")
+    print(f"   Total models: {stats['total_models']}")
+    print(f"   Models by type: {stats['models_by_type']}")
+    print(f"   Models by capability: {stats['models_by_capability']}")
+
+def get_model_for_capability(capability: ModelCapability) -> str:
+    """Get the best model for a specific capability"""
+    
+    model_manager = ModelManager()
+    models = model_manager.registry.get_models_by_capability(capability)
+    
+    if not models:
+        return None
+    
+    # Priority order for UI analysis models
+    priority_order = {
+        ModelCapability.UI_DETECTION: [
+            "omniparser-v2.0",
+            "yolov8n-fallback"
+        ],
+        ModelCapability.OCR: [
+            "paddleocr-v3.0"
+        ],
+        ModelCapability.TABLE_DETECTION: [
+            "table-transformer-v1.1-detection"
+        ],
+        ModelCapability.TABLE_STRUCTURE_RECOGNITION: [
+            "table-transformer-v1.1-structure"
+        ]
+    }
+    
+    preferred_models = priority_order.get(capability, [])
+    
+    # Return the first available preferred model
+    for model_id in preferred_models:
+        if model_id in models:
+            return model_id
+    
+    # Fallback to first available model
+    return list(models.keys())[0] if models else None
+
+async def main():
+    """Main registration workflow"""
+    
+    print("🚀 ISA Model Registry - UI Analysis Models Registration")
+    print("=" * 60)
+    
+    try:
+        # Register models
+        results = await register_ui_analysis_models()
+        
+        # Verify registration
+        await verify_model_registry()
+        
+        print(f"\n🎉 Model registration completed!")
+        print(f"   Use ModelManager.get_model() to download and use models")
+        print(f"   Use get_model_for_capability() to get recommended models")
+        
+        # Show usage example
+        print(f"\n💡 Usage Example:")
+        print(f"   from isa_model.core.model_manager import ModelManager")
+        print(f"   from isa_model.core.model_repo import ModelCapability")
+        print(f"   ")
+        print(f"   manager = ModelManager()")
+        print(f"   ui_model_path = await manager.get_model(")
+        print(f"       model_id='omniparser-v2.0',")
+        print(f"       repo_id='microsoft/OmniParser',")
+        print(f"       model_type=ModelType.VISION,")
+        print(f"       capabilities=[ModelCapability.UI_DETECTION]")
+        print(f"   )")
+        
+    except Exception as e:
+        print(f"❌ Registration failed: {e}")
+        return False
+    
+    return True
+
+if __name__ == "__main__":
+    asyncio.run(main())

isa_model/deployment/runtime/deployed_service.py

@@ -0,0 +1,338 @@
+"""
+Runtime Management for Self-Owned Deployed Services
+
+This module manages the runtime aspects of self-owned deployed model services.
+It does NOT handle third-party API services (OpenAI, Replicate) - those are 
+managed in the inference module.
+
+Only for services deployed by ISADeploymentService or similar self-owned deployments.
+"""
+
+import asyncio
+import logging
+import time
+from typing import Dict, List, Optional, Any, Union
+from dataclasses import dataclass, field
+from datetime import datetime, timedelta
+import httpx
+from pathlib import Path
+
+from ...core.types import (
+    ServiceStatus, 
+    DeploymentPlatform,
+    HealthMetrics,
+    ServiceMetrics,
+    ResourceRequirements
+)
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class DeployedService:
+    """Runtime information for a self-owned deployed service"""
+    service_id: str
+    deployment_id: str
+    model_id: str
+    platform: DeploymentPlatform
+    endpoint_url: str
+    status: ServiceStatus = ServiceStatus.PENDING
+    health_check_url: Optional[str] = None
+    api_key: Optional[str] = None
+    resource_requirements: Optional[ResourceRequirements] = None
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    created_at: datetime = field(default_factory=datetime.now)
+    last_health_check: Optional[datetime] = None
+    health_metrics: Optional[HealthMetrics] = None
+    service_metrics: Optional[ServiceMetrics] = None
+
+
+class DeployedServiceManager:
+    """
+    Manages runtime aspects of self-owned deployed services.
+    
+    Features:
+    - Health monitoring for deployed services
+    - Service discovery and status tracking
+    - Runtime metrics collection
+    - Service lifecycle management
+    
+    Example:
+        ```python
+        from isa_model.deployment.runtime import DeployedServiceManager
+        
+        manager = DeployedServiceManager()
+        
+        # Register a newly deployed service
+        service = await manager.register_deployed_service(
+            service_id="gemma-4b-alpaca-v1-prod",
+            deployment_id="gemma-4b-alpaca-v1-int8-20241230-143022",
+            model_id="gemma-4b-alpaca-v1",
+            platform=DeploymentPlatform.RUNPOD,
+            endpoint_url="https://api.runpod.ai/v2/xyz123/inference"
+        )
+        
+        # Monitor health
+        health = await manager.check_service_health(service.service_id)
+        ```
+    """
+    
+    def __init__(self, storage_backend: str = "local"):
+        """Initialize deployed service manager"""
+        self.storage_backend = storage_backend
+        self.services: Dict[str, DeployedService] = {}
+        self.health_check_interval = 60  # seconds
+        self.health_check_timeout = 30   # seconds
+        self._monitoring_tasks: Dict[str, asyncio.Task] = {}
+        
+        logger.info(f"DeployedServiceManager initialized with {storage_backend} backend")
+    
+    async def register_deployed_service(self,
+                                      service_id: str,
+                                      deployment_id: str,
+                                      model_id: str,
+                                      platform: DeploymentPlatform,
+                                      endpoint_url: str,
+                                      health_check_url: Optional[str] = None,
+                                      api_key: Optional[str] = None,
+                                      resource_requirements: Optional[ResourceRequirements] = None,
+                                      metadata: Optional[Dict[str, Any]] = None) -> DeployedService:
+        """Register a newly deployed self-owned service"""
+        
+        if health_check_url is None:
+            # Try common health check patterns
+            if endpoint_url.endswith('/'):
+                health_check_url = f"{endpoint_url}health"
+            else:
+                health_check_url = f"{endpoint_url}/health"
+        
+        service = DeployedService(
+            service_id=service_id,
+            deployment_id=deployment_id,
+            model_id=model_id,
+            platform=platform,
+            endpoint_url=endpoint_url,
+            health_check_url=health_check_url,
+            api_key=api_key,
+            resource_requirements=resource_requirements,
+            metadata=metadata or {},
+            status=ServiceStatus.DEPLOYING
+        )
+        
+        self.services[service_id] = service
+        
+        # Start health monitoring
+        await self._start_health_monitoring(service_id)
+        
+        logger.info(f"Registered deployed service: {service_id} on {platform.value}")
+        return service
+    
+    async def get_service(self, service_id: str) -> Optional[DeployedService]:
+        """Get service information"""
+        return self.services.get(service_id)
+    
+    async def list_services(self, 
+                          platform: Optional[DeploymentPlatform] = None,
+                          status: Optional[ServiceStatus] = None) -> List[DeployedService]:
+        """List deployed services with optional filtering"""
+        services = list(self.services.values())
+        
+        if platform:
+            services = [s for s in services if s.platform == platform]
+        
+        if status:
+            services = [s for s in services if s.status == status]
+        
+        return services
+    
+    async def check_service_health(self, service_id: str) -> Optional[HealthMetrics]:
+        """Perform health check on a specific service"""
+        service = self.services.get(service_id)
+        if not service or not service.health_check_url:
+            return None
+        
+        start_time = time.time()
+        
+        try:
+            async with httpx.AsyncClient(timeout=self.health_check_timeout) as client:
+                headers = {}
+                if service.api_key:
+                    headers["Authorization"] = f"Bearer {service.api_key}"
+                
+                response = await client.get(service.health_check_url, headers=headers)
+                
+                response_time_ms = int((time.time() - start_time) * 1000)
+                
+                is_healthy = response.status_code == 200
+                
+                # Try to extract additional metrics from response
+                metrics_data = {}
+                try:
+                    if response.headers.get('content-type', '').startswith('application/json'):
+                        metrics_data = response.json()
+                except:
+                    pass
+                
+                health_metrics = HealthMetrics(
+                    is_healthy=is_healthy,
+                    response_time_ms=response_time_ms,
+                    status_code=response.status_code,
+                    cpu_usage_percent=metrics_data.get('cpu_usage'),
+                    memory_usage_mb=metrics_data.get('memory_usage_mb'),
+                    gpu_usage_percent=metrics_data.get('gpu_usage'),
+                    error_message=None if is_healthy else f"HTTP {response.status_code}",
+                    checked_at=datetime.now()
+                )
+                
+                # Update service status based on health
+                if is_healthy and service.status == ServiceStatus.DEPLOYING:
+                    service.status = ServiceStatus.HEALTHY
+                elif not is_healthy and service.status == ServiceStatus.HEALTHY:
+                    service.status = ServiceStatus.UNHEALTHY
+                
+                service.last_health_check = datetime.now()
+                service.health_metrics = health_metrics
+                
+                return health_metrics
+                
+        except Exception as e:
+            logger.error(f"Health check failed for {service_id}: {e}")
+            
+            error_metrics = HealthMetrics(
+                is_healthy=False,
+                response_time_ms=int((time.time() - start_time) * 1000),
+                error_message=str(e),
+                checked_at=datetime.now()
+            )
+            
+            service.status = ServiceStatus.UNHEALTHY
+            service.last_health_check = datetime.now()
+            service.health_metrics = error_metrics
+            
+            return error_metrics
+    
+    async def update_service_metrics(self, 
+                                   service_id: str,
+                                   request_count: int = 0,
+                                   processing_time_ms: int = 0,
+                                   error_count: int = 0,
+                                   cost_usd: float = 0.0):
+        """Update service runtime metrics"""
+        service = self.services.get(service_id)
+        if not service:
+            return
+        
+        if not service.service_metrics:
+            service.service_metrics = ServiceMetrics(
+                window_start=datetime.now()
+            )
+        
+        service.service_metrics.request_count += request_count
+        service.service_metrics.total_processing_time_ms += processing_time_ms
+        service.service_metrics.error_count += error_count
+        service.service_metrics.total_cost_usd += cost_usd
+        service.service_metrics.window_end = datetime.now()
+    
+    async def stop_service(self, service_id: str) -> bool:
+        """Stop a deployed service and cleanup resources"""
+        service = self.services.get(service_id)
+        if not service:
+            return False
+        
+        # Stop health monitoring
+        await self._stop_health_monitoring(service_id)
+        
+        # Update status
+        service.status = ServiceStatus.STOPPED
+        
+        # Note: Actual service termination would depend on the platform
+        # For RunPod, Modal, etc., we would call their respective APIs
+        
+        logger.info(f"Stopped service: {service_id}")
+        return True
+    
+    async def remove_service(self, service_id: str) -> bool:
+        """Remove service from registry"""
+        if service_id in self.services:
+            await self._stop_health_monitoring(service_id)
+            del self.services[service_id]
+            logger.info(f"Removed service: {service_id}")
+            return True
+        return False
+    
+    async def _start_health_monitoring(self, service_id: str):
+        """Start background health monitoring for a service"""
+        if service_id in self._monitoring_tasks:
+            return  # Already monitoring
+        
+        async def health_monitor():
+            while service_id in self.services:
+                try:
+                    await self.check_service_health(service_id)
+                    await asyncio.sleep(self.health_check_interval)
+                except asyncio.CancelledError:
+                    break
+                except Exception as e:
+                    logger.error(f"Health monitoring error for {service_id}: {e}")
+                    await asyncio.sleep(self.health_check_interval)
+        
+        task = asyncio.create_task(health_monitor())
+        self._monitoring_tasks[service_id] = task
+        logger.info(f"Started health monitoring for {service_id}")
+    
+    async def _stop_health_monitoring(self, service_id: str):
+        """Stop health monitoring for a service"""
+        if service_id in self._monitoring_tasks:
+            task = self._monitoring_tasks.pop(service_id)
+            task.cancel()
+            try:
+                await task
+            except asyncio.CancelledError:
+                pass
+            logger.info(f"Stopped health monitoring for {service_id}")
+    
+    async def get_service_status_summary(self) -> Dict[str, Any]:
+        """Get summary of all deployed services"""
+        summary = {
+            "total_services": len(self.services),
+            "healthy_services": 0,
+            "unhealthy_services": 0,
+            "deploying_services": 0,
+            "stopped_services": 0,
+            "platforms": {},
+            "last_updated": datetime.now().isoformat()
+        }
+        
+        for service in self.services.values():
+            # Count by status
+            if service.status == ServiceStatus.HEALTHY:
+                summary["healthy_services"] += 1
+            elif service.status == ServiceStatus.UNHEALTHY:
+                summary["unhealthy_services"] += 1
+            elif service.status == ServiceStatus.DEPLOYING:
+                summary["deploying_services"] += 1
+            elif service.status == ServiceStatus.STOPPED:
+                summary["stopped_services"] += 1
+            
+            # Count by platform
+            platform = service.platform.value
+            summary["platforms"][platform] = summary["platforms"].get(platform, 0) + 1
+        
+        return summary
+    
+    async def cleanup_old_services(self, max_age_hours: int = 24):
+        """Remove services that haven't been healthy for a specified time"""
+        cutoff_time = datetime.now() - timedelta(hours=max_age_hours)
+        
+        services_to_remove = []
+        for service_id, service in self.services.items():
+            if (service.status == ServiceStatus.STOPPED and 
+                service.last_health_check and 
+                service.last_health_check < cutoff_time):
+                services_to_remove.append(service_id)
+        
+        for service_id in services_to_remove:
+            await self.remove_service(service_id)
+        
+        logger.info(f"Cleaned up {len(services_to_remove)} old services")
+        return len(services_to_remove)

isa_model/deployment/services/__init__.py

@@ -0,0 +1,9 @@
+"""
+Deployment Services
+
+This module contains services for automated deployment and management of AI models.
+"""
+
+from .auto_deploy_vision_service import AutoDeployVisionService
+
+__all__ = ['AutoDeployVisionService']