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

isa_model/inference/services/helpers/stacked_config.py

@@ -0,0 +1,148 @@
+"""
+Configuration system for stacked services
+"""
+
+from typing import Dict, Any, List, Optional
+from dataclasses import dataclass, field
+from enum import Enum
+
+# Define stacked service specific layer types
+class StackedLayerType(Enum):
+    """Types of processing layers for stacked services"""
+    INTELLIGENCE = "intelligence"      # High-level understanding
+    DETECTION = "detection"           # Element/object detection  
+    CLASSIFICATION = "classification" # Detailed classification
+    VALIDATION = "validation"         # Result validation
+    TRANSFORMATION = "transformation" # Data transformation
+    GENERATION = "generation"         # Content generation
+    ENHANCEMENT = "enhancement"       # Quality enhancement
+    CONTROL = "control"              # Precise control/refinement
+    UPSCALING = "upscaling"          # Resolution enhancement
+
+@dataclass
+class LayerConfig:
+    """Configuration for a processing layer"""
+    name: str
+    layer_type: StackedLayerType
+    service_type: str                  # e.g., 'vision', 'llm'
+    model_name: str
+    parameters: Dict[str, Any]
+    depends_on: List[str]             # Layer dependencies
+    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
+
+class WorkflowType(Enum):
+    """Predefined workflow types"""
+    UI_ANALYSIS_FAST = "ui_analysis_fast"
+    UI_ANALYSIS_ACCURATE = "ui_analysis_accurate"
+    UI_ANALYSIS_COMPREHENSIVE = "ui_analysis_comprehensive"
+    SEARCH_PAGE_ANALYSIS = "search_page_analysis"
+    CONTENT_EXTRACTION = "content_extraction"
+    FORM_INTERACTION = "form_interaction"
+    NAVIGATION_ANALYSIS = "navigation_analysis"
+    CUSTOM = "custom"
+
+@dataclass
+class StackedServiceConfig:
+    """Configuration for a stacked service workflow"""
+    name: str
+    workflow_type: WorkflowType
+    layers: List[LayerConfig] = field(default_factory=list)
+    global_timeout: float = 120.0
+    parallel_execution: bool = False
+    fail_fast: bool = False
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+class ConfigManager:
+    """Manager for stacked service configurations"""
+    
+    PREDEFINED_CONFIGS = {
+        WorkflowType.UI_ANALYSIS_FAST: {
+            "name": "Fast UI Analysis",
+            "layers": [
+                LayerConfig(
+                    name="page_intelligence",
+                    layer_type=StackedLayerType.INTELLIGENCE,
+                    service_type="vision",
+                    model_name="gpt-4.1-nano",
+                    parameters={"max_tokens": 300},
+                    depends_on=[],
+                    timeout=10.0,
+                    fallback_enabled=True
+                ),
+                LayerConfig(
+                    name="element_detection",
+                    layer_type=StackedLayerType.DETECTION,
+                    service_type="vision",
+                    model_name="omniparser",
+                    parameters={
+                        "imgsz": 480,
+                        "box_threshold": 0.08,
+                        "iou_threshold": 0.2
+                    },
+                    depends_on=["page_intelligence"],
+                    timeout=15.0,
+                    fallback_enabled=True
+                ),
+                LayerConfig(
+                    name="element_classification",
+                    layer_type=StackedLayerType.CLASSIFICATION,
+                    service_type="vision",
+                    model_name="gpt-4.1-nano",
+                    parameters={"max_tokens": 200},
+                    depends_on=["page_intelligence", "element_detection"],
+                    timeout=20.0,
+                    fallback_enabled=False
+                )
+            ],
+            "global_timeout": 60.0,
+            "parallel_execution": False,
+            "fail_fast": False,
+            "metadata": {
+                "description": "Fast UI analysis optimized for speed",
+                "expected_time": "30-45 seconds",
+                "accuracy": "medium"
+            }
+        }
+    }
+    
+    @classmethod
+    def get_config(cls, workflow_type: WorkflowType) -> StackedServiceConfig:
+        """Get predefined configuration for a workflow type"""
+        if workflow_type not in cls.PREDEFINED_CONFIGS:
+            raise ValueError(f"Unknown workflow type: {workflow_type}")
+        
+        config_data = cls.PREDEFINED_CONFIGS[workflow_type]
+        
+        return StackedServiceConfig(
+            name=config_data["name"],
+            workflow_type=workflow_type,
+            layers=config_data["layers"],
+            global_timeout=config_data["global_timeout"],
+            parallel_execution=config_data["parallel_execution"],
+            fail_fast=config_data["fail_fast"],
+            metadata=config_data["metadata"]
+        )
+
+# Convenience function for quick access
+def get_ui_analysis_config(speed: str = "accurate") -> StackedServiceConfig:
+    """Get UI analysis configuration by speed preference"""
+    speed_mapping = {
+        "fast": WorkflowType.UI_ANALYSIS_FAST,
+        "accurate": WorkflowType.UI_ANALYSIS_ACCURATE,
+        "comprehensive": WorkflowType.UI_ANALYSIS_COMPREHENSIVE
+    }
+    
+    workflow_type = speed_mapping.get(speed.lower(), WorkflowType.UI_ANALYSIS_ACCURATE)
+    return ConfigManager.get_config(workflow_type)

isa_model/inference/services/img/__init__.py

@@ -0,0 +1,18 @@
+"""
+Image Generation Services
+
+This module contains services for image generation, separate from vision understanding.
+Including stacked services for complex image generation pipelines.
+"""
+
+from .base_image_gen_service import BaseImageGenService
+from .replicate_image_gen_service import ReplicateImageGenService
+
+# Stacked Image Generation Services  
+from .flux_professional_service import FluxProfessionalService
+
+__all__ = [
+    'BaseImageGenService',
+    'ReplicateImageGenService',
+    'FluxProfessionalService'
+]

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

@@ -3,7 +3,86 @@ from typing import Dict, Any, List, Union, Optional, BinaryIO
 from isa_model.inference.services.base_service import BaseService
 
 class BaseImageGenService(BaseService):
-    """Base class for image generation services"""
+    """Base class for image generation services with unified task dispatch"""
+    
+    async def invoke(
+        self, 
+        prompt: str,
+        task: Optional[str] = None,
+        **kwargs
+    ) -> Union[Dict[str, Any], List[Dict[str, Any]]]:
+        """
+        统一的任务分发方法 - Base类提供通用实现
+        
+        Args:
+            prompt: 文本提示词
+            task: 任务类型，支持多种图像生成任务
+            **kwargs: 任务特定的附加参数
+            
+        Returns:
+            Dict or List[Dict] containing generation results
+        """
+        task = task or "generate"
+        
+        # ==================== 图像生成类任务 ====================
+        if task == "generate":
+            num_images = kwargs.get("num_images", 1)
+            if num_images == 1:
+                return await self.generate_image(
+                    prompt,
+                    kwargs.get("negative_prompt"),
+                    kwargs.get("width", 512),
+                    kwargs.get("height", 512),
+                    kwargs.get("num_inference_steps", 20),
+                    kwargs.get("guidance_scale", 7.5),
+                    kwargs.get("seed")
+                )
+            else:
+                return await self.generate_images(
+                    prompt,
+                    num_images,
+                    kwargs.get("negative_prompt"),
+                    kwargs.get("width", 512),
+                    kwargs.get("height", 512),
+                    kwargs.get("num_inference_steps", 20),
+                    kwargs.get("guidance_scale", 7.5),
+                    kwargs.get("seed")
+                )
+        elif task == "generate_batch":
+            return await self.generate_images(
+                prompt,
+                kwargs.get("num_images", 4),
+                kwargs.get("negative_prompt"),
+                kwargs.get("width", 512),
+                kwargs.get("height", 512),
+                kwargs.get("num_inference_steps", 20),
+                kwargs.get("guidance_scale", 7.5),
+                kwargs.get("seed")
+            )
+        elif task == "img2img":
+            init_image = kwargs.get("init_image")
+            if not init_image:
+                raise ValueError("img2img task requires init_image parameter")
+            return await self.image_to_image(
+                prompt,
+                init_image,
+                kwargs.get("strength", 0.8),
+                kwargs.get("negative_prompt"),
+                kwargs.get("num_inference_steps", 20),
+                kwargs.get("guidance_scale", 7.5),
+                kwargs.get("seed")
+            )
+        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 ["generate", "generate_batch", "img2img"]
     
     @abstractmethod
     async def generate_image(

isa_model/inference/services/{stacked → img}/flux_professional_service.py

@@ -10,7 +10,7 @@ import io
 from typing import Dict, Any, List, Optional
 from PIL import Image
 
-from .base_stacked_service import BaseStackedService, LayerConfig, LayerType, LayerResult
+from .helpers.base_stacked_service import BaseStackedService, LayerConfig, LayerType, LayerResult
 
 logger = logging.getLogger(__name__)
 
@@ -571,6 +571,30 @@ class FluxProfessionalService(BaseStackedService):
         
         return None
     
+    def generate_final_output(self, results: Dict[str, LayerResult]) -> Any:
+        """Generate final output from all layer results"""
+        # Get the best available result
+        final_result = None
+        for layer_name in ["ultimate_upscaling", "detail_enhancement", "lora_style_application", "controlnet_refinement", "flux_base_generation"]:
+            if layer_name in results and results[layer_name].success:
+                final_result = results[layer_name]
+                break
+        
+        if final_result:
+            return {
+                "success": True,
+                "final_image": final_result.data,
+                "pipeline_stages": list(results.keys()),
+                "successful_stages": [name for name, result in results.items() if result.success]
+            }
+        else:
+            return {
+                "success": False,
+                "error": "No successful pipeline stages",
+                "pipeline_stages": list(results.keys()),
+                "failed_stages": [name for name, result in results.items() if not result.success]
+            }
+    
     async def close(self):
         """Clean up services"""
         for service in self.services.values():

isa_model/inference/services/{stacked → img/helpers}/base_stacked_service.py

@@ -10,42 +10,47 @@ import logging
 from dataclasses import dataclass
 from enum import Enum
 
-logger = logging.getLogger(__name__)
-
-class LayerType(Enum):
-    """Types of processing layers"""
-    INTELLIGENCE = "intelligence"      # High-level understanding
-    DETECTION = "detection"           # Element/object detection  
-    CLASSIFICATION = "classification" # Detailed classification
-    VALIDATION = "validation"         # Result validation
-    TRANSFORMATION = "transformation" # Data transformation
-    GENERATION = "generation"         # Content generation
-    ENHANCEMENT = "enhancement"       # Quality enhancement
-    CONTROL = "control"              # Precise control/refinement
-    UPSCALING = "upscaling"          # Resolution enhancement
-
-@dataclass
-class LayerConfig:
-    """Configuration for a processing layer"""
-    name: str
-    layer_type: LayerType
-    service_type: str                  # e.g., 'vision', 'llm'
-    model_name: str
-    parameters: Dict[str, Any]
-    depends_on: List[str]             # Layer dependencies
-    timeout: float = 30.0
-    retry_count: int = 1
-    fallback_enabled: bool = True
+# 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
 
-@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):
     """

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

@@ -17,38 +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.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, 
@@ -313,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)
                 }
@@ -346,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()
         

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"
 ]