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

isa_model/inference/services/stacked/config.py

@@ -1,426 +0,0 @@
-"""
-Configuration system for stacked services
-"""
-
-from typing import Dict, Any, List
-from dataclasses import dataclass, field
-from enum import Enum
-
-from .base_stacked_service import LayerConfig, LayerType
-
-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=LayerType.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=LayerType.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=LayerType.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"
-            }
-        },
-        
-        WorkflowType.UI_ANALYSIS_ACCURATE: {
-            "name": "Accurate UI Analysis",
-            "layers": [
-                LayerConfig(
-                    name="page_intelligence",
-                    layer_type=LayerType.INTELLIGENCE,
-                    service_type="vision",
-                    model_name="gpt-4-vision-preview",
-                    parameters={"max_tokens": 800},
-                    depends_on=[],
-                    timeout=20.0,
-                    fallback_enabled=True
-                ),
-                LayerConfig(
-                    name="element_detection",
-                    layer_type=LayerType.DETECTION,
-                    service_type="vision",
-                    model_name="omniparser",
-                    parameters={
-                        "imgsz": 640,
-                        "box_threshold": 0.05,
-                        "iou_threshold": 0.1
-                    },
-                    depends_on=["page_intelligence"],
-                    timeout=25.0,
-                    fallback_enabled=True
-                ),
-                LayerConfig(
-                    name="element_classification",
-                    layer_type=LayerType.CLASSIFICATION,
-                    service_type="vision",
-                    model_name="gpt-4-vision-preview",
-                    parameters={"max_tokens": 500},
-                    depends_on=["page_intelligence", "element_detection"],
-                    timeout=30.0,
-                    fallback_enabled=False
-                )
-            ],
-            "global_timeout": 90.0,
-            "parallel_execution": False,
-            "fail_fast": False,
-            "metadata": {
-                "description": "Balanced UI analysis for production use",
-                "expected_time": "60-75 seconds",
-                "accuracy": "high"
-            }
-        },
-        
-        WorkflowType.SEARCH_PAGE_ANALYSIS: {
-            "name": "Search Page Analysis",
-            "layers": [
-                LayerConfig(
-                    name="page_intelligence",
-                    layer_type=LayerType.INTELLIGENCE,
-                    service_type="vision",
-                    model_name="default",
-                    parameters={
-                        "task": "search_page_intelligence",
-                        "max_tokens": 400
-                    },
-                    depends_on=[],
-                    timeout=15.0,
-                    fallback_enabled=True
-                ),
-                LayerConfig(
-                    name="element_detection",
-                    layer_type=LayerType.DETECTION,
-                    service_type="vision",
-                    model_name="omniparser",
-                    parameters={
-                        "task": "element_detection",
-                        "imgsz": 640,
-                        "box_threshold": 0.05,
-                        "iou_threshold": 0.1
-                    },
-                    depends_on=["page_intelligence"],
-                    timeout=20.0,
-                    fallback_enabled=True
-                ),
-                LayerConfig(
-                    name="element_classification",
-                    layer_type=LayerType.CLASSIFICATION,
-                    service_type="vision",
-                    model_name="default",
-                    parameters={
-                        "task": "search_element_classification",
-                        "max_tokens": 300
-                    },
-                    depends_on=["page_intelligence", "element_detection"],
-                    timeout=25.0,
-                    fallback_enabled=False
-                )
-            ],
-            "global_timeout": 80.0,
-            "parallel_execution": False,
-            "fail_fast": False,
-            "metadata": {
-                "description": "Analysis for search pages (Google, Bing, etc.)",
-                "expected_time": "45-60 seconds",
-                "accuracy": "high",
-                "page_types": ["search", "query", "results"]
-            }
-        },
-        
-        WorkflowType.CONTENT_EXTRACTION: {
-            "name": "Content Extraction",
-            "layers": [
-                LayerConfig(
-                    name="page_intelligence",
-                    layer_type=LayerType.INTELLIGENCE,
-                    service_type="vision",
-                    model_name="default",
-                    parameters={
-                        "task": "content_page_intelligence",
-                        "max_tokens": 500
-                    },
-                    depends_on=[],
-                    timeout=15.0,
-                    fallback_enabled=True
-                ),
-                LayerConfig(
-                    name="content_detection",
-                    layer_type=LayerType.DETECTION,
-                    service_type="vision",
-                    model_name="florence-2",
-                    parameters={
-                        "task": "<OPEN_VOCABULARY_DETECTION>",
-                        "text_input": "article content, text blocks, headings, paragraphs, links"
-                    },
-                    depends_on=["page_intelligence"],
-                    timeout=25.0,
-                    fallback_enabled=True
-                ),
-                LayerConfig(
-                    name="content_classification",
-                    layer_type=LayerType.CLASSIFICATION,
-                    service_type="vision",
-                    model_name="default",
-                    parameters={
-                        "task": "content_classification",
-                        "max_tokens": 400
-                    },
-                    depends_on=["page_intelligence", "content_detection"],
-                    timeout=30.0,
-                    fallback_enabled=False
-                )
-            ],
-            "global_timeout": 90.0,
-            "parallel_execution": False,
-            "fail_fast": False,
-            "metadata": {
-                "description": "Extract and analyze content from web pages",
-                "expected_time": "60-75 seconds",
-                "accuracy": "high",
-                "page_types": ["article", "blog", "news", "documentation"]
-            }
-        },
-        
-        WorkflowType.UI_ANALYSIS_COMPREHENSIVE: {
-            "name": "Comprehensive UI Analysis",
-            "layers": [
-                LayerConfig(
-                    name="page_intelligence",
-                    layer_type=LayerType.INTELLIGENCE,
-                    service_type="vision",
-                    model_name="gpt-4-vision-preview",
-                    parameters={"max_tokens": 1000},
-                    depends_on=[],
-                    timeout=25.0,
-                    fallback_enabled=True
-                ),
-                LayerConfig(
-                    name="primary_detection",
-                    layer_type=LayerType.DETECTION,
-                    service_type="vision",
-                    model_name="omniparser",
-                    parameters={
-                        "imgsz": 1024,
-                        "box_threshold": 0.03,
-                        "iou_threshold": 0.1
-                    },
-                    depends_on=["page_intelligence"],
-                    timeout=30.0,
-                    fallback_enabled=True
-                ),
-                LayerConfig(
-                    name="secondary_detection",
-                    layer_type=LayerType.DETECTION,
-                    service_type="vision",
-                    model_name="florence-2",
-                    parameters={
-                        "task": "<OPEN_VOCABULARY_DETECTION>",
-                        "text_input": "login form elements, input fields, buttons, checkboxes"
-                    },
-                    depends_on=["page_intelligence"],
-                    timeout=25.0,
-                    fallback_enabled=True
-                ),
-                LayerConfig(
-                    name="detection_fusion",
-                    layer_type=LayerType.TRANSFORMATION,
-                    service_type="custom",
-                    model_name="fusion_algorithm",
-                    parameters={"fusion_method": "confidence_weighted"},
-                    depends_on=["primary_detection", "secondary_detection"],
-                    timeout=5.0,
-                    fallback_enabled=False
-                ),
-                LayerConfig(
-                    name="element_classification",
-                    layer_type=LayerType.CLASSIFICATION,
-                    service_type="vision",
-                    model_name="gpt-4-vision-preview",
-                    parameters={"max_tokens": 600},
-                    depends_on=["page_intelligence", "detection_fusion"],
-                    timeout=40.0,
-                    fallback_enabled=False
-                ),
-                LayerConfig(
-                    name="result_validation",
-                    layer_type=LayerType.VALIDATION,
-                    service_type="vision",
-                    model_name="gpt-4.1-nano",
-                    parameters={"validation_criteria": ["completeness", "consistency", "accuracy"]},
-                    depends_on=["element_classification"],
-                    timeout=15.0,
-                    fallback_enabled=True
-                )
-            ],
-            "global_timeout": 180.0,
-            "parallel_execution": True,  # Enable parallel execution for detection layers
-            "fail_fast": False,
-            "metadata": {
-                "description": "Most comprehensive UI analysis with multi-model fusion",
-                "expected_time": "120-150 seconds",
-                "accuracy": "very high"
-            }
-        }
-    }
-    
-    @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"]
-        )
-    
-    @classmethod
-    def create_custom_config(
-        cls,
-        name: str,
-        layers: List[LayerConfig],
-        global_timeout: float = 120.0,
-        parallel_execution: bool = False,
-        fail_fast: bool = False,
-        metadata: Dict[str, Any] = None
-    ) -> StackedServiceConfig:
-        """Create a custom configuration"""
-        return StackedServiceConfig(
-            name=name,
-            workflow_type=WorkflowType.CUSTOM,
-            layers=layers,
-            global_timeout=global_timeout,
-            parallel_execution=parallel_execution,
-            fail_fast=fail_fast,
-            metadata=metadata or {}
-        )
-    
-    @classmethod
-    def modify_config(
-        cls,
-        base_config: StackedServiceConfig,
-        modifications: Dict[str, Any]
-    ) -> StackedServiceConfig:
-        """Modify an existing configuration"""
-        # Create a copy
-        new_config = StackedServiceConfig(
-            name=base_config.name,
-            workflow_type=base_config.workflow_type,
-            layers=base_config.layers.copy(),
-            global_timeout=base_config.global_timeout,
-            parallel_execution=base_config.parallel_execution,
-            fail_fast=base_config.fail_fast,
-            metadata=base_config.metadata.copy()
-        )
-        
-        # Apply modifications
-        for key, value in modifications.items():
-            if hasattr(new_config, key):
-                setattr(new_config, key, value)
-            elif key == "layer_modifications":
-                # Modify specific layers
-                for layer_name, layer_mods in value.items():
-                    for layer in new_config.layers:
-                        if layer.name == layer_name:
-                            for mod_key, mod_value in layer_mods.items():
-                                if hasattr(layer, mod_key):
-                                    setattr(layer, mod_key, mod_value)
-                                elif mod_key == "parameters":
-                                    layer.parameters.update(mod_value)
-        
-        return new_config
-    
-    @classmethod
-    def get_available_workflows(cls) -> Dict[WorkflowType, Dict[str, Any]]:
-        """Get information about all available workflows"""
-        workflows = {}
-        
-        for workflow_type in cls.PREDEFINED_CONFIGS:
-            config_data = cls.PREDEFINED_CONFIGS[workflow_type]
-            workflows[workflow_type] = {
-                "name": config_data["name"],
-                "layer_count": len(config_data["layers"]),
-                "expected_time": config_data["metadata"].get("expected_time", "unknown"),
-                "accuracy": config_data["metadata"].get("accuracy", "unknown"),
-                "description": config_data["metadata"].get("description", "")
-            }
-        
-        return workflows
-
-# 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/vision/ollama_vision_service.py

@@ -1,194 +0,0 @@
-import os
-import json
-import base64
-import ollama
-from typing import Dict, Any, Union, List, Optional, BinaryIO
-from tenacity import retry, stop_after_attempt, wait_exponential
-from isa_model.inference.services.vision.base_vision_service import BaseVisionService
-from isa_model.inference.providers.base_provider import BaseProvider
-import logging
-import requests
-
-logger = logging.getLogger(__name__)
-
-class OllamaVisionService(BaseVisionService):
-    """Vision model service wrapper for Ollama using base64 encoded images"""
-    
-    def __init__(self, provider: 'BaseProvider', model_name: str = 'gemma3:4b'):
-        super().__init__(provider, model_name)
-        self.max_tokens = self.config.get('max_tokens', 1000)
-        self.temperature = self.config.get('temperature', 0.7)
-    
-    def _get_image_data(self, image: Union[str, BinaryIO]) -> bytes:
-        """获取图像数据，支持本地文件和URL"""
-        if isinstance(image, str):
-            # Check if it's a URL
-            if image.startswith(('http://', 'https://')):
-                response = requests.get(image)
-                response.raise_for_status()
-                return response.content
-            else:
-                # Local file path
-                with open(image, 'rb') as f:
-                    return f.read()
-        else:
-            return image.read()
-
-    @retry(
-        stop=stop_after_attempt(3),
-        wait=wait_exponential(multiplier=1, min=4, max=10),
-        reraise=True
-    )
-    async def analyze_image(
-        self, 
-        image: Union[str, BinaryIO],
-        prompt: Optional[str] = None,
-        max_tokens: int = 1000
-    ) -> Dict[str, Any]:
-        """
-        Analyze image and provide description or answer questions
-        """
-        try:
-            # 获取图像数据
-            image_data = self._get_image_data(image)
-            
-            # 转换为base64
-            image_base64 = base64.b64encode(image_data).decode('utf-8')
-            
-            # 使用默认提示词如果没有提供
-            query = prompt or "请描述这张图片的内容。"
-            
-            # 使用 ollama 库直接调用
-            response = ollama.chat(
-                model=self.model_name,
-                messages=[{
-                    'role': 'user',
-                    'content': query,
-                    'images': [image_base64]
-                }]
-            )
-            
-            content = response['message']['content']
-            
-            return {
-                "text": content,
-                "confidence": 1.0,  # Ollama doesn't provide confidence scores
-                "detected_objects": [],  # Basic implementation
-                "metadata": {
-                    "model": self.model_name,
-                    "prompt": query
-                }
-            }
-            
-        except Exception as e:
-            logger.error(f"Error in image analysis: {e}")
-            raise
-
-    async def analyze_images(
-        self, 
-        images: List[Union[str, BinaryIO]],
-        prompt: Optional[str] = None,
-        max_tokens: int = 1000
-    ) -> List[Dict[str, Any]]:
-        """Analyze multiple images"""
-        results = []
-        for image in images:
-            result = await self.analyze_image(image, prompt, max_tokens)
-            results.append(result)
-        return results
-
-    async def describe_image(
-        self, 
-        image: Union[str, BinaryIO],
-        detail_level: str = "medium"
-    ) -> Dict[str, Any]:
-        """Generate detailed description of image"""
-        prompts = {
-            "low": "简单描述这张图片。",
-            "medium": "详细描述这张图片的内容、颜色、物体和场景。",
-            "high": "非常详细地描述这张图片，包括所有可见的物体、颜色、纹理、场景、情感和任何其他细节。"
-        }
-        
-        prompt = prompts.get(detail_level, prompts["medium"])
-        result = await self.analyze_image(image, prompt)
-        
-        return {
-            "description": result["text"],
-            "objects": [],  # Basic implementation
-            "scene": "未知",  # Basic implementation
-            "colors": []  # Basic implementation
-        }
-
-    async def extract_text(self, image: Union[str, BinaryIO]) -> Dict[str, Any]:
-        """Extract text from image (OCR)"""
-        result = await self.analyze_image(image, "提取图片中的所有文字内容。")
-        
-        return {
-            "text": result["text"],
-            "confidence": 1.0,
-            "bounding_boxes": [],  # Basic implementation
-            "language": "未知"  # Basic implementation
-        }
-
-    async def detect_objects(
-        self, 
-        image: Union[str, BinaryIO],
-        confidence_threshold: float = 0.5
-    ) -> Dict[str, Any]:
-        """Detect objects in image"""
-        result = await self.analyze_image(image, "识别并列出图片中的所有物体。")
-        
-        return {
-            "objects": [],  # Basic implementation - would need parsing
-            "count": 0,
-            "bounding_boxes": []
-        }
-
-    async def classify_image(
-        self, 
-        image: Union[str, BinaryIO],
-        categories: Optional[List[str]] = None
-    ) -> Dict[str, Any]:
-        """Classify image into categories"""
-        if categories:
-            category_str = "、".join(categories)
-            prompt = f"将这张图片分类到以下类别之一：{category_str}"
-        else:
-            prompt = "这张图片属于什么类别？"
-            
-        result = await self.analyze_image(image, prompt)
-        
-        return {
-            "category": result["text"],
-            "confidence": 1.0,
-            "all_predictions": [{"category": result["text"], "confidence": 1.0}]
-        }
-
-    async def compare_images(
-        self, 
-        image1: Union[str, BinaryIO],
-        image2: Union[str, BinaryIO]
-    ) -> Dict[str, Any]:
-        """Compare two images for similarity"""
-        # For now, analyze each image separately and compare descriptions
-        result1 = await self.analyze_image(image1, "描述这张图片。")
-        result2 = await self.analyze_image(image2, "描述这张图片。")
-        
-        return {
-            "similarity_score": 0.5,  # Basic implementation
-            "differences": "需要进一步分析",
-            "common_elements": "需要进一步分析"
-        }
-
-    def get_supported_formats(self) -> List[str]:
-        """Get list of supported image formats"""
-        return ['jpg', 'jpeg', 'png', 'gif', 'bmp', 'webp']
-
-    def get_max_image_size(self) -> Dict[str, int]:
-        """Get maximum supported image dimensions"""
-        return {"width": 4096, "height": 4096}
-
-    async def close(self):
-        """Cleanup resources"""
-        pass
-