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

isa_model/inference/providers/base_provider.py

@@ -1,77 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Dict, List, Any, Optional
-import os
-import logging
-from pathlib import Path
-import dotenv
-
-from isa_model.inference.base import ModelType, Capability
-
-logger = logging.getLogger(__name__)
-
-class BaseProvider(ABC):
-    """Base class for all AI providers - handles API key management"""
-    
-    def __init__(self, config: Optional[Dict[str, Any]] = None):
-        self.config = config or {}
-        self._load_environment_config()
-        self._validate_config()
-    
-    def _load_environment_config(self):
-        """Load configuration from environment variables"""
-        # Load .env file if it exists
-        project_root = Path(__file__).parent.parent.parent.parent
-        env_path = project_root / ".env"
-        
-        if env_path.exists():
-            dotenv.load_dotenv(env_path)
-        
-        # Subclasses should override this to load provider-specific env vars
-        self._load_provider_env_vars()
-    
-    @abstractmethod
-    def _load_provider_env_vars(self):
-        """Load provider-specific environment variables"""
-        pass
-    
-    def _validate_config(self):
-        """Validate that required configuration is present"""
-        # Subclasses should override this to validate provider-specific config
-        pass
-    
-    def get_api_key(self) -> Optional[str]:
-        """Get the API key for this provider"""
-        return self.config.get("api_key")
-    
-    def has_valid_credentials(self) -> bool:
-        """Check if provider has valid credentials"""
-        return bool(self.get_api_key())
-    
-    @abstractmethod
-    def get_capabilities(self) -> Dict[ModelType, List[Capability]]:
-        """Get provider capabilities by model type"""
-        pass
-    
-    @abstractmethod
-    def get_models(self, model_type: ModelType) -> List[str]:
-        """Get available models for given type"""
-        pass
-    
-    def get_config(self) -> Dict[str, Any]:
-        """Get provider configuration (without sensitive data)"""
-        # 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 ""
-        if "api_token" in config_copy:
-            config_copy["api_token"] = "***" if config_copy["api_token"] else ""
-        return config_copy
-    
-    def get_full_config(self) -> Dict[str, Any]:
-        """Get full provider configuration (including sensitive data) - for internal use only"""
-        return self.config.copy()
-    
-    @abstractmethod
-    def is_reasoning_model(self, model_name: str) -> bool:
-        """Check if the model is optimized for reasoning tasks"""
-        pass

isa_model/inference/providers/ml_provider.py

@@ -1,50 +0,0 @@
-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/providers/modal_provider.py

@@ -1,109 +0,0 @@
-"""
-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/model_cache_manager.py

@@ -1,341 +0,0 @@
-from typing import Dict, List, Any, Optional
-import aiohttp
-import logging
-import asyncio
-from collections import OrderedDict
-import os
-import json
-import hashlib
-from pathlib import Path
-from isa_model.inference.base import ModelType
-
-logger = logging.getLogger(__name__)
-
-class ModelCacheManager:
-    """管理Triton服务器模型的加载/卸载，支持轮询模式"""
-    
-    def __init__(self, cache_size: int = 5, model_repository: str = "/models"):
-        """
-        初始化模型缓存管理器
-        
-        Args:
-            cache_size: 最大缓存模型数量
-            model_repository: 模型库路径
-        """
-        self.cache_size = cache_size
-        self.model_repository = model_repository
-        
-        # LRU缓存使用OrderedDict
-        self.model_cache = OrderedDict()
-        
-        # 服务器配置
-        self.server_config = {
-            "polling_enabled": True,  # 默认启用轮询模式（适合多模型场景）
-            "triton_url": "localhost:8000",
-            "openai_api_url": "localhost:9000"
-        }
-        
-        # 模型类型映射
-        self.model_type_map = {
-            ModelType.LLM: "llm",
-            ModelType.EMBEDDING: "embedding",
-            ModelType.VISION: "vision",
-            ModelType.RERANK: "rerank"
-        }
-        
-        logger.info(f"初始化ModelCacheManager，缓存大小: {cache_size}，模型库: {model_repository}")
-    
-    async def detect_server_mode(self):
-        """检测Triton服务器是否运行在轮询模式"""
-        try:
-            # 尝试加载任意模型以检测模式
-            models = await self._get_repository_models()
-            if not models:
-                logger.warning("无法获取模型列表，无法检测服务器模式")
-                return
-                
-            test_model = models[0]
-            url = f"http://{self.server_config['triton_url']}/v2/repository/models/{test_model}/load"
-            
-            async with aiohttp.ClientSession() as session:
-                async with session.post(url) as response:
-                    response_text = await response.text()
-                    
-                    if response.status == 503 and "polling is enabled" in response_text:
-                        self.server_config["polling_enabled"] = True
-                        logger.info("检测到Triton服务器运行在轮询模式（多模型模式）")
-                    elif response.status == 200:
-                        self.server_config["polling_enabled"] = False
-                        logger.info("检测到Triton服务器运行在手动加载模式（单模型模式）")
-                    else:
-                        logger.warning(f"无法确定服务器模式，状态码: {response.status}")
-        except Exception as e:
-            logger.error(f"检测服务器模式时出错: {e}")
-    
-    async def load_model(self, model_name: str, model_type: ModelType) -> bool:
-        """
-        加载模型到Triton服务器
-        
-        Args:
-            model_name: 模型名称
-            model_type: 模型类型
-            
-        Returns:
-            bool: 成功返回True，失败返回False
-        """
-        # 如果是第一次加载，检测服务器模式
-        if not hasattr(self, '_mode_detected'):
-            await self.detect_server_mode()
-            self._mode_detected = True
-        
-        if model_name in self.model_cache:
-            # 模型已加载，移到LRU缓存末尾
-            self.model_cache.move_to_end(model_name)
-            logger.info(f"模型 {model_name} 已在缓存中，移至末尾")
-            return True
-        
-        try:
-            # 检查模型是否已加载到服务器
-            is_loaded = await self._check_model_loaded(model_name)
-            if is_loaded:
-                logger.info(f"模型 {model_name} 已在服务器中加载")
-                self.model_cache[model_name] = {
-                    "type": model_type,
-                    "load_time": asyncio.get_event_loop().time()
-                }
-                return True
-            
-            # 如果在轮询模式下，我们不能手动加载模型
-            if self.server_config["polling_enabled"]:
-                # 检查模型是否存在
-                exists = await self._check_model_exists(model_name)
-                if exists:
-                    logger.warning(f"服务器在轮询模式下，无法手动加载模型 {model_name}，但模型存在")
-                    # 我们假设模型将通过轮询加载
-                    return True
-                else:
-                    logger.error(f"模型 {model_name} 不存在于服务器存储库中")
-                    return False
-            else:
-                # 在非轮询模式下，可以手动加载
-                # 如果缓存已满，卸载最少使用的模型
-                if len(self.model_cache) >= self.cache_size:
-                    lru_model, _ = self.model_cache.popitem(last=False)
-                    await self._unload_from_triton(lru_model)
-                    logger.info(f"从缓存中卸载LRU模型 {lru_model}")
-                
-                # 加载新模型
-                success = await self._load_to_triton(model_name)
-                if success:
-                    self.model_cache[model_name] = {
-                        "type": model_type,
-                        "load_time": asyncio.get_event_loop().time()
-                    }
-                    logger.info(f"成功加载模型 {model_name}")
-                    return True
-                else:
-                    logger.error(f"加载模型 {model_name} 失败")
-                    return False
-                
-        except Exception as e:
-            logger.error(f"加载模型 {model_name} 时出错: {e}")
-            return False
-    
-    async def unload_model(self, model_name: str) -> bool:
-        """卸载模型"""
-        # 如果在轮询模式下，我们不能手动卸载模型
-        if self.server_config["polling_enabled"]:
-            logger.warning(f"服务器在轮询模式下，无法手动卸载模型 {model_name}")
-            return True
-        
-        if model_name not in self.model_cache:
-            logger.warning(f"模型 {model_name} 未在缓存中，无需卸载")
-            return True
-        
-        try:
-            # 卸载模型
-            success = await self._unload_from_triton(model_name)
-            if success:
-                # 从缓存中移除
-                self.model_cache.pop(model_name, None)
-                logger.info(f"成功卸载模型 {model_name}")
-                return True
-            else:
-                logger.error(f"卸载模型 {model_name} 失败")
-                return False
-                
-        except Exception as e:
-            logger.error(f"卸载模型 {model_name} 时出错: {e}")
-            return False
-    
-    async def _load_to_triton(self, model_name: str) -> bool:
-        """向Triton服务器发送加载模型请求"""
-        try:
-            logger.info(f"尝试加载模型 {model_name} 到Triton服务器")
-            
-            url = f"http://{self.server_config['triton_url']}/v2/repository/models/{model_name}/load"
-            
-            async with aiohttp.ClientSession() as session:
-                async with session.post(url) as response:
-                    response_text = await response.text()
-                    
-                    if response.status == 200:
-                        logger.info(f"成功加载模型 {model_name}")
-                        return True
-                    elif response.status == 400:
-                        # 模型可能已加载
-                        logger.info(f"模型 {model_name} 可能已加载: {response_text}")
-                        return True
-                    elif response.status == 503 and "polling is enabled" in response_text:
-                        # 检测到轮询模式
-                        self.server_config["polling_enabled"] = True
-                        logger.warning(f"服务器在轮询模式下，无法手动加载模型: {response_text}")
-                        # 检查模型是否存在
-                        return await self._check_model_exists(model_name)
-                    else:
-                        logger.error(f"加载模型 {model_name} 失败: Status {response.status}, Response: {response_text}")
-                        return False
-                    
-        except Exception as e:
-            logger.error(f"向Triton API发送加载模型 {model_name} 请求时出错: {e}")
-            return False
-    
-    async def _check_model_loaded(self, model_name: str) -> bool:
-        """检查模型是否已加载"""
-        try:
-            url = f"http://{self.server_config['triton_url']}/v2/models/{model_name}/ready"
-            
-            async with aiohttp.ClientSession() as session:
-                async with session.get(url) as response:
-                    if response.status == 200:
-                        logger.info(f"模型 {model_name} 已加载")
-                        return True
-                    else:
-                        logger.info(f"模型 {model_name} 未加载，状态码: {response.status}")
-                        return False
-        except Exception as e:
-            logger.error(f"检查模型 {model_name} 是否加载时出错: {e}")
-            return False
-    
-    async def _check_model_exists(self, model_name: str) -> bool:
-        """检查模型是否存在于存储库中"""
-        try:
-            url = f"http://{self.server_config['triton_url']}/v2/repository/index"
-            
-            async with aiohttp.ClientSession() as session:
-                async with session.post(url) as response:
-                    if response.status == 200:
-                        models = await response.json()
-                        model_names = [model["name"] for model in models]
-                        exists = model_name in model_names
-                        logger.info(f"模型 {model_name} {'存在' if exists else '不存在'}于存储库中")
-                        logger.info(f"可用模型: {model_names}")
-                        return exists
-                    else:
-                        logger.error(f"检查模型存在性失败: {response.status}")
-                        return False
-        except Exception as e:
-            logger.error(f"检查模型存在性时出错: {e}")
-            return False
-    
-    async def _unload_from_triton(self, model_name: str) -> bool:
-        """从Triton服务器卸载模型"""
-        try:
-            url = f"http://{self.server_config['triton_url']}/v2/repository/models/{model_name}/unload"
-            
-            async with aiohttp.ClientSession() as session:
-                async with session.post(url) as response:
-                    response_text = await response.text()
-                    
-                    if response.status == 200:
-                        logger.info(f"成功卸载模型 {model_name}")
-                        return True
-                    elif response.status == 503 and "polling is enabled" in response_text:
-                        # 检测到轮询模式
-                        self.server_config["polling_enabled"] = True
-                        logger.warning(f"服务器在轮询模式下，无法手动卸载模型: {response_text}")
-                        return True
-                    else:
-                        logger.error(f"卸载模型 {model_name} 失败: Status {response.status}, Response: {response_text}")
-                        return False
-        except Exception as e:
-            logger.error(f"向Triton API发送卸载模型 {model_name} 请求时出错: {e}")
-            return False
-    
-    def list_available_models(self, model_type: ModelType = None) -> List[str]:
-        """
-        列出可用模型
-        
-        Args:
-            model_type: 按模型类型筛选
-            
-        Returns:
-            模型名称列表
-        """
-        try:
-            # 获取模型列表
-            models = asyncio.run(self._get_repository_models())
-            
-            if not models:
-                logger.warning("在存储库中未找到模型或无法连接到服务器")
-                return []
-            
-            # 如果未指定模型类型，返回所有模型
-            if model_type is None:
-                return models
-            
-            # 基于命名约定的简单过滤器
-            if model_type == ModelType.LLM:
-                # 返回包含关键字的模型
-                llm_keywords = ["llama", "mistral", "gemma", "qwen", "phi", "gpt", "falcon"]
-                return [m for m in models if any(kw in m.lower() for kw in llm_keywords)]
-            elif model_type == ModelType.EMBEDDING:
-                embed_keywords = ["embed", "bge", "e5", "text-embedding"]
-                return [m for m in models if any(kw in m.lower() for kw in embed_keywords)]
-            elif model_type == ModelType.VISION:
-                vision_keywords = ["clip", "vision", "multimodal", "image"]
-                return [m for m in models if any(kw in m.lower() for kw in vision_keywords)]
-            elif model_type == ModelType.RERANK:
-                rerank_keywords = ["rerank", "cross-encoder"]
-                return [m for m in models if any(kw in m.lower() for kw in rerank_keywords)]
-            else:
-                return []
-                
-        except Exception as e:
-            logger.error(f"列出模型时出错: {e}")
-            return []
-    
-    async def _get_repository_models(self) -> List[str]:
-        """从Triton服务器获取模型列表"""
-        try:
-            url = f"http://{self.server_config['triton_url']}/v2/repository/index"
-            
-            async with aiohttp.ClientSession() as session:
-                async with session.post(url) as response:
-                    if response.status == 200:
-                        models = await response.json()
-                        return [model["name"] for model in models]
-                    else:
-                        logger.error(f"获取模型失败: Status {response.status}")
-                        return []
-        except Exception as e:
-            logger.error(f"获取存储库模型时出错: {e}")
-            return []
-    
-    async def get_openai_models(self) -> List[Dict[str, Any]]:
-        """获取OpenAI兼容API中的可用模型"""
-        try:
-            url = f"http://{self.server_config['openai_api_url']}/v1/models"
-            
-            async with aiohttp.ClientSession() as session:
-                async with session.get(url) as response:
-                    if response.status == 200:
-                        result = await response.json()
-                        logger.info(f"从OpenAI API获取到 {len(result.get('data', []))} 个模型")
-                        return result.get("data", [])
-                    else:
-                        logger.error(f"获取OpenAI模型失败: Status {response.status}")
-                        return []
-        except Exception as e:
-            logger.error(f"获取OpenAI模型时出错: {e}")
-            return [] 

isa_model/inference/providers/ollama_provider.py

@@ -1,92 +0,0 @@
-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 OllamaProvider(BaseProvider):
-    """Provider for Ollama API with proper configuration management"""
-    
-    def __init__(self, config=None):
-        """Initialize the Ollama Provider with centralized config management"""
-        super().__init__(config)
-        self.name = "ollama"
-        
-        logger.info(f"Initialized OllamaProvider with URL: {self.config.get('base_url', 'http://localhost:11434')}")
-    
-    def _load_provider_env_vars(self):
-        """Load Ollama-specific environment variables"""
-        # Set defaults first
-        defaults = {
-            "base_url": "http://localhost:11434",
-            "timeout": 60,
-            "temperature": 0.7,
-            "top_p": 0.9,
-            "max_tokens": 2048,
-            "keep_alive": "5m"
-        }
-        
-        # 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 = {
-            "base_url": "OLLAMA_BASE_URL",
-        }
-        
-        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 Ollama configuration"""
-        # Ollama doesn't require API keys, just validate base_url is set
-        if not self.config.get("base_url"):
-            logger.warning("Ollama base_url not set, using default: http://localhost:11434")
-            self.config["base_url"] = "http://localhost:11434"
-    
-    def has_valid_credentials(self) -> bool:
-        """Check if provider has valid credentials (Ollama doesn't need API keys)"""
-        return True  # Ollama typically doesn't require authentication
-    
-    def get_capabilities(self) -> Dict[ModelType, List[Capability]]:
-        """Get provider capabilities by model type"""
-        return {
-            ModelType.LLM: [
-                Capability.CHAT, 
-                Capability.COMPLETION
-            ],
-            ModelType.EMBEDDING: [
-                Capability.EMBEDDING
-            ],
-            ModelType.VISION: [
-                Capability.MULTIMODAL_UNDERSTANDING
-            ]
-        }
-    
-    def get_models(self, model_type: ModelType) -> List[str]:
-        """Get available models for given type"""
-        # Placeholder: In real implementation, this would query Ollama API
-        if model_type == ModelType.LLM:
-            return ["llama3.2:3b", "llama3", "mistral", "phi3", "llama3.1", "codellama", "gemma"]
-        elif model_type == ModelType.EMBEDDING:
-            return ["bge-m3", "nomic-embed-text"]
-        elif model_type == ModelType.VISION:
-            return ["gemma3:4b", "llava", "bakllava", "llama3-vision"]
-        else:
-            return []
-    
-    def get_config(self) -> Dict[str, Any]:
-        """Get provider configuration"""
-        return self.config
-    
-    def is_reasoning_model(self, model_name: str) -> bool:
-        """Check if the model is optimized for reasoning tasks"""
-        # Default implementation: consider larger models as reasoning-capable
-        reasoning_models = ["llama3.1", "llama3", "claude3", "gpt4", "mixtral", "gemma", "palm2"]
-        return any(rm in model_name.lower() for rm in reasoning_models)