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

isa_model/inference/services/img/helpers/base_stacked_service.py

@@ -0,0 +1,274 @@
+"""
+Base Stacked Service for orchestrating multiple AI models
+"""
+
+from abc import ABC, abstractmethod
+from typing import Dict, Any, List, Optional, Union, Callable
+import time
+import asyncio
+import logging
+from dataclasses import dataclass
+from enum import Enum
+
+# Import shared types from helpers
+try:
+    from ..helpers.stacked_config import StackedLayerType as LayerType, LayerConfig, LayerResult
+except ImportError:
+    # Fallback definitions if shared config is not available
+    class LayerType(Enum):
+        """Types of processing layers"""
+        INTELLIGENCE = "intelligence"
+        DETECTION = "detection"
+        CLASSIFICATION = "classification"
+        VALIDATION = "validation"
+        TRANSFORMATION = "transformation"
+        GENERATION = "generation"
+        ENHANCEMENT = "enhancement"
+        CONTROL = "control"
+        UPSCALING = "upscaling"
+    
+    @dataclass
+    class LayerConfig:
+        """Configuration for a processing layer"""
+        name: str
+        layer_type: LayerType
+        service_type: str
+        model_name: str
+        parameters: Dict[str, Any]
+        depends_on: List[str]
+        timeout: float = 30.0
+        retry_count: int = 1
+        fallback_enabled: bool = True
+    
+    @dataclass
+    class LayerResult:
+        """Result from a processing layer"""
+        layer_name: str
+        success: bool
+        data: Any
+        metadata: Dict[str, Any]
+        execution_time: float
+        error: Optional[str] = None
+
+logger = logging.getLogger(__name__)
+
+class BaseStackedService(ABC):
+    """
+    Base class for stacked services that orchestrate multiple AI models
+    """
+    
+    def __init__(self, ai_factory, service_name: str):
+        self.ai_factory = ai_factory
+        self.service_name = service_name
+        self.layers: List[LayerConfig] = []
+        self.services: Dict[str, Any] = {}
+        self.results: Dict[str, LayerResult] = {}
+        
+    def add_layer(self, config: LayerConfig):
+        """Add a processing layer to the stack"""
+        self.layers.append(config)
+        logger.info(f"Added layer {config.name} ({config.layer_type.value}) to {self.service_name}")
+    
+    async def initialize_services(self):
+        """Initialize all required services"""
+        for layer in self.layers:
+            service_key = f"{layer.service_type}_{layer.model_name}"
+            
+            if service_key not in self.services:
+                if layer.service_type == 'vision':
+                    if layer.model_name == "default":
+                        # 使用默认vision服务
+                        service = self.ai_factory.get_vision()
+                    elif layer.model_name == "omniparser":
+                        # 使用replicate omniparser
+                        service = self.ai_factory.get_vision(model_name="omniparser", provider="replicate")
+                    else:
+                        # 其他指定模型
+                        service = self.ai_factory.get_vision(model_name=layer.model_name)
+                elif layer.service_type == 'llm':
+                    if layer.model_name == "default":
+                        service = self.ai_factory.get_llm()
+                    else:
+                        service = self.ai_factory.get_llm(model_name=layer.model_name)
+                elif layer.service_type == 'image_gen':
+                    if layer.model_name == "default":
+                        service = self.ai_factory.get_image_gen()
+                    else:
+                        service = self.ai_factory.get_image_gen(model_name=layer.model_name)
+                else:
+                    raise ValueError(f"Unsupported service type: {layer.service_type}")
+                
+                self.services[service_key] = service
+                logger.info(f"Initialized {service_key} service")
+    
+    async def execute_layer(self, layer: LayerConfig, context: Dict[str, Any]) -> LayerResult:
+        """Execute a single layer"""
+        start_time = time.time()
+        
+        try:
+            # Check dependencies
+            for dep in layer.depends_on:
+                if dep not in self.results or not self.results[dep].success:
+                    raise ValueError(f"Dependency {dep} failed or not executed")
+            
+            # Get the service
+            service_key = f"{layer.service_type}_{layer.model_name}"
+            service = self.services[service_key]
+            
+            # Execute layer with timeout
+            data = await asyncio.wait_for(
+                self.execute_layer_logic(layer, service, context),
+                timeout=layer.timeout
+            )
+            
+            execution_time = time.time() - start_time
+            
+            result = LayerResult(
+                layer_name=layer.name,
+                success=True,
+                data=data,
+                metadata={
+                    "layer_type": layer.layer_type.value,
+                    "model": layer.model_name,
+                    "parameters": layer.parameters
+                },
+                execution_time=execution_time
+            )
+            
+            logger.info(f"Layer {layer.name} completed in {execution_time:.2f}s")
+            return result
+            
+        except Exception as e:
+            execution_time = time.time() - start_time
+            error_msg = str(e)
+            
+            logger.error(f"Layer {layer.name} failed after {execution_time:.2f}s: {error_msg}")
+            
+            result = LayerResult(
+                layer_name=layer.name,
+                success=False,
+                data=None,
+                metadata={
+                    "layer_type": layer.layer_type.value,
+                    "model": layer.model_name,
+                    "parameters": layer.parameters
+                },
+                execution_time=execution_time,
+                error=error_msg
+            )
+            
+            # Try fallback if enabled
+            if layer.fallback_enabled:
+                fallback_result = await self.execute_fallback(layer, context, error_msg)
+                if fallback_result:
+                    result.data = fallback_result
+                    result.success = True
+                    result.error = f"Fallback used: {error_msg}"
+            
+            return result
+    
+    @abstractmethod
+    async def execute_layer_logic(self, layer: LayerConfig, service: Any, context: Dict[str, Any]) -> Any:
+        """Execute the specific logic for a layer - to be implemented by subclasses"""
+        pass
+    
+    async def execute_fallback(self, layer: LayerConfig, context: Dict[str, Any], error: str) -> Optional[Any]:
+        """Execute fallback logic for a failed layer - can be overridden by subclasses"""
+        return None
+    
+    async def invoke(self, input_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Invoke the entire stack of layers"""
+        logger.info(f"Starting {self.service_name} stack invocation")
+        stack_start_time = time.time()
+        
+        # Initialize services if not done
+        if not self.services:
+            await self.initialize_services()
+        
+        # Clear previous results
+        self.results.clear()
+        
+        # Build execution order based on dependencies
+        execution_order = self._build_execution_order()
+        
+        # Execute layers in order
+        context = {"input": input_data, "results": self.results}
+        
+        for layer in execution_order:
+            result = await self.execute_layer(layer, context)
+            self.results[layer.name] = result
+            
+            # Update context with result
+            context["results"] = self.results
+            
+            # Stop if critical layer fails
+            if not result.success and not layer.fallback_enabled:
+                logger.error(f"Critical layer {layer.name} failed, stopping execution")
+                break
+        
+        total_time = time.time() - stack_start_time
+        
+        # Generate final result
+        final_result = {
+            "service": self.service_name,
+            "success": all(r.success for r in self.results.values()),
+            "total_execution_time": total_time,
+            "layer_results": {name: result for name, result in self.results.items()},
+            "final_output": self.generate_final_output(self.results)
+        }
+        
+        logger.info(f"{self.service_name} stack invocation completed in {total_time:.2f}s")
+        return final_result
+    
+    def _build_execution_order(self) -> List[LayerConfig]:
+        """Build execution order based on dependencies"""
+        # Simple topological sort
+        ordered = []
+        remaining = self.layers.copy()
+        
+        while remaining:
+            # Find layers with no unmet dependencies
+            ready = []
+            for layer in remaining:
+                deps_met = all(dep in [l.name for l in ordered] for dep in layer.depends_on)
+                if deps_met:
+                    ready.append(layer)
+            
+            if not ready:
+                raise ValueError("Circular dependency detected in layer configuration")
+            
+            # Add ready layers to order
+            ordered.extend(ready)
+            for layer in ready:
+                remaining.remove(layer)
+        
+        return ordered
+    
+    @abstractmethod
+    def generate_final_output(self, results: Dict[str, LayerResult]) -> Any:
+        """Generate final output from all layer results - to be implemented by subclasses"""
+        pass
+    
+    async def close(self):
+        """Close all services"""
+        for service in self.services.values():
+            if hasattr(service, 'close'):
+                await service.close()
+        self.services.clear()
+        logger.info(f"Closed all services for {self.service_name}")
+    
+    def get_performance_metrics(self) -> Dict[str, Any]:
+        """Get performance metrics for the stack"""
+        if not self.results:
+            return {}
+        
+        metrics = {
+            "total_layers": len(self.results),
+            "successful_layers": sum(1 for r in self.results.values() if r.success),
+            "failed_layers": sum(1 for r in self.results.values() if not r.success),
+            "total_execution_time": sum(r.execution_time for r in self.results.values()),
+            "layer_times": {name: r.execution_time for name, r in self.results.items()},
+            "layer_success": {name: r.success for name, r in self.results.items()}
+        }
+        
+        return metrics

isa_model/inference/services/{vision → img}/replicate_image_gen_service.py

@@ -17,42 +17,41 @@ import replicate
 from PIL import Image
 from io import BytesIO
 
-from isa_model.inference.services.vision.base_image_gen_service import BaseImageGenService
-from isa_model.inference.providers.base_provider import BaseProvider
+from .base_image_gen_service import BaseImageGenService
 
-# 设置日志记录
-logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 class ReplicateImageGenService(BaseImageGenService):
     """
-    Replicate 图像生成服务
+    Replicate 图像生成服务 with unified architecture
     - flux-schnell: 文生图 (t2i) - $3 per 1000 images
     - flux-kontext-pro: 图生图 (i2i) - $0.04 per image
     """
     
-    def __init__(self, provider: BaseProvider, model_name: str):
-        super().__init__(provider, model_name)
+    def __init__(self, provider_name: str, model_name: str, **kwargs):
+        super().__init__(provider_name, model_name, **kwargs)
         
-        # 获取配置
-        provider_config = provider.get_full_config()
-        self.api_token = provider_config.get("api_token") or provider_config.get("replicate_api_token")
+        # Get configuration from centralized config manager
+        provider_config = self.get_provider_config()
         
-        if not self.api_token:
-            raise ValueError("Replicate API token not found in provider configuration")
-        
-        # 设置 API token
-        os.environ["REPLICATE_API_TOKEN"] = self.api_token
-        
-        # 生成图像存储目录
-        self.output_dir = "generated_images"
-        os.makedirs(self.output_dir, exist_ok=True)
-        
-        # 统计信息
-        self.last_generation_count = 0
-        self.total_generation_count = 0
-        
-        logger.info(f"Initialized ReplicateImageGenService with model '{self.model_name}'")
+        try:
+            self.api_token = provider_config.get("api_key") or provider_config.get("replicate_api_token")
+            
+            if not self.api_token:
+                raise ValueError("Replicate API token not found in provider configuration")
+            
+            # Set API token
+            os.environ["REPLICATE_API_TOKEN"] = self.api_token
+            
+            # Statistics
+            self.last_generation_count = 0
+            self.total_generation_count = 0
+            
+            logger.info(f"Initialized ReplicateImageGenService with model '{self.model_name}'")
+            
+        except Exception as e:
+            logger.error(f"Failed to initialize Replicate client: {e}")
+            raise ValueError(f"Failed to initialize Replicate client: {e}") from e
 
     async def generate_image(
         self, 
@@ -133,6 +132,161 @@ class ReplicateImageGenService(BaseImageGenService):
         
         return await self._generate_internal(input_data)
 
+    async def instant_id_generation(
+        self,
+        prompt: str,
+        face_image: Union[str, Any],
+        negative_prompt: Optional[str] = None,
+        num_inference_steps: int = 30,
+        guidance_scale: float = 5.0,
+        seed: Optional[int] = None,
+        identitynet_strength_ratio: float = 0.8,
+        adapter_strength_ratio: float = 0.8
+    ) -> Dict[str, Any]:
+        """InstantID人脸一致性生成"""
+        
+        if "instant-id" in self.model_name:
+            input_data = {
+                "prompt": prompt,
+                "image": face_image,
+                "guidance_scale": guidance_scale,
+                "num_inference_steps": num_inference_steps,
+                "identitynet_strength_ratio": identitynet_strength_ratio,
+                "adapter_strength_ratio": adapter_strength_ratio
+            }
+            
+            if negative_prompt:
+                input_data["negative_prompt"] = negative_prompt
+            if seed:
+                input_data["seed"] = seed
+        else:
+            # 默认InstantID参数
+            input_data = {
+                "prompt": prompt,
+                "face_image": face_image,
+                "negative_prompt": negative_prompt or "",
+                "num_inference_steps": num_inference_steps,
+                "guidance_scale": guidance_scale,
+                "identitynet_strength_ratio": identitynet_strength_ratio,
+                "adapter_strength_ratio": adapter_strength_ratio
+            }
+            
+            if seed:
+                input_data["seed"] = seed
+        
+        return await self._generate_internal(input_data)
+
+    async def consistent_character_generation(
+        self,
+        subject: Union[str, Any],
+        prompt: Optional[str] = None,
+        negative_prompt: Optional[str] = None,
+        number_of_images: int = 4,
+        disable_safety_checker: bool = False
+    ) -> Dict[str, Any]:
+        """一致性角色生成 - 生成同一角色的多种姿态和表情"""
+        
+        if "consistent-character" in self.model_name:
+            input_data = {
+                "subject": subject,
+                "number_of_images": number_of_images,
+                "disable_safety_checker": disable_safety_checker
+            }
+            
+            if prompt:
+                input_data["prompt"] = prompt
+            if negative_prompt:
+                input_data["negative_prompt"] = negative_prompt
+        else:
+            # 默认一致性角色参数
+            input_data = {
+                "subject_image": subject,
+                "prompt": prompt or "portrait, different poses and expressions",
+                "negative_prompt": negative_prompt or "low quality, blurry",
+                "num_images": number_of_images
+            }
+        
+        return await self._generate_internal(input_data)
+
+    async def flux_lora_generation(
+        self,
+        prompt: str,
+        lora_scale: float = 1.0,
+        num_outputs: int = 1,
+        aspect_ratio: str = "1:1",
+        output_format: str = "jpg",
+        guidance_scale: float = 3.5,
+        output_quality: int = 90,
+        num_inference_steps: int = 28,
+        disable_safety_checker: bool = False
+    ) -> Dict[str, Any]:
+        """FLUX LoRA生成 - 使用预训练的LoRA权重"""
+        
+        if any(lora in self.model_name for lora in ["flux-dev-lora", "flux-lora"]):
+            input_data = {
+                "prompt": prompt,
+                "lora_scale": lora_scale,
+                "num_outputs": num_outputs,
+                "aspect_ratio": aspect_ratio,
+                "output_format": output_format,
+                "guidance_scale": guidance_scale,
+                "output_quality": output_quality,
+                "num_inference_steps": num_inference_steps,
+                "disable_safety_checker": disable_safety_checker
+            }
+        else:
+            # 默认LoRA参数
+            input_data = {
+                "prompt": prompt,
+                "lora_strength": lora_scale,
+                "num_images": num_outputs,
+                "guidance_scale": guidance_scale,
+                "num_inference_steps": num_inference_steps
+            }
+        
+        return await self._generate_internal(input_data)
+
+    async def ultimate_upscale(
+        self,
+        image: Union[str, Any],
+        scale: int = 4,
+        scheduler: str = "K_EULER_ANCESTRAL",
+        num_inference_steps: int = 20,
+        guidance_scale: float = 10.0,
+        strength: float = 0.55,
+        hdr: float = 0.0,
+        seed: Optional[int] = None
+    ) -> Dict[str, Any]:
+        """Ultimate SD Upscaler - 专业超分辨率"""
+        
+        if "ultimate" in self.model_name or "upscal" in self.model_name:
+            input_data = {
+                "image": image,
+                "scale": scale,
+                "scheduler": scheduler,
+                "num_inference_steps": num_inference_steps,
+                "guidance_scale": guidance_scale,
+                "strength": strength,
+                "hdr": hdr
+            }
+            
+            if seed:
+                input_data["seed"] = seed
+        else:
+            # 默认超分辨率参数
+            input_data = {
+                "image": image,
+                "upscale_factor": scale,
+                "num_inference_steps": num_inference_steps,
+                "guidance_scale": guidance_scale,
+                "denoising_strength": strength
+            }
+            
+            if seed:
+                input_data["seed"] = seed
+        
+        return await self._generate_internal(input_data)
+
     async def _generate_internal(self, input_data: Dict[str, Any]) -> Dict[str, Any]:
         """内部生成方法"""
         try:
@@ -141,11 +295,19 @@ class ReplicateImageGenService(BaseImageGenService):
             # 调用 Replicate API
             output = await replicate.async_run(self.model_name, input=input_data)
             
-            # 处理输出
+            # 处理输出 - 转换FileOutput对象为URL字符串
             if isinstance(output, list):
-                urls = output
+                raw_urls = output
             else:
-                urls = [output]
+                raw_urls = [output]
+            
+            # 转换为字符串URL
+            urls = []
+            for url in raw_urls:
+                if hasattr(url, 'url'):
+                    urls.append(str(url.url))  # type: ignore
+                else:
+                    urls.append(str(url))
 
             # 更新统计
             self.last_generation_count = len(urls)
@@ -154,25 +316,35 @@ class ReplicateImageGenService(BaseImageGenService):
             # 计算成本
             cost = self._calculate_cost(len(urls))
             
-            # 跟踪计费信息
-            from isa_model.inference.billing_tracker import ServiceType
-            self._track_usage(
-                service_type=ServiceType.IMAGE_GENERATION,
+            # Track billing information
+            await self._track_usage(
+                service_type="image_generation",
                 operation="image_generation",
-                input_units=len(urls),  # 生成的图像数量
+                input_tokens=0,
+                output_tokens=0,
+                input_units=1,  # Input prompt
+                output_units=len(urls),  # Generated images count
                 metadata={
                     "model": self.model_name,
-                    "prompt": input_data.get("prompt", "")[:100],  # 截取前100字符
-                    "generation_type": "t2i" if "flux-schnell" in self.model_name else "i2i"
+                    "prompt": input_data.get("prompt", "")[:100],  # Truncate to 100 chars
+                    "generation_type": "t2i" if "flux-schnell" in self.model_name else "i2i",
+                    "image_count": len(urls),
+                    "cost_usd": cost
                 }
             )
             
+            # Return URLs instead of binary data for HTTP API compatibility
             result = {
-                "urls": urls,
+                "urls": urls,  # Image URLs - primary response
+                "url": urls[0] if urls else None,  # First URL for convenience  
+                "format": "jpg",  # Default format
+                "width": input_data.get("width", 1024),
+                "height": input_data.get("height", 1024),
+                "seed": input_data.get("seed"),
                 "count": len(urls),
                 "cost_usd": cost,
-                "model": self.model_name,
                 "metadata": {
+                    "model": self.model_name,
                     "input": input_data,
                     "generation_count": len(urls)
                 }
@@ -187,7 +359,7 @@ class ReplicateImageGenService(BaseImageGenService):
 
     def _calculate_cost(self, image_count: int) -> float:
         """计算生成成本"""
-        from isa_model.core.model_manager import ModelManager
+        from isa_model.core.models.model_manager import ModelManager
         
         manager = ModelManager()
         
@@ -224,37 +396,6 @@ class ReplicateImageGenService(BaseImageGenService):
             results.append(result)
         return results
 
-    async def generate_image_to_file(
-        self, 
-        prompt: str,
-        output_path: str,
-        negative_prompt: Optional[str] = None,
-        width: int = 512,
-        height: int = 512,
-        num_inference_steps: int = 4,
-        guidance_scale: float = 7.5,
-        seed: Optional[int] = None
-    ) -> Dict[str, Any]:
-        """生成图像并保存到文件"""
-        result = await self.generate_image(
-            prompt, negative_prompt, width, height, 
-            num_inference_steps, guidance_scale, seed
-        )
-        
-        # 保存第一张图像
-        if result.get("urls"):
-            url = result["urls"][0]
-            url_str = str(url) if hasattr(url, "__str__") else url
-            await self._download_image(url_str, output_path)
-            
-            return {
-                "file_path": output_path,
-                "cost_usd": result.get("cost_usd", 0.0),
-                "model": self.model_name
-            }
-        else:
-            raise ValueError("No image generated")
-
     async def _download_image(self, url: str, save_path: str) -> None:
         """下载图像并保存"""
         try:

isa_model/inference/services/llm/__init__.py

@@ -5,10 +5,10 @@ LLM Services - Business logic services for Language Models
 # Import LLM services here when created
 from .ollama_llm_service import OllamaLLMService
 from .openai_llm_service import OpenAILLMService
-from .triton_llm_service import TritonLLMService
+from .yyds_llm_service import YydsLLMService
 
 __all__ = [
     "OllamaLLMService",
-    "OpenAILLMService",
-    "TritonLLMService"
+    "OpenAILLMService", 
+    "YydsLLMService"
 ]