isa-model 0.3.4__py3-none-any.whl → 0.3.6__py3-none-any.whl

isa_model/inference/providers/modal_provider.py

@@ -0,0 +1,109 @@
+"""
+Modal Provider
+
+Provider for ISA self-hosted Modal services
+No API keys needed since we deploy our own services
+"""
+
+import os
+import logging
+from typing import Dict, Any, Optional, List
+from .base_provider import BaseProvider
+from isa_model.inference.base import ModelType, Capability
+
+logger = logging.getLogger(__name__)
+
+class ModalProvider(BaseProvider):
+    """Provider for ISA Modal services"""
+    
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        super().__init__(config)
+        self.name = "modal"
+        self.base_url = "https://modal.com"  # Not used directly
+    
+    def _load_provider_env_vars(self):
+        """Load Modal-specific environment variables"""
+        # Modal doesn't need API keys for deployed services
+        # But we can load Modal token if available
+        modal_token = os.getenv("MODAL_TOKEN_ID") or os.getenv("MODAL_TOKEN_SECRET")
+        if modal_token:
+            self.config["modal_token"] = modal_token
+        
+        # Set default config
+        if "timeout" not in self.config:
+            self.config["timeout"] = 300
+        if "deployment_region" not in self.config:
+            self.config["deployment_region"] = "us-east-1"
+        if "gpu_type" not in self.config:
+            self.config["gpu_type"] = "T4"
+        
+    def get_api_key(self) -> str:
+        """Modal services don't need API keys for deployed apps"""
+        return "modal-deployed-service"  # Placeholder
+    
+    def get_base_url(self) -> str:
+        """Get base URL for Modal services"""
+        return self.base_url
+    
+    def validate_credentials(self) -> bool:
+        """
+        Validate Modal credentials
+        For deployed services, we assume they're accessible
+        """
+        try:
+            # Check if Modal is available
+            import modal
+            return True
+        except ImportError:
+            logger.warning("Modal package not available")
+            return False
+    
+    def get_capabilities(self) -> Dict[ModelType, List[Capability]]:
+        """Get Modal provider capabilities"""
+        return {
+            ModelType.VISION: [
+                Capability.OBJECT_DETECTION,
+                Capability.IMAGE_ANALYSIS,
+                Capability.UI_DETECTION,
+                Capability.OCR,
+                Capability.DOCUMENT_ANALYSIS
+            ]
+        }
+    
+    def get_models(self, model_type: ModelType) -> List[str]:
+        """Get available models for given type"""
+        if model_type == ModelType.VISION:
+            return [
+                "omniparser-v2.0",
+                "table-transformer-detection",
+                "table-transformer-structure-v1.1",
+                "paddleocr-3.0",
+                "yolov8"
+            ]
+        return []
+    
+    def is_reasoning_model(self, model_name: str) -> bool:
+        """Check if the model is optimized for reasoning tasks"""
+        # Vision models are not reasoning models
+        return False
+    
+    def get_default_config(self) -> Dict[str, Any]:
+        """Get default configuration for Modal services"""
+        return {
+            "timeout": 300,  # 5 minutes
+            "max_retries": 3,
+            "deployment_region": "us-east-1",
+            "gpu_type": "T4"
+        }
+    
+    def get_billing_info(self) -> Dict[str, Any]:
+        """Get billing information for Modal services"""
+        return {
+            "provider": "modal",
+            "billing_model": "compute_usage",
+            "cost_per_hour": {
+                "T4": 0.60,
+                "A100": 4.00
+            },
+            "note": "Costs depend on actual usage time, scales to zero when not in use"
+        }

isa_model/inference/providers/yyds_provider.py

@@ -0,0 +1,108 @@
+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
+import os
+
+logger = logging.getLogger(__name__)
+
+class YydsProvider(BaseProvider):
+    """Provider for YYDS API with proper API key management"""
+    
+    def __init__(self, config=None):
+        """Initialize the YYDS Provider with centralized config management"""
+        super().__init__(config)
+        self.name = "yyds"
+        
+        logger.info(f"Initialized YydsProvider with URL: {self.config.get('base_url', 'https://api.yyds.com/v1')}")
+        
+        if not self.has_valid_credentials():
+            logger.warning("YYDS API key not found. Set YYDS_API_KEY environment variable or pass api_key in config.")
+    
+    def _load_provider_env_vars(self):
+        """Load YYDS-specific environment variables"""
+        # Set defaults first
+        defaults = {
+            "base_url": "https://api.yyds.com/v1",
+            "timeout": 60,
+            "temperature": 0.7,
+            "top_p": 0.9,
+            "max_tokens": 1024
+        }
+        
+        # Apply defaults only if not already set
+        for key, value in defaults.items():
+            if key not in self.config:
+                self.config[key] = value
+        
+        # Load from environment variables (override config if present)
+        env_mappings = {
+            "api_key": "YYDS_API_KEY",
+            "base_url": "YYDS_API_BASE",
+            "organization": "YYDS_ORGANIZATION"
+        }
+        
+        for config_key, env_var in env_mappings.items():
+            env_value = os.getenv(env_var)
+            if env_value:
+                self.config[config_key] = env_value
+    
+    def _validate_config(self):
+        """Validate YYDS configuration"""
+        if not self.config.get("api_key"):
+            logger.debug("YYDS API key not set - some functionality may not work")
+    
+    def get_model_pricing(self, model_name: str) -> Dict[str, float]:
+        """Get pricing information for a model - delegated to ModelManager"""
+        # Import here to avoid circular imports
+        from isa_model.core.model_manager import ModelManager
+        model_manager = ModelManager()
+        return model_manager.get_model_pricing("yyds", model_name)
+    
+    def calculate_cost(self, model_name: str, input_tokens: int, output_tokens: int) -> float:
+        """Calculate cost for a request - delegated to ModelManager"""
+        # Import here to avoid circular imports
+        from isa_model.core.model_manager import ModelManager
+        model_manager = ModelManager()
+        return model_manager.calculate_cost("yyds", model_name, input_tokens, output_tokens)
+    
+    def set_api_key(self, api_key: str):
+        """Set the API key after initialization"""
+        self.config["api_key"] = api_key
+        logger.info("YYDS API key updated")
+    
+    def get_capabilities(self) -> Dict[ModelType, List[Capability]]:
+        """Get provider capabilities by model type"""
+        return {
+            ModelType.LLM: [
+                Capability.CHAT, 
+                Capability.COMPLETION
+            ]
+        }
+    
+    def get_models(self, model_type: ModelType) -> List[str]:
+        """Get available models for given type"""
+        if model_type == ModelType.LLM:
+            return ["claude-sonnet-4-20250514", "claude-3-5-sonnet-20241022"]
+        else:
+            return []
+    
+    def get_default_model(self, model_type: ModelType) -> str:
+        """Get default model for a given type"""
+        if model_type == ModelType.LLM:
+            return "claude-sonnet-4-20250514"
+        else:
+            return ""
+    
+    def get_config(self) -> Dict[str, Any]:
+        """Get provider configuration"""
+        # Return a copy without sensitive information
+        config_copy = self.config.copy()
+        if "api_key" in config_copy:
+            config_copy["api_key"] = "***" if config_copy["api_key"] else ""
+        return config_copy
+    
+    def is_reasoning_model(self, model_name: str) -> bool:
+        """Check if the model is optimized for reasoning tasks"""
+        reasoning_models = ["claude-sonnet-4", "claude-3-5-sonnet"]
+        return any(rm in model_name.lower() for rm in reasoning_models)

isa_model/inference/services/__init__.py

@@ -5,7 +5,8 @@ File: isa_model/inference/services/__init__.py
 This module contains service implementations for different AI model types.
 """
 
-from .base_service import BaseService, BaseLLMService, BaseEmbeddingService
+from .base_service import BaseService, BaseEmbeddingService
+from .llm.base_llm_service import BaseLLMService
 
 __all__ = [
     "BaseService",

isa_model/inference/services/audio/base_stt_service.py

@@ -3,7 +3,71 @@ from typing import Dict, Any, List, Union, Optional, BinaryIO
 from isa_model.inference.services.base_service import BaseService
 
 class BaseSTTService(BaseService):
-    """Base class for Speech-to-Text services"""
+    """Base class for Speech-to-Text services with unified task dispatch"""
+    
+    async def invoke(
+        self, 
+        audio_input: Union[str, BinaryIO, List[Union[str, BinaryIO]]],
+        task: Optional[str] = None,
+        **kwargs
+    ) -> Union[Dict[str, Any], List[Dict[str, Any]]]:
+        """
+        统一的任务分发方法 - Base类提供通用实现
+        
+        Args:
+            audio_input: 音频输入，可以是:
+                - str: 音频文件路径
+                - BinaryIO: 音频文件对象
+                - List: 多个音频文件（批量处理）
+            task: 任务类型，支持多种STT任务
+            **kwargs: 任务特定的附加参数
+            
+        Returns:
+            Dict or List[Dict] containing task results
+        """
+        task = task or "transcribe"
+        
+        # ==================== 语音转文本类任务 ====================
+        if task == "transcribe":
+            if isinstance(audio_input, list):
+                return await self.transcribe_batch(
+                    audio_input,
+                    kwargs.get("language"),
+                    kwargs.get("prompt")
+                )
+            else:
+                return await self.transcribe(
+                    audio_input,
+                    kwargs.get("language"),
+                    kwargs.get("prompt")
+                )
+        elif task == "translate":
+            if isinstance(audio_input, list):
+                raise ValueError("translate task requires single audio input")
+            return await self.translate(audio_input)
+        elif task == "batch_transcribe":
+            if not isinstance(audio_input, list):
+                audio_input = [audio_input]
+            return await self.transcribe_batch(
+                audio_input,
+                kwargs.get("language"),
+                kwargs.get("prompt")
+            )
+        elif task == "detect_language":
+            if isinstance(audio_input, list):
+                raise ValueError("detect_language task requires single audio input")
+            return await self.detect_language(audio_input)
+        else:
+            raise NotImplementedError(f"{self.__class__.__name__} does not support task: {task}")
+    
+    def get_supported_tasks(self) -> List[str]:
+        """
+        获取支持的任务列表
+        
+        Returns:
+            List of supported task names
+        """
+        return ["transcribe", "translate", "batch_transcribe", "detect_language"]
     
     @abstractmethod
     async def transcribe(

isa_model/inference/services/audio/base_tts_service.py

@@ -3,7 +3,81 @@ from typing import Dict, Any, List, Union, Optional, BinaryIO
 from isa_model.inference.services.base_service import BaseService
 
 class BaseTTSService(BaseService):
-    """Base class for Text-to-Speech services"""
+    """Base class for Text-to-Speech services with unified task dispatch"""
+    
+    async def invoke(
+        self, 
+        text: Union[str, List[str]],
+        task: Optional[str] = None,
+        **kwargs
+    ) -> Union[Dict[str, Any], List[Dict[str, Any]]]:
+        """
+        统一的任务分发方法 - Base类提供通用实现
+        
+        Args:
+            text: 输入文本，可以是:
+                - str: 单个文本
+                - List[str]: 多个文本（批量处理）
+            task: 任务类型，支持多种TTS任务
+            **kwargs: 任务特定的附加参数
+            
+        Returns:
+            Dict or List[Dict] containing task results
+        """
+        task = task or "synthesize"
+        
+        # ==================== 语音合成类任务 ====================
+        if task == "synthesize":
+            if isinstance(text, list):
+                return await self.synthesize_speech_batch(
+                    text, 
+                    kwargs.get("voice"),
+                    kwargs.get("speed", 1.0),
+                    kwargs.get("pitch", 1.0),
+                    kwargs.get("format", "mp3")
+                )
+            else:
+                return await self.synthesize_speech(
+                    text,
+                    kwargs.get("voice"),
+                    kwargs.get("speed", 1.0),
+                    kwargs.get("pitch", 1.0),
+                    kwargs.get("format", "mp3")
+                )
+        elif task == "synthesize_to_file":
+            if not kwargs.get("output_path"):
+                raise ValueError("output_path is required for synthesize_to_file task")
+            if isinstance(text, list):
+                raise ValueError("synthesize_to_file task requires single text input")
+            return await self.synthesize_speech_to_file(
+                text,
+                kwargs["output_path"],
+                kwargs.get("voice"),
+                kwargs.get("speed", 1.0),
+                kwargs.get("pitch", 1.0),
+                kwargs.get("format", "mp3")
+            )
+        elif task == "batch_synthesize":
+            if not isinstance(text, list):
+                text = [text]
+            return await self.synthesize_speech_batch(
+                text,
+                kwargs.get("voice"),
+                kwargs.get("speed", 1.0),
+                kwargs.get("pitch", 1.0),
+                kwargs.get("format", "mp3")
+            )
+        else:
+            raise NotImplementedError(f"{self.__class__.__name__} does not support task: {task}")
+    
+    def get_supported_tasks(self) -> List[str]:
+        """
+        获取支持的任务列表
+        
+        Returns:
+            List of supported task names
+        """
+        return ["synthesize", "synthesize_to_file", "batch_synthesize"]
     
     @abstractmethod
     async def synthesize_speech(