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

isa_model/inference/services/llm/ollama_llm_service.py

@@ -3,6 +3,7 @@ import httpx
 import json
 from typing import Dict, Any, List, Union, AsyncGenerator, Optional, Callable
 from isa_model.inference.services.llm.base_llm_service import BaseLLMService
+from isa_model.core.config.config_manager import ConfigManager
 
 logger = logging.getLogger(__name__)
 
@@ -16,7 +17,10 @@ class OllamaLLMService(BaseLLMService):
         provider_config = self.get_provider_config()
         
         # Create HTTP client for Ollama API
-        base_url = provider_config.get("base_url", "http://localhost:11434")
+        config_manager = ConfigManager()
+        # Use Consul discovery with fallback
+        default_base_url = config_manager.get_ollama_url()
+        base_url = provider_config.get("base_url", default_base_url)
         timeout = provider_config.get("timeout", 60)
         
         self.client = httpx.AsyncClient(
@@ -34,7 +38,10 @@ class OllamaLLMService(BaseLLMService):
         """Ensure the HTTP client is available and not closed"""
         if not hasattr(self, 'client') or not self.client or self.client.is_closed:
             provider_config = self.get_provider_config()
-            base_url = provider_config.get("base_url", "http://localhost:11434")
+            config_manager = ConfigManager()
+            # Use Consul discovery with fallback
+            default_base_url = config_manager.get_ollama_url()
+            base_url = provider_config.get("base_url", default_base_url)
             timeout = provider_config.get("timeout", 60)
             self.client = httpx.AsyncClient(base_url=base_url, timeout=timeout)
     

isa_model/inference/services/llm/openai_llm_service.py

@@ -20,6 +20,8 @@ class OpenAILLMService(BaseLLMService):
         
         # Check if this is an O-series reasoning model
         self.is_reasoning_model = model_name.startswith("o4-") or model_name.startswith("o3-")
+        self.uses_completion_tokens = self.is_reasoning_model or model_name.startswith("gpt-5")
+        self.requires_default_temperature = self.is_reasoning_model or model_name.startswith("gpt-5")
         self.supports_deep_research = "deep-search" in model_name or "deep-research" in model_name
         
         # Get configuration from centralized config manager
@@ -36,7 +38,9 @@ class OpenAILLMService(BaseLLMService):
             self.client = AsyncOpenAI(
                 api_key=provider_config["api_key"],
                 base_url=provider_config.get("api_base_url", "https://api.openai.com/v1"),
-                organization=provider_config.get("organization")
+                organization=provider_config.get("organization"),
+                timeout=10.0,  # 10 second timeout for first token (much faster than 600s default)
+                max_retries=2  # Retry on timeout
             )
             
             logger.info(f"Initialized OpenAILLMService with model {self.model_name} and endpoint {self.client.base_url}")
@@ -70,6 +74,8 @@ class OpenAILLMService(BaseLLMService):
         
         # Copy OpenAI-specific attributes
         bound_service.is_reasoning_model = self.is_reasoning_model
+        bound_service.uses_completion_tokens = self.uses_completion_tokens
+        bound_service.requires_default_temperature = self.requires_default_temperature
         bound_service.supports_deep_research = self.supports_deep_research
         
         # Copy base class attributes
@@ -103,7 +109,7 @@ class OpenAILLMService(BaseLLMService):
         
         return bound_service
     
-    async def astream(self, input_data: Union[str, List[Dict[str, str]], Any], show_reasoning: bool = False) -> AsyncGenerator[Union[str, Dict[str, Any]], None]:
+    async def astream(self, input_data: Union[str, List[Dict[str, str]], Any], show_reasoning: bool = False, **extra_kwargs) -> AsyncGenerator[Union[str, Dict[str, Any]], None]:
         """
         True streaming method - yields tokens one by one as they arrive
         
@@ -121,19 +127,19 @@ class OpenAILLMService(BaseLLMService):
             if use_responses_api:
                 logger.info(f"Using Responses API streaming for {self.model_name}")
                 # Use Responses API streaming
-                async for chunk in self._astream_responses_api(input_data, show_reasoning):
+                async for chunk in self._astream_responses_api(input_data, show_reasoning, **extra_kwargs):
                     yield chunk
             else:
                 logger.debug(f"Using Chat Completions API streaming for {self.model_name}")
                 # Use Chat Completions API streaming
-                async for chunk in self._astream_chat_completions_api(input_data):
+                async for chunk in self._astream_chat_completions_api(input_data, **extra_kwargs):
                     yield chunk
                     
         except Exception as e:
             logger.error(f"Error in astream: {e}")
             raise
     
-    async def _astream_responses_api(self, input_data: Union[str, List[Dict[str, str]], Any], show_reasoning: bool = False) -> AsyncGenerator[Union[str, Dict[str, Any]], None]:
+    async def _astream_responses_api(self, input_data: Union[str, List[Dict[str, str]], Any], show_reasoning: bool = False, **extra_kwargs) -> AsyncGenerator[Union[str, Dict[str, Any]], None]:
         """Stream using Responses API for reasoning models and deep research models"""
         try:
             # Use adapter manager to prepare messages
@@ -228,7 +234,7 @@ class OpenAILLMService(BaseLLMService):
             logger.error(f"Error in _astream_responses_api: {e}")
             raise
     
-    async def _astream_chat_completions_api(self, input_data: Union[str, List[Dict[str, str]], Any]) -> AsyncGenerator[Union[str, Dict[str, Any]], None]:
+    async def _astream_chat_completions_api(self, input_data: Union[str, List[Dict[str, str]], Any], **extra_kwargs) -> AsyncGenerator[Union[str, Dict[str, Any]], None]:
         """Stream using Chat Completions API for standard models"""
         try:
             # Use adapter manager to prepare messages
@@ -242,13 +248,13 @@ class OpenAILLMService(BaseLLMService):
                 "stream": True
             }
             
-            # O4 models only support temperature=1 (default)
-            if not self.is_reasoning_model:
+            # O4 and GPT-5 models only support temperature=1 (default)
+            if not self.requires_default_temperature:
                 kwargs["temperature"] = provider_config.get("temperature", 0.7)
             
-            # O4 models use max_completion_tokens instead of max_tokens
+            # O4 and GPT-5 models use max_completion_tokens instead of max_tokens
             max_tokens_value = provider_config.get("max_tokens", 1024)
-            if self.is_reasoning_model:
+            if self.uses_completion_tokens:
                 kwargs["max_completion_tokens"] = max_tokens_value
             else:
                 kwargs["max_tokens"] = max_tokens_value
@@ -259,6 +265,11 @@ class OpenAILLMService(BaseLLMService):
                 kwargs["tools"] = tool_schemas
                 kwargs["tool_choice"] = "auto"
             
+            # Add response_format if specified (for JSON mode)
+            if 'response_format' in extra_kwargs:
+                kwargs['response_format'] = extra_kwargs['response_format']
+                logger.debug(f"Using response_format in streaming: {extra_kwargs['response_format']}")
+            
             # Stream tokens and detect tool calls
             content_chunks = []
             tool_calls_accumulator = {}  # Track complete tool calls by ID
@@ -360,13 +371,14 @@ class OpenAILLMService(BaseLLMService):
             logger.error(f"Error in _astream_chat_completions_api: {e}")
             raise
     
-    async def ainvoke(self, input_data: Union[str, List[Dict[str, str]], Any], show_reasoning: bool = False) -> Union[str, Any]:
+    async def ainvoke(self, input_data: Union[str, List[Dict[str, str]], Any], show_reasoning: bool = False, **extra_kwargs) -> Union[str, Any]:
         """
         Unified invoke method for all input types
         
         Args:
             input_data: Input messages or text
             show_reasoning: If True and model supports it, show reasoning process using Responses API
+            **extra_kwargs: Additional parameters to pass to the API (e.g., response_format)
         """
         try:
             # Use adapter manager to prepare messages
@@ -385,13 +397,13 @@ class OpenAILLMService(BaseLLMService):
                 "messages": messages
             }
             
-            # O4 models only support temperature=1 (default)
-            if not self.is_reasoning_model:
+            # O4 and GPT-5 models only support temperature=1 (default)
+            if not self.requires_default_temperature:
                 kwargs["temperature"] = provider_config.get("temperature", 0.7)
             
-            # O4 models use max_completion_tokens instead of max_tokens
+            # O4 and GPT-5 models use max_completion_tokens instead of max_tokens
             max_tokens_value = provider_config.get("max_tokens", 1024)
-            if self.is_reasoning_model:
+            if self.uses_completion_tokens:
                 kwargs["max_completion_tokens"] = max_tokens_value
             else:
                 kwargs["max_tokens"] = max_tokens_value
@@ -403,11 +415,16 @@ class OpenAILLMService(BaseLLMService):
                 if not use_responses_api:  # Responses API handles tool choice differently
                     kwargs["tool_choice"] = "auto"
             
+            # Add response_format if specified (for JSON mode)
+            if 'response_format' in extra_kwargs:
+                kwargs['response_format'] = extra_kwargs['response_format']
+                logger.debug(f"Using response_format: {extra_kwargs['response_format']}")
+            
             # Handle streaming vs non-streaming
             if self.streaming:
                 # TRUE STREAMING MODE - collect all chunks from the stream
                 content_chunks = []
-                async for token in self.astream(input_data, show_reasoning=show_reasoning):
+                async for token in self.astream(input_data, show_reasoning=show_reasoning, **extra_kwargs):
                     if isinstance(token, str):
                         content_chunks.append(token)
                     elif isinstance(token, dict) and "result" in token:

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)

isa_model/inference/services/vision/__init__.py

@@ -31,6 +31,21 @@ 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", 
@@ -43,4 +58,10 @@ 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/blip_vision_service.py

@@ -0,0 +1,359 @@
+#!/usr/bin/env python3
+"""
+BLIP Vision Service
+Computer vision service using BLIP for image captioning and description
+Based on the notebook implementation
+"""
+
+import os
+import logging
+from typing import Dict, List, Any, Optional, Union, BinaryIO
+from PIL import Image
+import io
+
+from .base_vision_service import BaseVisionService
+
+logger = logging.getLogger(__name__)
+
+def _lazy_import_blip_deps():
+    """Lazy import BLIP dependencies"""
+    try:
+        import torch
+        import tensorflow as tf
+        from transformers import BlipProcessor, BlipForConditionalGeneration
+        
+        return {
+            'torch': torch,
+            'tf': tf,
+            'BlipProcessor': BlipProcessor,
+            'BlipForConditionalGeneration': BlipForConditionalGeneration,
+            'available': True
+        }
+    except ImportError as e:
+        logger.warning(f"BLIP dependencies not available: {e}")
+        return {'available': False}
+
+class BLIPVisionService(BaseVisionService):
+    """
+    BLIP-based vision service for image captioning and description
+    Provides an alternative implementation to VLM-based captioning
+    """
+    
+    def __init__(self, model_name: str = "Salesforce/blip-image-captioning-base"):
+        """
+        Initialize BLIP vision service
+        
+        Args:
+            model_name: Hugging Face model name for BLIP
+        """
+        super().__init__()
+        
+        self.model_name = model_name
+        self.processor = None
+        self.model = None
+        
+        # Lazy load dependencies
+        self.blip_components = _lazy_import_blip_deps()
+        
+        if not self.blip_components['available']:
+            raise ImportError("BLIP dependencies (transformers, torch) are required")
+        
+        # Load BLIP model
+        self._load_blip_model()
+    
+    def _load_blip_model(self):
+        """Load BLIP model and processor"""
+        try:
+            # Load the pretrained BLIP processor and model
+            self.processor = self.blip_components['BlipProcessor'].from_pretrained(self.model_name)
+            self.model = self.blip_components['BlipForConditionalGeneration'].from_pretrained(self.model_name)
+            
+            logger.info(f"BLIP model loaded: {self.model_name}")
+            
+        except Exception as e:
+            logger.error(f"Error loading BLIP model: {e}")
+            raise
+    
+    def _preprocess_image(self, image: Union[str, BinaryIO]) -> Image.Image:
+        """
+        Preprocess image for BLIP input
+        
+        Args:
+            image: Image path or binary data
+            
+        Returns:
+            PIL Image in RGB format
+        """
+        try:
+            # Handle different image input types
+            if isinstance(image, str):
+                # File path
+                pil_image = Image.open(image).convert('RGB')
+            elif hasattr(image, 'read'):
+                # Binary IO
+                image_data = image.read()
+                pil_image = Image.open(io.BytesIO(image_data)).convert('RGB')
+            else:
+                raise ValueError("Unsupported image format")
+            
+            return pil_image
+            
+        except Exception as e:
+            logger.error(f"Error preprocessing image: {e}")
+            raise
+    
+    def _generate_text(self, image: Image.Image, prompt: str) -> str:
+        """
+        Generate text for image using BLIP
+        
+        Args:
+            image: PIL Image
+            prompt: Text prompt for generation
+            
+        Returns:
+            Generated text
+        """
+        try:
+            # Prepare inputs for BLIP model
+            inputs = self.processor(images=image, text=prompt, return_tensors="pt")
+            
+            # Generate text output
+            output = self.model.generate(**inputs)
+            
+            # Decode output
+            result = self.processor.decode(output[0], skip_special_tokens=True)
+            
+            return result
+            
+        except Exception as e:
+            logger.error(f"Error generating text: {e}")
+            raise
+    
+    async def describe_image(self, 
+                           image: Union[str, BinaryIO], 
+                           detail_level: str = "medium") -> Dict[str, Any]:
+        """
+        Generate description for image using BLIP
+        
+        Args:
+            image: Image path or binary data
+            detail_level: Level of detail (not used in BLIP, maintained for compatibility)
+            
+        Returns:
+            Description results
+        """
+        try:
+            # Preprocess image
+            pil_image = self._preprocess_image(image)
+            
+            # Generate caption using BLIP
+            prompt = "This is a picture of"  # Following notebook implementation
+            caption = self._generate_text(pil_image, prompt)
+            
+            return {
+                "task": "describe",
+                "service": "BLIPVisionService",
+                "description": caption,
+                "detail_level": detail_level,
+                "model_type": "BLIP",
+                "prompt_used": prompt,
+                "success": True
+            }
+            
+        except Exception as e:
+            logger.error(f"Error describing image: {e}")
+            return {
+                "error": str(e),
+                "service": "BLIPVisionService",
+                "success": False
+            }
+    
+    async def analyze_image(self, 
+                          image: Union[str, BinaryIO], 
+                          prompt: Optional[str] = None,
+                          max_tokens: int = 1000) -> Dict[str, Any]:
+        """
+        Analyze image using BLIP
+        
+        Args:
+            image: Image path or binary data
+            prompt: Optional custom prompt
+            max_tokens: Not used for BLIP
+            
+        Returns:
+            Analysis results
+        """
+        try:
+            # Preprocess image
+            pil_image = self._preprocess_image(image)
+            
+            # Use custom prompt or default
+            if prompt:
+                analysis_prompt = prompt
+            else:
+                analysis_prompt = "This is a detailed photo showing"  # For summary-like analysis
+            
+            # Generate analysis using BLIP
+            analysis_text = self._generate_text(pil_image, analysis_prompt)
+            
+            return {
+                "task": "analyze",
+                "service": "BLIPVisionService",
+                "text": analysis_text,
+                "model_type": "BLIP",
+                "prompt_used": analysis_prompt,
+                "success": True
+            }
+            
+        except Exception as e:
+            logger.error(f"Error analyzing image: {e}")
+            return {
+                "error": str(e),
+                "service": "BLIPVisionService",
+                "success": False
+            }
+    
+    async def generate_caption(self, image: Union[str, BinaryIO]) -> Dict[str, Any]:
+        """
+        Generate caption for image (Task 9 from notebook)
+        
+        Args:
+            image: Image path or binary data
+            
+        Returns:
+            Caption results
+        """
+        try:
+            # Preprocess image
+            pil_image = self._preprocess_image(image)
+            
+            # Generate caption
+            prompt = "This is a picture of"  # Following notebook
+            caption = self._generate_text(pil_image, prompt)
+            
+            return {
+                "task": "caption",
+                "service": "BLIPVisionService",
+                "caption": caption,
+                "model_type": "BLIP",
+                "success": True
+            }
+            
+        except Exception as e:
+            logger.error(f"Error generating caption: {e}")
+            return {
+                "error": str(e),
+                "service": "BLIPVisionService",
+                "success": False
+            }
+    
+    async def generate_summary(self, image: Union[str, BinaryIO]) -> Dict[str, Any]:
+        """
+        Generate summary for image (Task 10 from notebook)
+        
+        Args:
+            image: Image path or binary data
+            
+        Returns:
+            Summary results
+        """
+        try:
+            # Preprocess image
+            pil_image = self._preprocess_image(image)
+            
+            # Generate summary
+            prompt = "This is a detailed photo showing"  # Following notebook
+            summary = self._generate_text(pil_image, prompt)
+            
+            return {
+                "task": "summary",
+                "service": "BLIPVisionService",
+                "summary": summary,
+                "model_type": "BLIP",
+                "success": True
+            }
+            
+        except Exception as e:
+            logger.error(f"Error generating summary: {e}")
+            return {
+                "error": str(e),
+                "service": "BLIPVisionService",
+                "success": False
+            }
+    
+    async def batch_generate(self, 
+                           images: List[Union[str, BinaryIO]], 
+                           task: str = "caption") -> Dict[str, Any]:
+        """
+        Generate captions or summaries for multiple images
+        
+        Args:
+            images: List of image paths or binary data
+            task: Task type ("caption" or "summary")
+            
+        Returns:
+            Batch generation results
+        """
+        try:
+            results = []
+            errors = []
+            
+            for i, image in enumerate(images):
+                try:
+                    if task == "caption":
+                        result = await self.generate_caption(image)
+                    elif task == "summary":
+                        result = await self.generate_summary(image)
+                    else:
+                        raise ValueError(f"Unsupported task: {task}")
+                    
+                    if result.get("success"):
+                        results.append({
+                            "index": i,
+                            "image": str(image) if isinstance(image, str) else f"binary_image_{i}",
+                            **result
+                        })
+                    else:
+                        errors.append({
+                            "index": i,
+                            "image": str(image) if isinstance(image, str) else f"binary_image_{i}",
+                            "error": result.get("error", "Unknown error")
+                        })
+                        
+                except Exception as e:
+                    errors.append({
+                        "index": i,
+                        "image": str(image) if isinstance(image, str) else f"binary_image_{i}",
+                        "error": str(e)
+                    })
+            
+            return {
+                "task": f"batch_{task}",
+                "service": "BLIPVisionService",
+                "total_images": len(images),
+                "successful": len(results),
+                "failed": len(errors),
+                "results": results,
+                "errors": errors,
+                "success": True
+            }
+            
+        except Exception as e:
+            logger.error(f"Error in batch generation: {e}")
+            return {
+                "error": str(e),
+                "service": "BLIPVisionService",
+                "success": False
+            }
+    
+    def get_service_info(self) -> Dict[str, Any]:
+        """Get service information"""
+        return {
+            "service_name": "BLIPVisionService",
+            "model_name": self.model_name,
+            "model_type": "BLIP",
+            "capabilities": ["describe", "analyze", "caption", "summary", "batch_generate"],
+            "model_loaded": self.model is not None,
+            "processor_loaded": self.processor is not None,
+            "dependencies_available": self.blip_components['available']
+        }

isa_model/inference/services/vision/helpers/image_utils.py

@@ -59,25 +59,28 @@ def get_image_data(image: Union[str, BinaryIO]) -> bytes:
 
 def compress_image(image_data: Union[bytes, BytesIO], max_size: int = 1024) -> bytes:
     """压缩图片以减小大小
-    
+
     Args:
         image_data: 图片数据，可以是 bytes 或 BytesIO
         max_size: 最大尺寸（像素）
-        
+
     Returns:
         bytes: 压缩后的图片数据
     """
     try:
+        # Ensure max_size is int (type safety)
+        max_size = int(max_size)
+
         # 如果输入是 bytes，转换为 BytesIO
         if isinstance(image_data, bytes):
             image_data = BytesIO(image_data)
-            
+
         img = Image.open(image_data)
-        
+
         # 转换为 RGB 模式（如果需要）
         if img.mode in ('RGBA', 'P'):
             img = img.convert('RGB')
-        
+
         # 计算新尺寸，保持宽高比
         ratio = max_size / max(img.size)
         if ratio < 1: