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

isa_model/core/types.py

@@ -0,0 +1,291 @@
+"""
+Unified Type Definitions for ISA Model SDK
+
+This module contains all the common enums and type definitions used across
+the entire SDK to ensure consistency and avoid duplication.
+"""
+
+from enum import Enum
+from typing import Dict, List, Optional, Any, Union
+from dataclasses import dataclass
+from datetime import datetime
+
+# ===== MODEL TYPES =====
+
+class ModelType(str, Enum):
+    """Types of models in the system"""
+    LLM = "llm"
+    EMBEDDING = "embedding"
+    RERANK = "rerank"
+    IMAGE = "image"
+    AUDIO = "audio"
+    VIDEO = "video"
+    VISION = "vision"
+    IMAGE_GEN = "image_gen"  # Added for consistency
+
+class ModelCapability(str, Enum):
+    """Model capabilities"""
+    TEXT_GENERATION = "text_generation"
+    CHAT = "chat"
+    EMBEDDING = "embedding"
+    RERANKING = "reranking"
+    REASONING = "reasoning"
+    IMAGE_GENERATION = "image_generation"
+    IMAGE_ANALYSIS = "image_analysis"
+    AUDIO_TRANSCRIPTION = "audio_transcription"
+    IMAGE_UNDERSTANDING = "image_understanding"
+    UI_DETECTION = "ui_detection"
+    OCR = "ocr"
+    TABLE_DETECTION = "table_detection"
+    TABLE_STRUCTURE_RECOGNITION = "table_structure_recognition"
+
+class ModelStage(str, Enum):
+    """Model lifecycle stages"""
+    REGISTERED = "registered"
+    TRAINING = "training"
+    EVALUATION = "evaluation"
+    DEPLOYMENT = "deployment"
+    PRODUCTION = "production"
+    RETIRED = "retired"
+
+# ===== SERVICE TYPES =====
+
+class ServiceType(str, Enum):
+    """Types of services available in the platform"""
+    LLM = "llm"
+    EMBEDDING = "embedding"
+    VISION = "vision"
+    AUDIO = "audio"
+    IMAGE_GEN = "image_gen"
+
+class ServiceStatus(str, Enum):
+    """Service deployment and health status"""
+    PENDING = "pending"
+    DEPLOYING = "deploying"
+    HEALTHY = "healthy"
+    UNHEALTHY = "unhealthy"
+    STOPPED = "stopped"
+
+class DeploymentPlatform(str, Enum):
+    """Supported deployment platforms for self-owned services only"""
+    MODAL = "modal"
+    KUBERNETES = "kubernetes"
+    RUNPOD = "runpod"
+    YYDS = "yyds"
+    OLLAMA = "ollama"  # Local deployment
+
+# ===== OPERATION TYPES =====
+
+class ModelOperationType(str, Enum):
+    """Types of model operations that incur costs"""
+    TRAINING = "training"
+    EVALUATION = "evaluation"
+    DEPLOYMENT = "deployment"
+    INFERENCE = "inference"
+    STORAGE = "storage"
+
+class InferenceOperationType(str, Enum):
+    """Types of inference operations"""
+    CHAT = "chat"
+    COMPLETION = "completion"
+    EMBEDDING = "embedding"
+    IMAGE_GENERATION = "image_generation"
+    VISION_ANALYSIS = "vision_analysis"
+    AUDIO_TRANSCRIPTION = "audio_transcription"
+    AUDIO_GENERATION = "audio_generation"
+
+# ===== ROUTING AND LOAD BALANCING =====
+
+class RoutingStrategy(str, Enum):
+    """Routing strategies for distributing requests among model replicas"""
+    ROUND_ROBIN = "round_robin"
+    WEIGHTED_ROUND_ROBIN = "weighted_round_robin"
+    LEAST_CONNECTIONS = "least_connections"
+    RESPONSE_TIME = "response_time"
+    RANDOM = "random"
+    CONSISTENT_HASH = "consistent_hash"
+    DYNAMIC_LOAD_BALANCING = "dynamic_load_balancing"
+
+# ===== EVALUATION AND TRAINING =====
+
+class MetricType(str, Enum):
+    """Types of evaluation metrics"""
+    ACCURACY = "accuracy"
+    PRECISION = "precision"
+    RECALL = "recall"
+    F1_SCORE = "f1_score"
+    BLEU = "bleu"
+    ROUGE = "rouge"
+    PERPLEXITY = "perplexity"
+    BERTSCORE = "bertscore"
+    SEMANTIC_SIMILARITY = "semantic_similarity"
+
+class AnnotationType(str, Enum):
+    """Types of training data annotations"""
+    TEXT_CLASSIFICATION = "text_classification"
+    NAMED_ENTITY_RECOGNITION = "named_entity_recognition"
+    QUESTION_ANSWERING = "question_answering"
+    SUMMARIZATION = "summarization"
+    TRANSLATION = "translation"
+    IMAGE_CLASSIFICATION = "image_classification"
+    OBJECT_DETECTION = "object_detection"
+    SEMANTIC_SEGMENTATION = "semantic_segmentation"
+
+class DatasetType(str, Enum):
+    """Types of training datasets"""
+    TEXT = "text"
+    IMAGE = "image"
+    AUDIO = "audio"
+    VIDEO = "video"
+    MULTIMODAL = "multimodal"
+
+class DatasetStatus(str, Enum):
+    """Status of training datasets"""
+    CREATED = "created"
+    UPLOADING = "uploading"
+    PROCESSING = "processing"
+    READY = "ready"
+    ERROR = "error"
+
+class ExperimentType(str, Enum):
+    """Types of ML experiments"""
+    TRAINING = "training"
+    EVALUATION = "evaluation"
+    HYPERPARAMETER_TUNING = "hyperparameter_tuning"
+    MODEL_COMPARISON = "model_comparison"
+
+# ===== STACKED SERVICES =====
+
+class LayerType(Enum):
+    """Types of layers in stacked services"""
+    INPUT_PROCESSING = "input_processing"
+    MODEL_INFERENCE = "model_inference"
+    OUTPUT_PROCESSING = "output_processing"
+    VALIDATION = "validation"
+    CACHING = "caching"
+
+class WorkflowType(Enum):
+    """Types of workflows"""
+    SEQUENTIAL = "sequential"
+    PARALLEL = "parallel"
+    CONDITIONAL = "conditional"
+    LOOP = "loop"
+
+# ===== PROVIDER TYPES =====
+
+class Provider(str, Enum):
+    """AI service providers"""
+    OPENAI = "openai"
+    REPLICATE = "replicate"
+    OLLAMA = "ollama"
+    ANTHROPIC = "anthropic"
+    GOOGLE = "google"
+    YYDS = "yyds"
+    MODAL = "modal"
+
+# ===== DATA CLASSES =====
+
+@dataclass
+class HealthMetrics:
+    """Service health metrics"""
+    is_healthy: bool
+    response_time_ms: Optional[int] = None
+    status_code: Optional[int] = None
+    cpu_usage_percent: Optional[float] = None
+    memory_usage_mb: Optional[int] = None
+    gpu_usage_percent: Optional[float] = None
+    error_message: Optional[str] = None
+    checked_at: Optional[datetime] = None
+
+@dataclass
+class ServiceMetrics:
+    """Service runtime metrics"""
+    request_count: int = 0
+    total_processing_time_ms: int = 0
+    error_count: int = 0
+    total_cost_usd: float = 0.0
+    window_start: Optional[datetime] = None
+    window_end: Optional[datetime] = None
+
+@dataclass
+class ResourceRequirements:
+    """Service resource requirements"""
+    gpu_type: Optional[str] = None
+    memory_mb: Optional[int] = None
+    cpu_cores: Optional[int] = None
+    storage_gb: Optional[int] = None
+    min_replicas: int = 0
+    max_replicas: int = 1
+
+@dataclass
+class ModelInfo:
+    """Model information structure"""
+    model_id: str
+    model_type: ModelType
+    capabilities: List[ModelCapability]
+    stage: ModelStage
+    provider: str
+    provider_model_name: str
+    metadata: Dict[str, Any]
+    created_at: Optional[datetime] = None
+    updated_at: Optional[datetime] = None
+
+@dataclass
+class UsageData:
+    """Usage data for billing tracking"""
+    operation_type: ModelOperationType
+    inference_operation: Optional[InferenceOperationType] = None
+    input_tokens: Optional[int] = None
+    output_tokens: Optional[int] = None
+    input_units: Optional[float] = None
+    output_units: Optional[float] = None
+    metadata: Optional[Dict[str, Any]] = None
+
+# ===== TYPE ALIASES =====
+
+# Common type aliases for better readability
+ModelID = str
+ServiceID = str
+DeploymentID = str
+ProviderName = str
+ModelName = str
+EndpointURL = str
+ConfigDict = Dict[str, Any]
+MetadataDict = Dict[str, Any]
+
+# ===== BACKWARD COMPATIBILITY =====
+
+# Legacy aliases for backward compatibility during migration
+# These should be removed once all modules are updated
+
+# From inference/billing_tracker.py
+class LegacyServiceType(Enum):
+    """Legacy service type - use ServiceType instead"""
+    LLM = "llm"
+    EMBEDDING = "embedding"
+    VISION = "vision"
+    IMAGE_GENERATION = "image_generation"
+    AUDIO_STT = "audio_stt"
+    AUDIO_TTS = "audio_tts"
+
+# Migration mapping
+LEGACY_SERVICE_TYPE_MAPPING = {
+    LegacyServiceType.LLM: ServiceType.LLM,
+    LegacyServiceType.EMBEDDING: ServiceType.EMBEDDING,
+    LegacyServiceType.VISION: ServiceType.VISION,
+    LegacyServiceType.IMAGE_GENERATION: ServiceType.IMAGE_GEN,
+    LegacyServiceType.AUDIO_STT: ServiceType.AUDIO,
+    LegacyServiceType.AUDIO_TTS: ServiceType.AUDIO,
+}
+
+def migrate_legacy_service_type(legacy_type: Union[LegacyServiceType, str]) -> ServiceType:
+    """Migrate legacy service type to new unified type"""
+    if isinstance(legacy_type, str):
+        # Try to find matching legacy enum
+        for legacy_enum in LegacyServiceType:
+            if legacy_enum.value == legacy_type:
+                return LEGACY_SERVICE_TYPE_MAPPING[legacy_enum]
+        # Fallback to direct mapping
+        return ServiceType(legacy_type)
+    else:
+        return LEGACY_SERVICE_TYPE_MAPPING.get(legacy_type, ServiceType.LLM)

isa_model/deployment/__init__.py

@@ -26,11 +26,13 @@ from .core.deployment_config import (
     create_gemma_runpod_triton_config,
     create_local_triton_config
 )
+from .services import AutoDeployVisionService
 
 __all__ = [
     # Main classes
     "DeploymentManager",
     "DeploymentConfig",
+    "AutoDeployVisionService",
     
     # Configuration classes
     "ModelConfig",

isa_model/deployment/cloud/modal/isa_vision_doc_service.py

@@ -119,7 +119,7 @@ image = (
     image=image,
     memory=16384,  # 16GB RAM
     timeout=1800,  # 30 minutes
-    scaledown_window=300,  # 5 minutes idle timeout
+    scaledown_window=60,   # 1 minute idle timeout
     min_containers=0,  # Scale to zero when not in use
 )
 class DocumentAnalysisService:
@@ -605,8 +605,162 @@ class DocumentAnalysisService:
         image_data = base64.b64decode(image_b64)
         return Image.open(io.BytesIO(image_data)).convert('RGB')
 
-# Warmup function removed to save costs
+# Auto-registration function
+@app.function() 
+async def register_service():
+    """Auto-register this service in the model registry"""
+    try:
+        import sys
+        from pathlib import Path
+        
+        # Add project root to path for imports
+        project_root = Path(__file__).parent.parent.parent.parent
+        sys.path.insert(0, str(project_root))
+        
+        try:
+            from isa_model.core.model_manager import ModelManager
+            from isa_model.core.model_repo import ModelType, ModelCapability
+            from isa_model.core.service_registry import ServiceRegistry
+            from isa_model.core.types import ServiceType, DeploymentPlatform, ServiceStatus, ResourceRequirements
+            from isa_model.core.model_service import ModelService
+        except ImportError:
+            # Fallback if import fails in Modal environment
+            print("⚠️ Could not import required modules - registration skipped")
+            return {"success": False, "error": "Required modules not available"}
+        
+        # Use ModelManager to register this service
+        model_manager = ModelManager()
+        
+        # 1. First register the underlying model (backward compatibility)
+        model_success = model_manager.registry.register_model(
+            model_id="isa-vision-doc-service",
+            model_type=ModelType.VISION,
+            capabilities=[
+                ModelCapability.TABLE_DETECTION,
+                ModelCapability.TABLE_STRUCTURE_RECOGNITION,
+                ModelCapability.OCR,
+                ModelCapability.IMAGE_ANALYSIS
+            ],
+            metadata={
+                "description": "ISA Vision Document Analysis Service with table detection, structure recognition, and OCR",
+                "service_name": "isa-vision-doc",
+                "service_type": "modal",
+                "deployment_type": "modal",
+                "endpoint": "https://isa-vision-doc.modal.run",
+                "underlying_models": [
+                    "microsoft/table-transformer-detection",
+                    "microsoft/table-transformer-structure-recognition-v1.1-all",
+                    "PaddleOCR 3.0"
+                ],
+                "gpu_requirement": "T4",
+                "memory_mb": 16384,
+                "auto_registered": True,
+                "registered_by": "isa_vision_doc_service.py",
+                "is_service": True,  # Mark this as a service, not a raw model
+                "capabilities_details": {
+                    "table_detection": "Microsoft Table Transformer Detection",
+                    "table_structure": "Microsoft Table Transformer Structure Recognition v1.1",
+                    "ocr": "PaddleOCR 3.0 with Chinese/English support"
+                }
+            }
+        )
+        
+        # 2. Register as a deployed service in the ServiceRegistry (MaaS platform)
+        service_success = False
+        try:
+            service_registry = ServiceRegistry(model_manager.registry)
+            
+            # Create ModelService instance
+            service = ModelService(
+                service_id="isa-vision-doc-modal-001",
+                service_name="isa_vision_doc",
+                model_id="isa-vision-doc-service",
+                deployment_platform=DeploymentPlatform.MODAL,
+                service_type=ServiceType.VISION,
+                status=ServiceStatus.HEALTHY,
+                inference_endpoint="https://isa-vision-doc.modal.run/analyze_document_complete",
+                health_endpoint="https://isa-vision-doc.modal.run/health_check",
+                capabilities=["table_detection", "table_structure_recognition", "ocr", "image_analysis"],
+                resource_requirements=ResourceRequirements(
+                    gpu_type="T4",
+                    memory_mb=16384,
+                    cpu_cores=4,
+                    min_replicas=0,
+                    max_replicas=5
+                ),
+                metadata={
+                    "description": "ISA Vision Document Analysis Service with table detection, structure recognition, and OCR",
+                    "underlying_models": [
+                        "microsoft/table-transformer-detection",
+                        "microsoft/table-transformer-structure-recognition-v1.1-all",
+                        "PaddleOCR 3.0"
+                    ],
+                    "auto_scaling": True,
+                    "scale_to_zero": True,
+                    "platform": "modal",
+                    "registered_by": "isa_vision_doc_service.py"
+                }
+            )
+            
+            # Register in ServiceRegistry
+            service_success = await service_registry.register_service(service)
+            
+            if service_success:
+                print("✅ Service registered in MaaS platform ServiceRegistry")
+            else:
+                print("⚠️ ServiceRegistry registration failed")
+                
+        except Exception as e:
+            print(f"⚠️ ServiceRegistry registration error: {e}")
+        
+        if model_success:
+            print("✅ Model registry registration successful")
+        else:
+            print("⚠️ Model registry registration failed")
+            
+        overall_success = model_success and service_success
+        return {
+            "success": overall_success, 
+            "model_registry": model_success,
+            "service_registry": service_success
+        }
+        
+    except Exception as e:
+        print(f"❌ Auto-registration error: {e}")
+        return {"success": False, "error": str(e)}
+
+# Quick deployment function
+@app.function()
+def deploy_service():
+    """Deploy this service instantly"""
+    import subprocess
+    import os
+    
+    print("🚀 Deploying ISA Vision Document Service...")
+    try:
+        # Get the current file path
+        current_file = __file__
+        
+        # Run modal deploy command
+        result = subprocess.run(
+            ["modal", "deploy", current_file],
+            capture_output=True,
+            text=True,
+            check=True
+        )
+        
+        print("✅ Deployment completed successfully!")
+        print(f"📝 Output: {result.stdout}")
+        return {"success": True, "output": result.stdout}
+        
+    except subprocess.CalledProcessError as e:
+        print(f"❌ Deployment failed: {e}")
+        print(f"📝 Error: {e.stderr}")
+        return {"success": False, "error": str(e), "stderr": e.stderr}
 
 if __name__ == "__main__":
     print("🚀 ISA Vision Document Service - Modal Deployment")
-    print("Deploy with: modal deploy isa_vision_doc_service.py")
+    print("Deploy with: modal deploy isa_vision_doc_service.py")
+    print("Or call: modal run isa_vision_doc_service.py::deploy_service")
+    print("Note: Requires T4 GPU and 16GB+ RAM for optimal performance")
+    print("\n📝 Service will auto-register in model registry upon deployment")