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

isa_model/inference/ai_factory.py

@@ -36,12 +36,13 @@ class AIFactory:
     
     def __init__(self):
         """Initialize the AI Factory."""
-        if not self._is_initialized:
+        # Check if this specific instance has been initialized (not class-level flag)
+        if not hasattr(self, 'model_manager'):
             # Use centralized managers
             self.model_manager = ModelManager()
             self.config_manager = ConfigManager()
             self._cached_services: Dict[str, BaseService] = {}
-            
+
             logger.info("AI Factory initialized with centralized ModelManager and ConfigManager")
             AIFactory._is_initialized = True
     
@@ -52,8 +53,8 @@ class AIFactory:
         Get a LLM service instance with automatic defaults
         
         Args:
-            model_name: Name of the model to use (defaults: OpenAI="gpt-4.1-mini", Ollama="llama3.2:3b", YYDS="claude-sonnet-4-20250514")
-            provider: Provider name (defaults to 'openai' for production, 'ollama' for dev)
+            model_name: Name of the model to use (defaults: OpenAI="gpt-4.1-mini", Ollama="llama3.2:3b", YYDS="claude-sonnet-4-20250514", Cerebras="gpt-oss-120b", ISA="isa-llm-service")
+            provider: Provider name (defaults to 'openai' for production, 'ollama' for dev, 'cerebras' for ultra-fast inference, 'isa' for custom models, 'huggingface' for HF models)
             config: Optional configuration dictionary
             
         Returns:
@@ -69,6 +70,15 @@ class AIFactory:
         elif provider == "yyds":
             final_model_name = model_name or "claude-sonnet-4-20250514"
             final_provider = provider
+        elif provider == "cerebras":
+            final_model_name = model_name or "gpt-oss-120b"
+            final_provider = provider
+        elif provider == "isa":
+            final_model_name = model_name or "isa-llm-service"
+            final_provider = provider
+        elif provider == "huggingface":
+            final_model_name = model_name or "xenobordom/dialogpt-isa-trained-1755493402"
+            final_provider = provider
         else:
             # Default provider selection - OpenAI with cheapest model
             final_provider = provider or "openai"
@@ -76,6 +86,12 @@ class AIFactory:
                 final_model_name = model_name or "gpt-4.1-mini"
             elif final_provider == "ollama":
                 final_model_name = model_name or "llama3.2:3b-instruct-fp16"
+            elif final_provider == "cerebras":
+                final_model_name = model_name or "gpt-oss-120b"
+            elif final_provider == "isa":
+                final_model_name = model_name or "isa-llm-service"
+            elif final_provider == "huggingface":
+                final_model_name = model_name or "xenobordom/dialogpt-isa-trained-1755493402"
             else:
                 final_model_name = model_name or "gpt-4.1-mini"
         
@@ -93,6 +109,18 @@ class AIFactory:
                 from isa_model.inference.services.llm.yyds_llm_service import YydsLLMService
                 return YydsLLMService(provider_name=final_provider, model_name=final_model_name,
                                     model_manager=self.model_manager, config_manager=self.config_manager)
+            elif final_provider == "cerebras":
+                from isa_model.inference.services.llm.cerebras_llm_service import CerebrasLLMService
+                return CerebrasLLMService(provider_name=final_provider, model_name=final_model_name,
+                                        model_manager=self.model_manager, config_manager=self.config_manager)
+            elif final_provider == "isa":
+                from isa_model.inference.services.llm.huggingface_llm_service import ISALLMService
+                return ISALLMService(provider_name=final_provider, model_name=final_model_name,
+                                   model_manager=self.model_manager, config_manager=self.config_manager)
+            elif final_provider == "huggingface":
+                from isa_model.inference.services.llm.huggingface_llm_service import ISALLMService
+                return ISALLMService(provider_name="isa", model_name=final_model_name,
+                                   model_manager=self.model_manager, config_manager=self.config_manager)
             else:
                 raise ValueError(f"Unsupported LLM provider: {final_provider}")
         except Exception as e:
@@ -130,7 +158,7 @@ class AIFactory:
         
         elif model_name in ["isa_vision_table", "isa_vision_ui", "isa_vision_doc"]:
             try:
-                from isa_model.deployment.services.simple_auto_deploy_vision_service import SimpleAutoDeployVisionService
+                from isa_model.deployment.modal.services.vision.simple_auto_deploy_vision_service import SimpleAutoDeployVisionService
                 logger.info(f"Creating auto-deploy service wrapper for {model_name}")
                 return SimpleAutoDeployVisionService(model_name, config)
             except Exception as e:
@@ -312,6 +340,40 @@ class AIFactory:
             logger.error(f"Failed to create TTS service: {e}")
             raise
     
+    def get_realtime(self, model_name: Optional[str] = None, provider: Optional[str] = None,
+                     config: Optional[Dict[str, Any]] = None) -> BaseService:
+        """
+        Get realtime audio service with automatic defaults
+        
+        Args:
+            model_name: Name of the model to use (defaults: OpenAI="gpt-4o-realtime-preview-2024-10-01")
+            provider: Provider name (defaults to 'openai')
+            config: Optional configuration dictionary
+            
+        Returns:
+            Realtime service instance
+        """
+        # Set defaults based on provider
+        if provider == "openai":
+            final_model_name = model_name or "gpt-4o-realtime-preview-2024-10-01"
+            final_provider = provider
+        else:
+            # Default provider selection - only OpenAI supports realtime currently
+            final_provider = provider or "openai"
+            final_model_name = model_name or "gpt-4o-realtime-preview-2024-10-01"
+        
+        # Create service using new centralized approach
+        try:
+            if final_provider == "openai":
+                from isa_model.inference.services.audio.openai_realtime_service import OpenAIRealtimeService
+                return OpenAIRealtimeService(provider_name=final_provider, model_name=final_model_name,
+                                           model_manager=self.model_manager, config_manager=self.config_manager)
+            else:
+                raise ValueError(f"Unsupported realtime provider: {final_provider}")
+        except Exception as e:
+            logger.error(f"Failed to create realtime service: {e}")
+            raise
+    
     def get_embed(self, model_name: Optional[str] = None, provider: Optional[str] = None,
                      config: Optional[Dict[str, Any]] = None) -> BaseService:
         """
@@ -351,9 +413,10 @@ class AIFactory:
         
         try:
             if final_provider == "openai":
-                from isa_model.inference.services.embedding.openai_embed_service import OpenAIEmbedService
-                service = OpenAIEmbedService(provider_name=final_provider, model_name=final_model_name,
-                                           model_manager=self.model_manager, config_manager=self.config_manager)
+                # Use resilient embedding service for OpenAI (with fallback)
+                from isa_model.inference.services.embedding.resilient_embed_service import ResilientEmbedService
+                service = ResilientEmbedService(provider_name=final_provider, model_name=final_model_name,
+                                              model_manager=self.model_manager, config_manager=self.config_manager)
             elif final_provider == "ollama":
                 from isa_model.inference.services.embedding.ollama_embed_service import OllamaEmbedService
                 service = OllamaEmbedService(provider_name=final_provider, model_name=final_model_name,
@@ -371,7 +434,30 @@ class AIFactory:
             
         except Exception as e:
             logger.error(f"Failed to create embedding service: {e}")
-            raise
+            # As a last resort, try the resilient service
+            try:
+                logger.info("Attempting to create resilient embedding service as fallback")
+                from isa_model.inference.services.embedding.resilient_embed_service import ResilientEmbedService
+                service = ResilientEmbedService(provider_name="openai", model_name="text-embedding-3-small",
+                                              model_manager=self.model_manager, config_manager=self.config_manager)
+                self._cached_services[cache_key] = service
+                logger.info("Successfully created fallback embedding service")
+                return service
+            except Exception as fallback_error:
+                logger.error(f"Even fallback embedding service failed: {fallback_error}")
+                # Create a more informative error
+                error_details = {
+                    "primary_error": str(e),
+                    "fallback_error": str(fallback_error),
+                    "provider": final_provider,
+                    "model": final_model_name,
+                    "suggestions": [
+                        "检查OpenAI API密钥配置",
+                        "确认网络连接正常",
+                        "尝试使用其他嵌入提供商如ollama"
+                    ]
+                }
+                raise ValueError(f"嵌入服务创建失败: {str(e)}。详细信息: {error_details}")
 
     def clear_cache(self):
         """Clear the service cache"""
@@ -463,4 +549,45 @@ class AIFactory:
         # Modal services auto-scale to zero, so explicit shutdown isn't required
         # This method is here for compatibility with AutoDeployVisionService
         logger.info(f"Modal service {model_name} will auto-scale to zero when idle")
-        pass
+        pass
+    
+    async def cleanup(self):
+        """Clean up all cached services and resources"""
+        logger.info("🧹 Starting AIFactory cleanup...")
+        
+        cleanup_tasks = []
+        for service_key, service in self._cached_services.items():
+            try:
+                if hasattr(service, 'close') and callable(service.close):
+                    cleanup_tasks.append(service.close())
+                    logger.debug(f"Scheduled cleanup for service: {service_key}")
+            except Exception as e:
+                logger.error(f"Error scheduling cleanup for service {service_key}: {e}")
+        
+        # Wait for all cleanup tasks to complete
+        if cleanup_tasks:
+            import asyncio
+            try:
+                await asyncio.gather(*cleanup_tasks, return_exceptions=True)
+                logger.info(f"✅ Cleaned up {len(cleanup_tasks)} services")
+            except Exception as e:
+                logger.error(f"❌ Error during service cleanup: {e}")
+        
+        # Clear the cached services
+        self._cached_services.clear()
+        
+        # Clean up model manager if it has cleanup method
+        if hasattr(self.model_manager, 'cleanup') and callable(self.model_manager.cleanup):
+            try:
+                await self.model_manager.cleanup()
+                logger.info("✅ Model manager cleaned up")
+            except Exception as e:
+                logger.error(f"❌ Error cleaning up model manager: {e}")
+        
+        logger.info("✅ AIFactory cleanup completed")
+    
+    @classmethod
+    def reset_instance(cls):
+        """Reset the singleton instance (useful for testing)"""
+        cls._instance = None
+        cls._is_initialized = False

isa_model/inference/legacy_services/__init__.py

@@ -0,0 +1,21 @@
+"""
+Model Service Suite Package
+"""
+
+from .model_training import ModelTrainingService, TrainingConfig, TrainingResult
+from .model_evaluation import ModelEvaluationService, EvaluationResult
+from .model_serving import ModelServingService, ServingResult
+from .model_service import ModelService, ModelConfig, ModelResult
+
+__all__ = [
+    'ModelTrainingService',
+    'TrainingConfig', 
+    'TrainingResult',
+    'ModelEvaluationService',
+    'EvaluationResult',
+    'ModelServingService',
+    'ServingResult',
+    'ModelService',
+    'ModelConfig',
+    'ModelResult'
+]