isa-model 0.3.91__py3-none-any.whl → 0.4.3__py3-none-any.whl

isa_model/inference/services/llm/yyds_llm_service.py

@@ -63,16 +63,19 @@ class YydsLLMService(BaseLLMService):
         
         return bound_service
     
-    async def astream(self, input_data: Union[str, List[Dict[str, str]], Any]) -> AsyncGenerator[str, None]:
+    async def astream(self, input_data: Union[str, List[Dict[str, str]], Any], **kwargs) -> AsyncGenerator[str, None]:
         """
         True streaming method - yields tokens one by one as they arrive
         
         Args:
             input_data: Same as ainvoke
+            **kwargs: Additional parameters (will filter out unsupported ones)
             
         Yields:
             Individual tokens as they arrive from the API
         """
+        # Remove parameters that yyds doesn't support
+        kwargs.pop('show_reasoning', None)  # OpenAI-specific parameter
         try:
             # Use adapter manager to prepare messages
             messages = self._prepare_messages(input_data)
@@ -115,8 +118,11 @@ class YydsLLMService(BaseLLMService):
             logger.error(f"Error in astream: {e}")
             raise
     
-    async def ainvoke(self, input_data: Union[str, List[Dict[str, str]], Any]) -> Union[str, Any]:
+    async def ainvoke(self, input_data: Union[str, List[Dict[str, str]], Any], **kwargs) -> Union[str, Any]:
         """Unified invoke method for all input types"""
+        # Remove parameters that yyds doesn't support
+        kwargs.pop('show_reasoning', None)  # OpenAI-specific parameter
+        kwargs.pop('task', None)  # Handled internally
         try:
             # Use adapter manager to prepare messages
             messages = self._prepare_messages(input_data)
@@ -252,7 +258,8 @@ class YydsLLMService(BaseLLMService):
     async def chat(
         self,
         input_data: Union[str, List[Dict[str, str]], Any],
-        max_tokens: Optional[int] = None
+        max_tokens: Optional[int] = None,
+        show_reasoning: bool = False
     ) -> Dict[str, Any]:
         """
         Chat method that wraps ainvoke for compatibility with base class

isa_model/inference/services/vision/__init__.py

@@ -11,9 +11,9 @@ from .base_vision_service import BaseVisionService
 from .openai_vision_service import OpenAIVisionService
 from .replicate_vision_service import ReplicateVisionService
 
-# Stacked Vision Services
-from .doc_analysis_service import DocAnalysisStackedService
-from .ui_analysis_service import UIAnalysisService
+# Stacked Vision Services (disabled - files don't exist)
+# from .doc_analysis_service import DocAnalysisStackedService
+# from .ui_analysis_service import UIAnalysisService
 
 # ISA Vision service
 try:
@@ -31,16 +31,37 @@ except ImportError:
     OllamaVisionService = None
     OLLAMA_VISION_AVAILABLE = False
 
+# Computer Vision specialized services
+try:
+    from .vgg16_vision_service import VGG16VisionService
+    VGG16_VISION_AVAILABLE = True
+except ImportError:
+    VGG16VisionService = None
+    VGG16_VISION_AVAILABLE = False
+
+try:
+    from .blip_vision_service import BLIPVisionService
+    BLIP_VISION_AVAILABLE = True
+except ImportError:
+    BLIPVisionService = None
+    BLIP_VISION_AVAILABLE = False
+
 __all__ = [
     "BaseVisionService",
     "OpenAIVisionService", 
     "ReplicateVisionService",
-    "DocAnalysisStackedService",
-    "UIAnalysisService"
+    # "DocAnalysisStackedService",  # Disabled - file doesn't exist
+    # "UIAnalysisService"           # Disabled - file doesn't exist
 ]
 
 if ISA_VISION_AVAILABLE:
     __all__.append("ISAVisionService")
 
 if OLLAMA_VISION_AVAILABLE:
-    __all__.append("OllamaVisionService") 
+    __all__.append("OllamaVisionService")
+
+if VGG16_VISION_AVAILABLE:
+    __all__.append("VGG16VisionService")
+
+if BLIP_VISION_AVAILABLE:
+    __all__.append("BLIPVisionService") 

isa_model/inference/services/vision/base_vision_service.py

@@ -21,43 +21,61 @@ class BaseVisionService(BaseService):
         **kwargs
     ) -> Dict[str, Any]:
         """
-        统一的任务分发方法 - Base类提供通用实现
+        统一的任务分发方法 - 基于6个核心任务的设计
         
         Args:
             image: Path to image file or image data
             prompt: Optional text prompt/question about the image
-            task: Task type - 支持两大类：图像理解 + 检测抽取
-            **kwargs: Additional task-specific parameters
+            task: Core task type (analyze, describe, extract, detect, classify, compare)
+            **kwargs: Additional task-specific parameters including:
+                - target: Sub-task specification (e.g., "text"/"table" for extract, "objects"/"ui" for detect)
+                - max_tokens: Maximum tokens for text generation
+                - confidence_threshold: Confidence threshold for detection
+                - categories: Categories for classification
+                - image2: Second image for comparison
             
         Returns:
             Dict containing task results
         """
         task = task or "analyze"
         
-        # ==================== 图像理解类任务 ====================
-        if task == "analyze":
+        # Core task dispatch with parameterized sub-tasks
+        if task == "analyze" and hasattr(self, 'analyze_image'):
             return await self.analyze_image(image, prompt, kwargs.get("max_tokens", 1000))
-        elif task == "describe":
+            
+        elif task == "describe" and hasattr(self, 'describe_image'):
             return await self.describe_image(image, kwargs.get("detail_level", "medium"))
-        elif task == "classify":
+            
+        elif task == "extract":
+            # Extract with target specification
+            target = kwargs.get("target", "text")
+            if target == "table" and hasattr(self, 'extract_table_data'):
+                return await self.extract_table_data(image, kwargs.get("table_format", "json"))
+            elif hasattr(self, 'extract_text'):
+                return await self.extract_text(image)
+            else:
+                raise NotImplementedError(f"{self.__class__.__name__} does not support extract task")
+                
+        elif task == "detect":
+            # Detect with target specification
+            target = kwargs.get("target", "objects")
+            if target == "ui" and hasattr(self, 'detect_ui_elements'):
+                return await self.detect_ui_elements(image, 
+                    kwargs.get("element_types"), 
+                    kwargs.get("confidence_threshold", 0.5))
+            elif target == "coordinates" and hasattr(self, 'get_object_coordinates'):
+                return await self.get_object_coordinates(image, kwargs.get("object_name", ""))
+            elif hasattr(self, 'detect_objects'):
+                return await self.detect_objects(image, kwargs.get("confidence_threshold", 0.5))
+            else:
+                raise NotImplementedError(f"{self.__class__.__name__} does not support detect task")
+                
+        elif task == "classify" and hasattr(self, 'classify_image'):
             return await self.classify_image(image, kwargs.get("categories"))
-        elif task == "compare":
+            
+        elif task == "compare" and hasattr(self, 'compare_images'):
             return await self.compare_images(image, kwargs.get("image2"))
-        
-        # ==================== 检测抽取类任务 ====================
-        elif task == "extract_text":
-            return await self.extract_text(image)
-        elif task == "detect_objects":
-            return await self.detect_objects(image, kwargs.get("confidence_threshold", 0.5))
-        elif task == "detect_ui_elements":
-            return await self.detect_ui_elements(image, kwargs.get("element_types"), kwargs.get("confidence_threshold", 0.5))
-        elif task == "detect_document_elements":
-            return await self.detect_document_elements(image, kwargs.get("element_types"), kwargs.get("confidence_threshold", 0.5))
-        elif task == "extract_table_data":
-            return await self.extract_table_data(image, kwargs.get("table_format", "json"), kwargs.get("preserve_formatting", True))
-        elif task == "get_coordinates":
-            return await self.get_object_coordinates(image, kwargs.get("object_name", ""))
-        
+            
         else:
             raise NotImplementedError(f"{self.__class__.__name__} does not support task: {task}")
     
@@ -83,40 +101,84 @@ class BaseVisionService(BaseService):
             - metadata: Additional metadata about the analysis
         """
         raise NotImplementedError(f"{self.__class__.__name__} does not support analyze_image task")
+
     
-    # ==================== 图像理解类方法 ====================
     
-    async def describe_image(
-        self, 
-        image: Union[str, BinaryIO],
-        detail_level: str = "medium"
-    ) -> Dict[str, Any]:
+    
+    async def close(self):
+        """Cleanup resources - default implementation does nothing"""
+        pass
+    
+    def get_supported_tasks(self) -> List[str]:
         """
-        图像描述 - Provider可选实现
+        获取provider支持的核心任务列表
+        
+        Returns:
+            List of core task names (analyze, describe, extract, detect, classify, compare)
         """
-        raise NotImplementedError(f"{self.__class__.__name__} does not support describe_image task")
+        supported = []
+        
+        # Check core task support based on implemented methods
+        task_method_map = {
+            'analyze': 'analyze_image',
+            'describe': 'describe_image',
+            'extract': 'extract_text',  # Basic extract support
+            'detect': 'detect_objects',  # Basic detect support
+            'classify': 'classify_image',
+            'compare': 'compare_images'
+        }
+        
+        for task_name, method_name in task_method_map.items():
+            if hasattr(self, method_name):
+                try:
+                    # Check if method is actually implemented (not just raising NotImplementedError)
+                    import inspect
+                    method = getattr(self, method_name)
+                    if callable(method):
+                        source = inspect.getsource(method)
+                        # If it's not just raising NotImplementedError, consider it supported
+                        if not ('raise NotImplementedError' in source and len(source.split('\n')) < 10):
+                            supported.append(task_name)
+                except:
+                    # If we can't inspect, assume it's supported if the method exists
+                    supported.append(task_name)
+                
+        return supported
     
-    async def classify_image(
+    # ==================== COMMON TASK IMPLEMENTATIONS ====================
+    # 为每个provider提供可选的默认实现，provider可以覆盖这些方法
+    
+    async def analyze_images(
         self, 
-        image: Union[str, BinaryIO],
-        categories: Optional[List[str]] = None
-    ) -> Dict[str, Any]:
+        images: List[Union[str, BinaryIO]],
+        prompt: Optional[str] = None,
+        max_tokens: int = 1000
+    ) -> List[Dict[str, Any]]:
         """
-        图像分类 - Provider可选实现
+        批量图像分析 - Provider可选实现
+        默认实现：如果provider支持analyze_image，则逐个调用
         """
-        raise NotImplementedError(f"{self.__class__.__name__} does not support classify_image task")
+        if hasattr(self, 'analyze_image'):
+            results = []
+            for image in images:
+                try:
+                    result = await self.analyze_image(image, prompt, max_tokens)
+                    results.append(result)
+                except NotImplementedError:
+                    raise NotImplementedError(f"{self.__class__.__name__} does not support analyze_images task")
+            return results
+        else:
+            raise NotImplementedError(f"{self.__class__.__name__} does not support analyze_images task")
     
-    async def compare_images(
+    async def describe_image(
         self, 
-        image1: Union[str, BinaryIO],
-        image2: Union[str, BinaryIO]
+        image: Union[str, BinaryIO],
+        detail_level: str = "medium"
     ) -> Dict[str, Any]:
         """
-        图像比较 - Provider可选实现
+        图像描述 - Provider可选实现
         """
-        raise NotImplementedError(f"{self.__class__.__name__} does not support compare_images task")
-    
-    # ==================== 检测抽取类方法 ====================
+        raise NotImplementedError(f"{self.__class__.__name__} does not support describe_image task")
     
     async def extract_text(self, image: Union[str, BinaryIO]) -> Dict[str, Any]:
         """
@@ -130,48 +192,10 @@ class BaseVisionService(BaseService):
         confidence_threshold: float = 0.5
     ) -> Dict[str, Any]:
         """
-        通用物体检测 - Provider可选实现
+        物体检测 - Provider可选实现
         """
         raise NotImplementedError(f"{self.__class__.__name__} does not support detect_objects task")
     
-    async def detect_ui_elements(
-        self,
-        image: Union[str, BinaryIO],
-        element_types: Optional[List[str]] = None,
-        confidence_threshold: float = 0.5
-    ) -> Dict[str, Any]:
-        """
-        UI界面元素检测 - Provider可选实现
-        
-        Args:
-            image: 输入图像
-            element_types: 要检测的元素类型 ['button', 'input', 'text', 'image', 'link', etc.]
-            confidence_threshold: 置信度阈值
-            
-        Returns:
-            Dict containing detected UI elements with their bounding boxes and types
-        """
-        raise NotImplementedError(f"{self.__class__.__name__} does not support detect_ui_elements task")
-    
-    async def detect_document_elements(
-        self,
-        image: Union[str, BinaryIO],
-        element_types: Optional[List[str]] = None,
-        confidence_threshold: float = 0.5
-    ) -> Dict[str, Any]:
-        """
-        文档结构元素检测 - Provider可选实现
-        
-        Args:
-            image: 输入图像
-            element_types: 要检测的元素类型 ['table', 'header', 'paragraph', 'list', etc.]
-            confidence_threshold: 置信度阈值
-            
-        Returns:
-            Dict containing detected document elements with their structure and content
-        """
-        raise NotImplementedError(f"{self.__class__.__name__} does not support detect_document_elements task")
-    
     async def get_object_coordinates(
         self,
         image: Union[str, BinaryIO],
@@ -182,116 +206,25 @@ class BaseVisionService(BaseService):
         """
         raise NotImplementedError(f"{self.__class__.__name__} does not support get_object_coordinates task")
     
-    async def extract_table_data(
-        self,
+    async def classify_image(
+        self, 
         image: Union[str, BinaryIO],
-        table_format: str = "json",
-        preserve_formatting: bool = True
+        categories: Optional[List[str]] = None
     ) -> Dict[str, Any]:
         """
-        表格数据结构化抽取 - Provider可选实现
-        
-        Args:
-            image: 输入图像
-            table_format: 输出格式 ('json', 'csv', 'markdown', 'html')
-            preserve_formatting: 是否保持原始格式（合并单元格、样式等）
-            
-        Returns:
-            Dict containing extracted table data in structured format:
-            {
-                "tables": [
-                    {
-                        "table_id": "table_1",
-                        "headers": ["Column1", "Column2", "Column3"],
-                        "rows": [
-                            ["cell1", "cell2", "cell3"],
-                            ["cell4", "cell5", "cell6"]
-                        ],
-                        "metadata": {
-                            "row_count": 2,
-                            "column_count": 3,
-                            "has_headers": true,
-                            "merged_cells": [],
-                            "table_caption": "optional_caption"
-                        }
-                    }
-                ],
-                "raw_data": "original_table_text",
-                "format": "json"
-            }
-        """
-        raise NotImplementedError(f"{self.__class__.__name__} does not support extract_table_data task")
-    
-    async def close(self):
-        """Cleanup resources - default implementation does nothing"""
-        pass
-    
-    def get_supported_tasks(self) -> List[str]:
-        """
-        获取provider支持的任务列表
-        
-        Returns:
-            List of supported task names
+        图像分类 - Provider可选实现
         """
-        supported = []
-        
-        # 检查哪些方法被实现了
-        if hasattr(self, 'analyze_image') and callable(getattr(self, 'analyze_image')):
-            try:
-                # 尝试调用看是否抛出NotImplementedError
-                import inspect
-                if not 'NotImplementedError' in inspect.getsource(self.analyze_image):
-                    supported.append('analyze')
-            except:
-                pass
-                
-        # 检查各类任务支持情况
-        method_task_map = {
-            # 图像理解类
-            'describe_image': 'describe',
-            'classify_image': 'classify',
-            'compare_images': 'compare',
-            # 检测抽取类
-            'extract_text': 'extract_text', 
-            'detect_objects': 'detect_objects',
-            'detect_ui_elements': 'detect_ui_elements',
-            'detect_document_elements': 'detect_document_elements',
-            'extract_table_data': 'extract_table_data',
-            'get_object_coordinates': 'get_coordinates'
-        }
-        
-        for method_name, task_name in method_task_map.items():
-            if hasattr(self, method_name):
-                # 检查是否是默认实现（基于analyze_image）还是provider自己的实现
-                supported.append(task_name)
-                
-        return supported
-    
-    # ==================== COMMON TASK IMPLEMENTATIONS ====================
-    # 为每个provider提供可选的默认实现，provider可以覆盖这些方法
+        raise NotImplementedError(f"{self.__class__.__name__} does not support classify_image task")
     
-    async def analyze_images(
+    async def compare_images(
         self, 
-        images: List[Union[str, BinaryIO]],
-        prompt: Optional[str] = None,
-        max_tokens: int = 1000
-    ) -> List[Dict[str, Any]]:
+        image1: Union[str, BinaryIO],
+        image2: Union[str, BinaryIO]
+    ) -> Dict[str, Any]:
         """
-        批量图像分析 - Provider可选实现
-        默认实现：如果provider支持analyze_image，则逐个调用
+        图像比较 - Provider可选实现
         """
-        if hasattr(self, 'analyze_image'):
-            results = []
-            for image in images:
-                try:
-                    result = await self.analyze_image(image, prompt, max_tokens)
-                    results.append(result)
-                except NotImplementedError:
-                    raise NotImplementedError(f"{self.__class__.__name__} does not support analyze_images task")
-            return results
-        else:
-            raise NotImplementedError(f"{self.__class__.__name__} does not support analyze_images task")
-    
+        raise NotImplementedError(f"{self.__class__.__name__} does not support compare_images task")
     
     def get_supported_formats(self) -> List[str]:
         """