isa-model 0.0.4__py3-none-any.whl → 0.0.8__py3-none-any.whl

isa_model/inference/ai_factory.py

@@ -1,17 +1,23 @@
-from typing import Dict, Type, Any, Optional, Tuple
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""
+Simplified AI Factory for creating inference services
+Uses the new service architecture with proper base classes
+"""
+
+from typing import Dict, Type, Any, Optional, Tuple, List
 import logging
+import os
 from isa_model.inference.providers.base_provider import BaseProvider
 from isa_model.inference.services.base_service import BaseService
 from isa_model.inference.base import ModelType
-import os
 
-# 设置基本的日志配置
-logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 class AIFactory:
     """
-    Factory for creating AI services based on the Single Model pattern.
+    Simplified Factory for creating AI services with proper inheritance hierarchy
     """
     
     _instance = None
@@ -24,72 +30,78 @@ class AIFactory:
     
     def __init__(self):
         """Initialize the AI Factory."""
-        self.triton_url = os.environ.get("TRITON_URL", "http://localhost:8000")
-        
-        # Cache for services (singleton pattern)
-        self._llm_services = {}
-        self._embedding_services = {}
-        self._speech_services = {}
-        
         if not self._is_initialized:
             self._providers: Dict[str, Type[BaseProvider]] = {}
             self._services: Dict[Tuple[str, ModelType], Type[BaseService]] = {}
             self._cached_services: Dict[str, BaseService] = {}
-            self._initialize_defaults()
+            self._initialize_services()
             AIFactory._is_initialized = True
     
-    def _initialize_defaults(self):
-        """Initialize default providers and services"""
+    def _initialize_services(self):
+        """Initialize available providers and services"""
+        try:
+            # Register Ollama services
+            self._register_ollama_services()
+            
+            # Register OpenAI services
+            self._register_openai_services()
+            
+            # Register Replicate services
+            self._register_replicate_services()
+            
+            logger.info("AI Factory initialized with simplified service architecture")
+            
+        except Exception as e:
+            logger.error(f"Error initializing services: {e}")
+            logger.warning("Some services may not be available")
+    
+    def _register_ollama_services(self):
+        """Register Ollama provider and services"""
         try:
-            # Import providers and services
             from isa_model.inference.providers.ollama_provider import OllamaProvider
-            from isa_model.inference.services.embedding.ollama_embed_service import OllamaEmbedService
             from isa_model.inference.services.llm.ollama_llm_service import OllamaLLMService
+            from isa_model.inference.services.embedding.ollama_embed_service import OllamaEmbedService
+            from isa_model.inference.services.vision.ollama_vision_service import OllamaVisionService
             
-            # Register Ollama provider and services
             self.register_provider('ollama', OllamaProvider)
-            self.register_service('ollama', ModelType.EMBEDDING, OllamaEmbedService)
             self.register_service('ollama', ModelType.LLM, OllamaLLMService)
+            self.register_service('ollama', ModelType.EMBEDDING, OllamaEmbedService)
+            self.register_service('ollama', ModelType.VISION, OllamaVisionService)
             
-            # Register OpenAI provider and services
-            try:
-                from isa_model.inference.providers.openai_provider import OpenAIProvider
-                from isa_model.inference.services.llm.openai_llm_service import OpenAILLMService
-                
-                self.register_provider('openai', OpenAIProvider)
-                self.register_service('openai', ModelType.LLM, OpenAILLMService)
-                logger.info("OpenAI services registered successfully")
-            except ImportError as e:
-                logger.warning(f"OpenAI services not available: {e}")
+            logger.info("Ollama services registered successfully")
             
-            # Register Replicate provider and services
-            try:
-                from isa_model.inference.providers.replicate_provider import ReplicateProvider
-                from isa_model.inference.services.vision.replicate_image_gen_service import ReplicateVisionService
-                
-                self.register_provider('replicate', ReplicateProvider)
-                self.register_service('replicate', ModelType.VISION, ReplicateVisionService)
-                logger.info("Replicate provider and vision service registered successfully")
-            except ImportError as e:
-                logger.warning(f"Replicate services not available: {e}")
-            except Exception as e:
-                logger.warning(f"Error registering Replicate services: {e}")
+        except ImportError as e:
+            logger.warning(f"Ollama services not available: {e}")
+    
+    def _register_openai_services(self):
+        """Register OpenAI provider and services"""
+        try:
+            from isa_model.inference.providers.openai_provider import OpenAIProvider
+            from isa_model.inference.services.llm.openai_llm_service import OpenAILLMService
+            from isa_model.inference.services.audio.openai_tts_service import OpenAITTSService
             
-            # Try to register Triton services
-            try:
-                from isa_model.inference.providers.triton_provider import TritonProvider
-                
-                self.register_provider('triton', TritonProvider)
-                logger.info("Triton provider registered successfully")
-                
-            except ImportError as e:
-                logger.warning(f"Triton provider not available: {e}")
+            self.register_provider('openai', OpenAIProvider)
+            self.register_service('openai', ModelType.LLM, OpenAILLMService)
+            self.register_service('openai', ModelType.AUDIO, OpenAITTSService)
             
-            logger.info("Default AI providers and services initialized with backend architecture")
-        except Exception as e:
-            logger.error(f"Error initializing default providers and services: {e}")
-            # Don't raise - allow factory to work even if some services fail to load
-            logger.warning("Some services may not be available due to import errors")
+            logger.info("OpenAI services registered successfully")
+            
+        except ImportError as e:
+            logger.warning(f"OpenAI services not available: {e}")
+    
+    def _register_replicate_services(self):
+        """Register Replicate provider and services"""
+        try:
+            from isa_model.inference.providers.replicate_provider import ReplicateProvider
+            from isa_model.inference.services.vision.replicate_image_gen_service import ReplicateImageGenService
+            
+            self.register_provider('replicate', ReplicateProvider)
+            self.register_service('replicate', ModelType.VISION, ReplicateImageGenService)
+            
+            logger.info("Replicate services registered successfully")
+            
+        except ImportError as e:
+            logger.warning(f"Replicate services not available: {e}")
     
     def register_provider(self, name: str, provider_class: Type[BaseProvider]) -> None:
         """Register an AI provider"""
@@ -109,24 +121,20 @@ class AIFactory:
             if cache_key in self._cached_services:
                 return self._cached_services[cache_key]
             
-            # 基础配置
-            base_config = {
-                "log_level": "INFO"
-            }
-            
-            # 合并配置
-            service_config = {**base_config, **(config or {})}
-            
-            # 创建 provider 和 service
-            provider_class = self._providers[provider_name]
+            # Get provider and service classes
+            provider_class = self._providers.get(provider_name)
             service_class = self._services.get((provider_name, model_type))
             
+            if not provider_class:
+                raise ValueError(f"No provider registered for '{provider_name}'")
+            
             if not service_class:
                 raise ValueError(
-                    f"No service registered for provider {provider_name} and model type {model_type}"
+                    f"No service registered for provider '{provider_name}' and model type '{model_type}'"
                 )
             
-            provider = provider_class(config=service_config)
+            # Create provider and service
+            provider = provider_class(config=config or {})
             service = service_class(provider=provider, model_name=model_name)
             
             self._cached_services[cache_key] = service
@@ -137,223 +145,117 @@ class AIFactory:
             raise
     
     # Convenient methods for common services
-    def get_llm(self, model_name: str = "llama3.1", provider: str = "ollama",
-                config: Optional[Dict[str, Any]] = None, api_key: Optional[str] = None) -> BaseService:
+    def get_llm_service(self, model_name: str = "llama3.1", provider: str = "ollama",
+                       config: Optional[Dict[str, Any]] = None) -> BaseService:
         """
         Get a LLM service instance
         
         Args:
             model_name: Name of the model to use
-            provider: Provider name ('ollama', 'openai', 'replicate', etc.)
+            provider: Provider name ('ollama', 'openai')
             config: Optional configuration dictionary
-            api_key: Optional API key for the provider (OpenAI, Replicate, etc.)
             
         Returns:
             LLM service instance
-            
-        Example:
-            # Using with API key directly
-            llm = AIFactory.get_instance().get_llm(
-                model_name="gpt-4o-mini", 
-                provider="openai", 
-                api_key="your-api-key-here"
-            )
-            
-            # Using without API key (will use environment variable)
-            llm = AIFactory.get_instance().get_llm(
-                model_name="gpt-4o-mini", 
-                provider="openai"
-            )
         """
-        
-        # Special case for DeepSeek service
-        if model_name.lower() in ["deepseek", "deepseek-r1", "qwen3-8b"]:
-            if "deepseek" in self._cached_services:
-                return self._cached_services["deepseek"]
-        
-        # Special case for Llama3-8B direct service
-        if model_name.lower() in ["llama3", "llama3-8b", "meta-llama-3"]:
-            if "llama3" in self._cached_services:
-                return self._cached_services["llama3"]
-        
-        basic_config: Dict[str, Any] = {
-            "temperature": 0
-        }
-        
-        # Add API key to config if provided
-        if api_key:
-            if provider == "openai":
-                basic_config["api_key"] = api_key
-            elif provider == "replicate":
-                basic_config["api_token"] = api_key
-            else:
-                logger.warning(f"API key provided but provider '{provider}' may not support it")
-        
-        if config:
-            basic_config.update(config)
-        return self.create_service(provider, ModelType.LLM, model_name, basic_config)
+        return self.create_service(provider, ModelType.LLM, model_name, config)
     
-    def get_vision_model(self, model_name: str = "gemma3-4b", provider: str = "triton",
-                       config: Optional[Dict[str, Any]] = None, api_key: Optional[str] = None) -> BaseService:
+    def get_embedding_service(self, model_name: str = "bge-m3", provider: str = "ollama",
+                             config: Optional[Dict[str, Any]] = None) -> BaseService:
         """
-        Get a vision model service instance
+        Get an embedding service instance
         
         Args:
             model_name: Name of the model to use
-            provider: Provider name ('openai', 'replicate', 'triton', etc.)
+            provider: Provider name ('ollama')
             config: Optional configuration dictionary
-            api_key: Optional API key for the provider (OpenAI, Replicate, etc.)
             
         Returns:
-            Vision service instance
-            
-        Example:
-            # Using with API key directly
-            vision = AIFactory.get_instance().get_vision_model(
-                model_name="gpt-4o", 
-                provider="openai", 
-                api_key="your-api-key-here"
-            )
-            
-            # Using Replicate for image generation
-            image_gen = AIFactory.get_instance().get_vision_model(
-                model_name="stability-ai/sdxl", 
-                provider="replicate", 
-                api_key="your-replicate-token"
-            )
+            Embedding service instance
         """
-        
-        # Special case for Gemma3-4B direct service
-        if model_name.lower() in ["gemma3", "gemma3-4b", "gemma3-vision"]:
-            if "gemma3" in self._cached_services:
-                return self._cached_services["gemma3"]
-        
-        # Special case for Replicate's image generation models
-        if provider == "replicate" and "/" in model_name:
-            replicate_config: Dict[str, Any] = {
-                "guidance_scale": 7.5,
-                "num_inference_steps": 30
-            }
-            
-            # Add API key if provided
-            if api_key:
-                replicate_config["api_token"] = api_key
-            
-            if config:
-                replicate_config.update(config)
-            return self.create_service(provider, ModelType.VISION, model_name, replicate_config)
-        
-        basic_config: Dict[str, Any] = {
-            "temperature": 0.7,
-            "max_new_tokens": 512
-        }
-        
-        # Add API key to config if provided
-        if api_key:
-            if provider == "openai":
-                basic_config["api_key"] = api_key
-            elif provider == "replicate":
-                basic_config["api_token"] = api_key
-            else:
-                logger.warning(f"API key provided but provider '{provider}' may not support it")
-        
-        if config:
-            basic_config.update(config)
-        return self.create_service(provider, ModelType.VISION, model_name, basic_config)
-    
-    def get_embedding(self, model_name: str = "bge-m3", provider: str = "ollama",
-                     config: Optional[Dict[str, Any]] = None) -> BaseService:
-        """Get an embedding service instance"""
         return self.create_service(provider, ModelType.EMBEDDING, model_name, config)
     
-    def get_rerank(self, model_name: str = "bge-m3", provider: str = "ollama",
-                   config: Optional[Dict[str, Any]] = None) -> BaseService:
-        """Get a rerank service instance"""
-        return self.create_service(provider, ModelType.RERANK, model_name, config)
-    
-    def get_embed_service(self, model_name: str = "bge-m3", provider: str = "ollama",
-                         config: Optional[Dict[str, Any]] = None) -> BaseService:
-        """Get an embedding service instance"""
-        return self.get_embedding(model_name, provider, config)
-    
-    def get_speech_model(self, model_name: str = "whisper_tiny", provider: str = "triton",
-                       config: Optional[Dict[str, Any]] = None) -> BaseService:
-        """Get a speech-to-text model service instance"""
-        
-        # Special case for Whisper Tiny direct service
-        if model_name.lower() in ["whisper", "whisper_tiny", "whisper-tiny"]:
-            if "whisper" in self._cached_services:
-                return self._cached_services["whisper"]
-        
-        basic_config = {
-            "language": "en",
-            "task": "transcribe"
-        }
-        if config:
-            basic_config.update(config)
-        return self.create_service(provider, ModelType.AUDIO, model_name, basic_config)
-    
-    async def get_embedding_service(self, model_name: str) -> Any:
+    def get_vision_service(self, model_name: str, provider: str,
+                          config: Optional[Dict[str, Any]] = None) -> BaseService:
         """
-        Get an embedding service for the specified model.
+        Get a vision service instance
         
         Args:
-            model_name: Name of the model
+            model_name: Name of the model to use
+            provider: Provider name ('ollama', 'replicate')
+            config: Optional configuration dictionary
             
         Returns:
-            Embedding service instance
+            Vision service instance
         """
-        if model_name in self._embedding_services:
-            return self._embedding_services[model_name]
-        
-        else:
-            raise ValueError(f"Unsupported embedding model: {model_name}")
+        return self.create_service(provider, ModelType.VISION, model_name, config)
     
-    async def get_speech_service(self, model_name: str) -> Any:
+    def get_image_generation_service(self, model_name: str, provider: str = "replicate",
+                                   config: Optional[Dict[str, Any]] = None) -> BaseService:
         """
-        Get a speech service for the specified model.
+        Get an image generation service instance
         
         Args:
-            model_name: Name of the model
+            model_name: Name of the model to use (e.g., "stability-ai/sdxl")
+            provider: Provider name ('replicate')
+            config: Optional configuration dictionary
             
         Returns:
-            Speech service instance
+            Image generation service instance
         """
-        if model_name in self._speech_services:
-            return self._speech_services[model_name]
-        
+        return self.create_service(provider, ModelType.VISION, model_name, config)
     
-    def get_model_info(self, model_type: Optional[str] = None) -> Dict[str, Any]:
+    def get_audio_service(self, model_name: str = "tts-1", provider: str = "openai",
+                         config: Optional[Dict[str, Any]] = None) -> BaseService:
         """
-        Get information about available models.
+        Get an audio service instance
         
         Args:
-            model_type: Optional filter for model type
+            model_name: Name of the model to use
+            provider: Provider name ('openai')
+            config: Optional configuration dictionary
             
         Returns:
-            Dict of model information
+            Audio service instance
         """
-        models = {
-            "llm": [
-                {"name": "deepseek", "description": "DeepSeek-R1-0528-Qwen3-8B language model"},
-                {"name": "llama", "description": "Llama3-8B language model"},
-                {"name": "gemma", "description": "Gemma3-4B language model"}
-            ],
-            "embedding": [
-                {"name": "bge_embed", "description": "BGE-M3 text embedding model"}
-            ],
-            "speech": [
-                {"name": "whisper", "description": "Whisper-tiny speech-to-text model"}
-            ]
-        }
-        
-        if model_type:
-            return {model_type: models.get(model_type, [])}
-        return models
+        return self.create_service(provider, ModelType.AUDIO, model_name, config)
+    
+    def get_available_services(self) -> Dict[str, List[str]]:
+        """Get information about available services"""
+        services = {}
+        for (provider, model_type), service_class in self._services.items():
+            if provider not in services:
+                services[provider] = []
+            services[provider].append(f"{model_type.value}: {service_class.__name__}")
+        return services
+    
+    def clear_cache(self):
+        """Clear the service cache"""
+        self._cached_services.clear()
+        logger.info("Service cache cleared")
     
     @classmethod
     def get_instance(cls) -> 'AIFactory':
         """Get the singleton instance"""
         if cls._instance is None:
             cls._instance = cls()
-        return cls._instance
+        return cls._instance
+    
+    # Alias methods for backward compatibility with tests
+    def get_llm(self, model_name: str = "llama3.1", provider: str = "ollama",
+                config: Optional[Dict[str, Any]] = None) -> BaseService:
+        """Alias for get_llm_service"""
+        return self.get_llm_service(model_name, provider, config)
+    
+    def get_embedding(self, model_name: str = "bge-m3", provider: str = "ollama",
+                     config: Optional[Dict[str, Any]] = None) -> BaseService:
+        """Alias for get_embedding_service"""
+        return self.get_embedding_service(model_name, provider, config)
+    
+    def get_vision_model(self, model_name: str, provider: str,
+                        config: Optional[Dict[str, Any]] = None) -> BaseService:
+        """Alias for get_vision_service and get_image_generation_service"""
+        if provider == "replicate":
+            return self.get_image_generation_service(model_name, provider, config)
+        else:
+            return self.get_vision_service(model_name, provider, config) 

isa_model/inference/providers/ml_provider.py

@@ -0,0 +1,50 @@
+from isa_model.inference.providers.base_provider import BaseProvider
+from isa_model.inference.base import ModelType, Capability
+from typing import Dict, List, Any
+import logging
+
+logger = logging.getLogger(__name__)
+
+class MLProvider(BaseProvider):
+    """Provider for traditional ML models"""
+    
+    def __init__(self, config=None):
+        default_config = {
+            "model_directory": "./models/ml",
+            "cache_models": True,
+            "max_cache_size": 5
+        }
+        
+        merged_config = {**default_config, **(config or {})}
+        super().__init__(config=merged_config)
+        self.name = "ml"
+        
+        logger.info(f"Initialized MLProvider with model directory: {self.config['model_directory']}")
+    
+    def get_capabilities(self) -> Dict[ModelType, List[Capability]]:
+        """Get provider capabilities"""
+        return {
+            ModelType.LLM: [],  # ML models are not LLMs
+            ModelType.EMBEDDING: [],
+            ModelType.VISION: [],
+            "ML": [  # Custom model type for traditional ML
+                "CLASSIFICATION",
+                "REGRESSION", 
+                "CLUSTERING",
+                "FEATURE_EXTRACTION"
+            ]
+        }
+    
+    def get_models(self, model_type: str = "ML") -> List[str]:
+        """Get available ML models"""
+        # In practice, this would scan the model directory
+        return [
+            "fraud_detection_rf",
+            "customer_churn_xgb", 
+            "price_prediction_lr",
+            "recommendation_kmeans"
+        ]
+    
+    def get_config(self) -> Dict[str, Any]:
+        """Get provider configuration"""
+        return self.config

isa_model/inference/services/audio/openai_tts_service.py

@@ -1,15 +1,15 @@
-from typing import Dict, Any
+from typing import Dict, Any, List, Optional
 import tempfile
 import os
 from openai import AsyncOpenAI
 from tenacity import retry, stop_after_attempt, wait_exponential
-from isa_model.inference.services.base_service import BaseService
+from isa_model.inference.services.audio.base_tts_service import BaseTTSService
 from isa_model.inference.providers.base_provider import BaseProvider
 import logging
 
 logger = logging.getLogger(__name__)
 
-class YYDSAudioService(BaseService):
+class OpenAITTSService(BaseTTSService):
     """Audio model service wrapper for YYDS"""
     
     def __init__(self, provider: 'BaseProvider', model_name: str):
@@ -69,3 +69,104 @@ class YYDSAudioService(BaseService):
         except Exception as e:
             logger.error(f"Error in audio transcription: {e}")
             raise
+
+    # 实现BaseTTSService的抽象方法
+    async def synthesize_speech(
+        self, 
+        text: str, 
+        voice: Optional[str] = None,
+        speed: float = 1.0,
+        pitch: float = 1.0,
+        format: str = "mp3"
+    ) -> Dict[str, Any]:
+        """Synthesize speech from text using OpenAI TTS"""
+        try:
+            response = await self._client.audio.speech.create(
+                model="tts-1",
+                voice=voice or "alloy",
+                input=text,
+                response_format=format,
+                speed=speed
+            )
+            
+            audio_data = response.content
+            
+            return {
+                "audio_data": audio_data,
+                "format": format,
+                "duration": 0.0,  # OpenAI doesn't provide duration
+                "sample_rate": 24000  # Default for OpenAI TTS
+            }
+            
+        except Exception as e:
+            logger.error(f"Error in speech synthesis: {e}")
+            raise
+
+    async def synthesize_speech_to_file(
+        self, 
+        text: str,
+        output_path: str,
+        voice: Optional[str] = None,
+        speed: float = 1.0,
+        pitch: float = 1.0,
+        format: str = "mp3"
+    ) -> Dict[str, Any]:
+        """Synthesize speech and save to file"""
+        result = await self.synthesize_speech(text, voice, speed, pitch, format)
+        
+        with open(output_path, 'wb') as f:
+            f.write(result["audio_data"])
+        
+        return {
+            "file_path": output_path,
+            "duration": result["duration"],
+            "sample_rate": result["sample_rate"]
+        }
+
+    async def synthesize_speech_batch(
+        self, 
+        texts: List[str],
+        voice: Optional[str] = None,
+        speed: float = 1.0,
+        pitch: float = 1.0,
+        format: str = "mp3"
+    ) -> List[Dict[str, Any]]:
+        """Synthesize speech for multiple texts"""
+        results = []
+        for text in texts:
+            result = await self.synthesize_speech(text, voice, speed, pitch, format)
+            results.append(result)
+        return results
+
+    def get_available_voices(self) -> List[Dict[str, Any]]:
+        """Get list of available OpenAI voices"""
+        return [
+            {"id": "alloy", "name": "Alloy", "language": "en-US", "gender": "neutral", "age": "adult"},
+            {"id": "echo", "name": "Echo", "language": "en-US", "gender": "male", "age": "adult"},
+            {"id": "fable", "name": "Fable", "language": "en-US", "gender": "neutral", "age": "adult"},
+            {"id": "onyx", "name": "Onyx", "language": "en-US", "gender": "male", "age": "adult"},
+            {"id": "nova", "name": "Nova", "language": "en-US", "gender": "female", "age": "adult"},
+            {"id": "shimmer", "name": "Shimmer", "language": "en-US", "gender": "female", "age": "adult"}
+        ]
+
+    def get_supported_formats(self) -> List[str]:
+        """Get list of supported audio formats"""
+        return ["mp3", "opus", "aac", "flac"]
+
+    def get_voice_info(self, voice_id: str) -> Dict[str, Any]:
+        """Get detailed information about a specific voice"""
+        voices = {voice["id"]: voice for voice in self.get_available_voices()}
+        voice_info = voices.get(voice_id, {})
+        
+        if voice_info:
+            voice_info.update({
+                "description": f"OpenAI {voice_info['name']} voice",
+                "sample_rate": 24000
+            })
+        
+        return voice_info
+
+    async def close(self):
+        """Cleanup resources"""
+        if hasattr(self._client, 'close'):
+            await self._client.close()