isa-model 0.1.0__tar.gz

isa_model-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023-2024 isA_Model Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. 

isa_model-0.1.0/MANIFEST.in

@@ -0,0 +1,3 @@
+include LICENSE
+include README.md
+recursive-include isa_model *.py

isa_model-0.1.0/PKG-INFO

@@ -0,0 +1,116 @@
+Metadata-Version: 2.4
+Name: isa-model
+Version: 0.1.0
+Summary: Unified AI model serving framework
+Author-email: isA_Model Contributors <your.email@example.com>
+License: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi>=0.95.0
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: httpx>=0.23.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: uvicorn>=0.22.0
+Requires-Dist: requests>=2.28.0
+Requires-Dist: aiohttp>=3.8.0
+Requires-Dist: transformers>=4.30.0
+Requires-Dist: langchain-core>=0.1.0
+Requires-Dist: tritonclient[grpc,http]>=2.30.0
+Requires-Dist: huggingface-hub>=0.16.0
+Requires-Dist: kubernetes>=25.3.0
+Requires-Dist: mlflow>=2.4.0
+Requires-Dist: torch>=2.0.0
+Dynamic: license-file
+
+# isA_Model - AI服务工厂
+
+isA_Model是一个轻量级AI服务工厂，用于统一管理和调用不同的AI模型和服务提供商。
+
+## 特性
+
+- 支持多种AI提供商(Ollama, OpenAI, Replicate, Triton)
+- 统一的API接口
+- 灵活的工厂模式
+- 异步支持
+- 单例模式，高效缓存
+
+## 安装
+
+```bash
+pip install -r requirements.txt
+```
+
+## 快速开始
+
+使用AI工厂很简单：
+
+```python
+from isa_model.inference.ai_factory import AIFactory
+from isa_model.inference.base import ModelType
+
+# 获取工厂实例
+factory = AIFactory()
+
+# LLM示例 - 使用Ollama
+llm = factory.get_llm(model_name="llama3.1", provider="ollama")
+response = await llm.generate("你好，请介绍一下自己。")
+print(response)
+
+# 图像生成示例 - 使用Replicate
+vision_service = factory.get_vision_model(
+    model_name="stability-ai/sdxl:c221b2b8ef527988fb59bf24a8b97c4561f1c671f73bd389f866bfb27c061316",
+    provider="replicate",
+    config={"api_token": "your_replicate_token"}
+)
+result = await vision_service.generate_image({
+    "prompt": "A beautiful sunset over mountains",
+    "num_inference_steps": 25
+})
+print(result["urls"])
+```
+
+## 工厂架构
+
+isA_Model使用三层架构:
+
+1. **客户端层** - 应用程序代码
+2. **服务层** - 模型服务实现(LLM, 图像, 嵌入等)
+3. **提供商层** - 底层API集成(Ollama, OpenAI, Replicate等)
+
+### 主要组件
+
+- `AIFactory` - 中央工厂类，提供模型和服务访问
+- `BaseService` - 所有服务的基类
+- `BaseProvider` - 所有提供商的基类
+- 特定服务实现 - 如`ReplicateVisionService`, `OllamaLLMService`等
+
+## 支持的模型类型
+
+- **LLM** - 大语言模型 
+- **VISION** - 图像生成和分析
+- **EMBEDDING** - 文本嵌入
+- **AUDIO** - 语音识别
+- **RERANK** - 重排序
+
+## 示例
+
+查看`test_*.py`文件获取更多使用示例。
+
+## 环境变量
+
+将API密钥和其他配置添加到`.env.local`文件中:
+
+```
+OPENAI_API_KEY=your_openai_key
+REPLICATE_API_TOKEN=your_replicate_token
+```
+
+## 许可证
+
+MIT 

isa_model-0.1.0/README.md

@@ -0,0 +1,86 @@
+# isA_Model - AI服务工厂
+
+isA_Model是一个轻量级AI服务工厂，用于统一管理和调用不同的AI模型和服务提供商。
+
+## 特性
+
+- 支持多种AI提供商(Ollama, OpenAI, Replicate, Triton)
+- 统一的API接口
+- 灵活的工厂模式
+- 异步支持
+- 单例模式，高效缓存
+
+## 安装
+
+```bash
+pip install -r requirements.txt
+```
+
+## 快速开始
+
+使用AI工厂很简单：
+
+```python
+from isa_model.inference.ai_factory import AIFactory
+from isa_model.inference.base import ModelType
+
+# 获取工厂实例
+factory = AIFactory()
+
+# LLM示例 - 使用Ollama
+llm = factory.get_llm(model_name="llama3.1", provider="ollama")
+response = await llm.generate("你好，请介绍一下自己。")
+print(response)
+
+# 图像生成示例 - 使用Replicate
+vision_service = factory.get_vision_model(
+    model_name="stability-ai/sdxl:c221b2b8ef527988fb59bf24a8b97c4561f1c671f73bd389f866bfb27c061316",
+    provider="replicate",
+    config={"api_token": "your_replicate_token"}
+)
+result = await vision_service.generate_image({
+    "prompt": "A beautiful sunset over mountains",
+    "num_inference_steps": 25
+})
+print(result["urls"])
+```
+
+## 工厂架构
+
+isA_Model使用三层架构:
+
+1. **客户端层** - 应用程序代码
+2. **服务层** - 模型服务实现(LLM, 图像, 嵌入等)
+3. **提供商层** - 底层API集成(Ollama, OpenAI, Replicate等)
+
+### 主要组件
+
+- `AIFactory` - 中央工厂类，提供模型和服务访问
+- `BaseService` - 所有服务的基类
+- `BaseProvider` - 所有提供商的基类
+- 特定服务实现 - 如`ReplicateVisionService`, `OllamaLLMService`等
+
+## 支持的模型类型
+
+- **LLM** - 大语言模型 
+- **VISION** - 图像生成和分析
+- **EMBEDDING** - 文本嵌入
+- **AUDIO** - 语音识别
+- **RERANK** - 重排序
+
+## 示例
+
+查看`test_*.py`文件获取更多使用示例。
+
+## 环境变量
+
+将API密钥和其他配置添加到`.env.local`文件中:
+
+```
+OPENAI_API_KEY=your_openai_key
+REPLICATE_API_TOKEN=your_replicate_token
+```
+
+## 许可证
+
+MIT 

isa_model-0.1.0/isa_model/__init__.py

@@ -0,0 +1,5 @@
+"""
+isA_Model - A simple interface for AI model integration
+"""
+
+__version__ = "0.1.0" 

isa_model-0.1.0/isa_model/core/model_manager.py

@@ -0,0 +1,143 @@
+from typing import Dict, Optional, List, Any
+import logging
+from pathlib import Path
+from huggingface_hub import hf_hub_download, snapshot_download
+from huggingface_hub.utils import HfHubHTTPError
+from .model_storage import ModelStorage, LocalModelStorage
+from .model_registry import ModelRegistry, ModelType, ModelCapability
+
+logger = logging.getLogger(__name__)
+
+class ModelManager:
+    """Model management service for handling model downloads, versions, and caching"""
+    
+    def __init__(self, 
+                 storage: Optional[ModelStorage] = None,
+                 registry: Optional[ModelRegistry] = None):
+        self.storage = storage or LocalModelStorage()
+        self.registry = registry or ModelRegistry()
+    
+    async def get_model(self, 
+                       model_id: str, 
+                       repo_id: str,
+                       model_type: ModelType,
+                       capabilities: List[ModelCapability],
+                       revision: Optional[str] = None,
+                       force_download: bool = False) -> Path:
+        """
+        Get model files, downloading if necessary
+        
+        Args:
+            model_id: Unique identifier for the model
+            repo_id: Hugging Face repository ID
+            model_type: Type of model (LLM, embedding, etc.)
+            capabilities: List of model capabilities
+            revision: Specific model version/tag
+            force_download: Force re-download even if cached
+            
+        Returns:
+            Path to the model files
+        """
+        # Check if model is already downloaded
+        if not force_download:
+            model_path = await self.storage.load_model(model_id)
+            if model_path:
+                logger.info(f"Using cached model {model_id}")
+                return model_path
+        
+        try:
+            # Download model files
+            logger.info(f"Downloading model {model_id} from {repo_id}")
+            model_dir = Path(f"./models/temp/{model_id}")
+            model_dir.mkdir(parents=True, exist_ok=True)
+            
+            snapshot_download(
+                repo_id=repo_id,
+                revision=revision,
+                local_dir=model_dir,
+                local_dir_use_symlinks=False
+            )
+            
+            # Save model and metadata
+            metadata = {
+                "repo_id": repo_id,
+                "revision": revision,
+                "downloaded_at": str(Path(model_dir).stat().st_mtime)
+            }
+            
+            # Register model
+            self.registry.register_model(
+                model_id=model_id,
+                model_type=model_type,
+                capabilities=capabilities,
+                metadata=metadata
+            )
+            
+            # Save model files
+            await self.storage.save_model(model_id, str(model_dir), metadata)
+            
+            return await self.storage.load_model(model_id)
+            
+        except HfHubHTTPError as e:
+            logger.error(f"Failed to download model {model_id}: {e}")
+            raise
+    
+    async def list_models(self) -> List[Dict[str, Any]]:
+        """List all downloaded models with their metadata"""
+        models = await self.storage.list_models()
+        return [
+            {
+                "model_id": model_id,
+                **metadata,
+                **(self.registry.get_model_info(model_id) or {})
+            }
+            for model_id, metadata in models.items()
+        ]
+    
+    async def remove_model(self, model_id: str) -> bool:
+        """Remove a model and its metadata"""
+        try:
+            # Remove from storage
+            storage_success = await self.storage.delete_model(model_id)
+            
+            # Unregister from registry
+            registry_success = self.registry.unregister_model(model_id)
+            
+            return storage_success and registry_success
+            
+        except Exception as e:
+            logger.error(f"Failed to remove model {model_id}: {e}")
+            return False
+    
+    async def get_model_info(self, model_id: str) -> Optional[Dict[str, Any]]:
+        """Get information about a specific model"""
+        storage_info = await self.storage.get_metadata(model_id)
+        registry_info = self.registry.get_model_info(model_id)
+        
+        if not storage_info and not registry_info:
+            return None
+            
+        return {
+            **(storage_info or {}),
+            **(registry_info or {})
+        }
+    
+    async def update_model(self, 
+                          model_id: str, 
+                          repo_id: str,
+                          model_type: ModelType,
+                          capabilities: List[ModelCapability],
+                          revision: Optional[str] = None) -> bool:
+        """Update a model to a new version"""
+        try:
+            return bool(await self.get_model(
+                model_id=model_id,
+                repo_id=repo_id,
+                model_type=model_type,
+                capabilities=capabilities,
+                revision=revision,
+                force_download=True
+            ))
+        except Exception as e:
+            logger.error(f"Failed to update model {model_id}: {e}")
+            return False 

isa_model-0.1.0/isa_model/core/model_registry.py

@@ -0,0 +1,115 @@
+from typing import Dict, List, Optional, Any
+from enum import Enum
+import logging
+from pathlib import Path
+import json
+
+logger = logging.getLogger(__name__)
+
+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"
+
+class ModelType(str, Enum):
+    """Model types"""
+    LLM = "llm"
+    EMBEDDING = "embedding"
+    RERANK = "rerank"
+    IMAGE = "image"
+    AUDIO = "audio"
+    VIDEO = "video"
+    VISION = "vision"
+
+class ModelRegistry:
+    """Registry for model metadata and capabilities"""
+    
+    def __init__(self, registry_file: str = "./models/model_registry.json"):
+        self.registry_file = Path(registry_file)
+        self.registry: Dict[str, Dict[str, Any]] = {}
+        self._load_registry()
+    
+    def _load_registry(self):
+        """Load model registry from file"""
+        if self.registry_file.exists():
+            with open(self.registry_file, 'r') as f:
+                self.registry = json.load(f)
+        else:
+            self.registry = {}
+            self._save_registry()
+    
+    def _save_registry(self):
+        """Save model registry to file"""
+        self.registry_file.parent.mkdir(parents=True, exist_ok=True)
+        with open(self.registry_file, 'w') as f:
+            json.dump(self.registry, f, indent=2)
+    
+    def register_model(self, 
+                      model_id: str,
+                      model_type: ModelType,
+                      capabilities: List[ModelCapability],
+                      metadata: Dict[str, Any]) -> bool:
+        """Register a model with its capabilities and metadata"""
+        try:
+            self.registry[model_id] = {
+                "type": model_type,
+                "capabilities": [cap.value for cap in capabilities],
+                "metadata": metadata
+            }
+            self._save_registry()
+            logger.info(f"Registered model {model_id}")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to register model {model_id}: {e}")
+            return False
+    
+    def unregister_model(self, model_id: str) -> bool:
+        """Unregister a model"""
+        try:
+            if model_id in self.registry:
+                del self.registry[model_id]
+                self._save_registry()
+                logger.info(f"Unregistered model {model_id}")
+                return True
+            return False
+        except Exception as e:
+            logger.error(f"Failed to unregister model {model_id}: {e}")
+            return False
+    
+    def get_model_info(self, model_id: str) -> Optional[Dict[str, Any]]:
+        """Get model information"""
+        return self.registry.get(model_id)
+    
+    def get_models_by_type(self, model_type: ModelType) -> Dict[str, Dict[str, Any]]:
+        """Get all models of a specific type"""
+        return {
+            model_id: info
+            for model_id, info in self.registry.items()
+            if info["type"] == model_type
+        }
+    
+    def get_models_by_capability(self, capability: ModelCapability) -> Dict[str, Dict[str, Any]]:
+        """Get all models with a specific capability"""
+        return {
+            model_id: info
+            for model_id, info in self.registry.items()
+            if capability.value in info["capabilities"]
+        }
+    
+    def has_capability(self, model_id: str, capability: ModelCapability) -> bool:
+        """Check if a model has a specific capability"""
+        model_info = self.get_model_info(model_id)
+        if not model_info:
+            return False
+        return capability.value in model_info["capabilities"]
+    
+    def list_models(self) -> Dict[str, Dict[str, Any]]:
+        """List all registered models"""
+        return self.registry