abstractcore 2.4.4__py3-none-any.whl → 2.4.5__py3-none-any.whl

abstractcore/media/utils/image_scaler.py

@@ -0,0 +1,306 @@
+"""
+Image scaling utility for AbstractCore media handling.
+
+Provides intelligent image scaling based on model-specific requirements
+and capabilities for vision models.
+"""
+
+from typing import Tuple, Optional, Union, Dict, Any
+from enum import Enum
+from pathlib import Path
+import logging
+
+try:
+    from PIL import Image, ImageOps
+    PIL_AVAILABLE = True
+except ImportError:
+    PIL_AVAILABLE = False
+
+from ..base import MediaProcessingError
+
+
+class ScalingMode(Enum):
+    """Image scaling modes."""
+    FIT = "fit"          # Scale to fit within target size, maintaining aspect ratio
+    FILL = "fill"        # Scale to fill target size, may crop, maintaining aspect ratio
+    STRETCH = "stretch"  # Stretch to exact target size, may distort aspect ratio
+    PAD = "pad"          # Scale to fit and pad with background to exact target size
+    CROP_CENTER = "crop_center"  # Scale to fill and crop from center
+
+
+class ModelOptimizedScaler:
+    """
+    Intelligent image scaler that optimizes images for specific vision models.
+
+    Uses model capability information to determine optimal scaling strategies.
+    """
+
+    def __init__(self):
+        self.logger = logging.getLogger(__name__)
+
+        if not PIL_AVAILABLE:
+            raise MediaProcessingError("PIL (Pillow) is required for image scaling")
+
+    def get_optimal_resolution(self, model_name: str, original_size: Tuple[int, int],
+                             model_capabilities: Optional[Dict[str, Any]] = None) -> Tuple[int, int]:
+        """
+        Get optimal resolution for a specific model.
+
+        Args:
+            model_name: Name of the model
+            original_size: Original image size (width, height)
+            model_capabilities: Model capability information
+
+        Returns:
+            Optimal target size (width, height)
+        """
+        if model_capabilities is None:
+            model_capabilities = self._get_model_capabilities(model_name)
+
+        max_resolution = model_capabilities.get("max_image_resolution", "variable")
+        image_patch_size = model_capabilities.get("image_patch_size", 16)
+        adaptive_windowing = model_capabilities.get("adaptive_windowing", False)
+
+        # Handle different resolution strategies
+        if max_resolution == "variable":
+            return self._optimize_variable_resolution(original_size, image_patch_size)
+        elif max_resolution == "896x896":
+            return (896, 896)
+        elif max_resolution == "3584x3584":
+            return self._optimize_large_resolution(original_size, (3584, 3584), image_patch_size)
+        elif "x" in str(max_resolution):
+            # Parse specific resolution like "1568x1568"
+            w, h = map(int, str(max_resolution).split("x"))
+            return (w, h)
+        else:
+            # Default fallback
+            return self._optimize_variable_resolution(original_size, image_patch_size)
+
+    def _optimize_variable_resolution(self, original_size: Tuple[int, int],
+                                    patch_size: int = 16) -> Tuple[int, int]:
+        """Optimize for variable resolution models like Qwen3-VL."""
+        width, height = original_size
+
+        # For variable resolution, aim for reasonable size that's efficient
+        # while maintaining good quality
+        max_dimension = 1024  # Good balance for most use cases
+
+        # Scale down if too large
+        if max(width, height) > max_dimension:
+            if width > height:
+                new_width = max_dimension
+                new_height = int(height * (max_dimension / width))
+            else:
+                new_height = max_dimension
+                new_width = int(width * (max_dimension / height))
+        else:
+            new_width, new_height = width, height
+
+        # Round to nearest patch size multiple for efficiency
+        new_width = ((new_width + patch_size - 1) // patch_size) * patch_size
+        new_height = ((new_height + patch_size - 1) // patch_size) * patch_size
+
+        return (new_width, new_height)
+
+    def _optimize_large_resolution(self, original_size: Tuple[int, int],
+                                 max_size: Tuple[int, int],
+                                 patch_size: int = 14) -> Tuple[int, int]:
+        """Optimize for large resolution models like Qwen2.5-VL."""
+        width, height = original_size
+        max_width, max_height = max_size
+
+        # Scale to fit within max size while maintaining aspect ratio
+        scale = min(max_width / width, max_height / height)
+
+        if scale < 1:  # Only scale down, never up
+            new_width = int(width * scale)
+            new_height = int(height * scale)
+        else:
+            new_width, new_height = width, height
+
+        # Round to nearest patch size multiple
+        new_width = ((new_width + patch_size - 1) // patch_size) * patch_size
+        new_height = ((new_height + patch_size - 1) // patch_size) * patch_size
+
+        return (new_width, new_height)
+
+    def scale_image(self, image: Image.Image, target_size: Tuple[int, int],
+                   mode: ScalingMode = ScalingMode.FIT,
+                   background_color: Tuple[int, int, int] = (255, 255, 255)) -> Image.Image:
+        """
+        Scale image to target size using specified mode.
+
+        Args:
+            image: PIL Image to scale
+            target_size: Target size (width, height)
+            mode: Scaling mode
+            background_color: Background color for padding (RGB)
+
+        Returns:
+            Scaled PIL Image
+        """
+        target_width, target_height = target_size
+
+        if mode == ScalingMode.FIT:
+            # Scale to fit within target size, maintaining aspect ratio
+            image.thumbnail((target_width, target_height), Image.Resampling.LANCZOS)
+            return image
+
+        elif mode == ScalingMode.FILL:
+            # Scale to fill target size, may crop
+            return ImageOps.fit(image, target_size, Image.Resampling.LANCZOS)
+
+        elif mode == ScalingMode.STRETCH:
+            # Stretch to exact target size
+            return image.resize(target_size, Image.Resampling.LANCZOS)
+
+        elif mode == ScalingMode.PAD:
+            # Scale to fit and pad to exact size
+            image.thumbnail((target_width, target_height), Image.Resampling.LANCZOS)
+
+            # Create new image with background color
+            new_image = Image.new('RGB', target_size, background_color)
+
+            # Paste scaled image centered
+            paste_x = (target_width - image.width) // 2
+            paste_y = (target_height - image.height) // 2
+            new_image.paste(image, (paste_x, paste_y))
+
+            return new_image
+
+        elif mode == ScalingMode.CROP_CENTER:
+            # Scale to fill and crop from center
+            return ImageOps.fit(image, target_size, Image.Resampling.LANCZOS, centering=(0.5, 0.5))
+
+        else:
+            raise MediaProcessingError(f"Unknown scaling mode: {mode}")
+
+    def scale_for_model(self, image: Image.Image, model_name: str,
+                       scaling_mode: ScalingMode = ScalingMode.FIT,
+                       model_capabilities: Optional[Dict[str, Any]] = None) -> Image.Image:
+        """
+        Scale image optimally for a specific model.
+
+        Args:
+            image: PIL Image to scale
+            model_name: Name of the target model
+            scaling_mode: How to scale the image
+            model_capabilities: Model capability information
+
+        Returns:
+            Optimally scaled PIL Image for the model
+        """
+        original_size = image.size
+        target_size = self.get_optimal_resolution(model_name, original_size, model_capabilities)
+
+        self.logger.debug(f"Scaling image for {model_name}: {original_size} -> {target_size}")
+
+        # For fixed resolution models, always use PAD mode to maintain exact size
+        if model_capabilities and model_capabilities.get("max_image_resolution") == "896x896":
+            scaling_mode = ScalingMode.PAD
+
+        return self.scale_image(image, target_size, scaling_mode)
+
+    def _get_model_capabilities(self, model_name: str) -> Dict[str, Any]:
+        """
+        Get model capabilities from the capabilities JSON.
+
+        Args:
+            model_name: Name of the model
+
+        Returns:
+            Model capabilities dictionary
+        """
+        try:
+            from ..capabilities import get_media_capabilities
+            return get_media_capabilities(model_name).__dict__
+        except ImportError:
+            # Fallback capability detection
+            return self._fallback_model_capabilities(model_name)
+
+    def _fallback_model_capabilities(self, model_name: str) -> Dict[str, Any]:
+        """Fallback capability detection when capabilities module not available."""
+        model_lower = model_name.lower()
+
+        # Gemma models - fixed 896x896
+        if any(gem in model_lower for gem in ["gemma3", "gemma-3n"]):
+            return {
+                "max_image_resolution": "896x896",
+                "image_patch_size": 16,
+                "adaptive_windowing": True
+            }
+
+        # Qwen2.5-VL models - up to 3584x3584
+        elif "qwen2.5" in model_lower and "vl" in model_lower:
+            return {
+                "max_image_resolution": "3584x3584",
+                "image_patch_size": 14,
+                "pixel_grouping": "28x28"
+            }
+
+        # Qwen3-VL models - variable resolution
+        elif "qwen3" in model_lower and "vl" in model_lower:
+            return {
+                "max_image_resolution": "variable",
+                "image_patch_size": 16,
+                "pixel_grouping": "32x32"
+            }
+
+        # Claude models - up to 1568x1568
+        elif "claude" in model_lower:
+            return {
+                "max_image_resolution": "1568x1568",
+                "image_patch_size": 14
+            }
+
+        # Default fallback
+        else:
+            return {
+                "max_image_resolution": "variable",
+                "image_patch_size": 16
+            }
+
+
+# Convenience functions for easy usage
+_scaler_instance = None
+
+def get_scaler() -> ModelOptimizedScaler:
+    """Get shared scaler instance."""
+    global _scaler_instance
+    if _scaler_instance is None:
+        _scaler_instance = ModelOptimizedScaler()
+    return _scaler_instance
+
+def scale_image_for_model(image: Union[Image.Image, str, Path],
+                         model_name: str,
+                         scaling_mode: ScalingMode = ScalingMode.FIT) -> Image.Image:
+    """
+    Convenience function to scale an image for a specific model.
+
+    Args:
+        image: PIL Image, or path to image file
+        model_name: Name of the target model
+        scaling_mode: How to scale the image
+
+    Returns:
+        Optimally scaled PIL Image
+    """
+    if isinstance(image, (str, Path)):
+        image = Image.open(image)
+
+    scaler = get_scaler()
+    return scaler.scale_for_model(image, model_name, scaling_mode)
+
+def get_optimal_size_for_model(model_name: str, original_size: Tuple[int, int]) -> Tuple[int, int]:
+    """
+    Get optimal image size for a specific model.
+
+    Args:
+        model_name: Name of the target model
+        original_size: Original image size (width, height)
+
+    Returns:
+        Optimal target size (width, height)
+    """
+    scaler = get_scaler()
+    return scaler.get_optimal_resolution(model_name, original_size)

abstractcore/utils/version.py

@@ -11,4 +11,4 @@ including when the package is installed from PyPI where pyproject.toml is not av
 
 # Package version - update this when releasing new versions
 # This must be manually synchronized with the version in pyproject.toml
-__version__ = "2.4.4"
+__version__ = "2.4.5"

{abstractcore-2.4.4.dist-info → abstractcore-2.4.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstractcore
-Version: 2.4.4
+Version: 2.4.5
 Summary: Unified interface to all LLM providers with essential infrastructure for tool calling, streaming, and model management
 Author-email: Laurent-Philippe Albou <contact@abstractcore.ai>
 Maintainer-email: Laurent-Philippe Albou <contact@abstractcore.ai>

{abstractcore-2.4.4.dist-info → abstractcore-2.4.5.dist-info}/RECORD

@@ -11,6 +11,9 @@ abstractcore/architectures/enums.py,sha256=9vIv2vDBEKhxwzwH9iaSAyf-iVj3p8y9loMeN
 abstractcore/assets/architecture_formats.json,sha256=CIf6SaR_IJs1D7Uvd1K3zWngIXJ_yq3DM_IE3wnpCHY,16076
 abstractcore/assets/model_capabilities.json,sha256=iUkDiljyZUZzPlpYCOFgStXyc6e7dvOfReYQ0HFrX9Q,49703
 abstractcore/assets/session_schema.json,sha256=b6HTAWxRVlVhAzA7FqaKpunK1yO6jilBOsD5sQkqJTo,10580
+abstractcore/cli/__init__.py,sha256=rUjLjZSK3wENSw4g_iN43Bc2i5cggcEmj4NPXBMohdc,241
+abstractcore/cli/main.py,sha256=QD38nnfrInavO452WbkXCI37SVsdIu9VhvjEOojXBGY,31834
+abstractcore/cli/vision_config.py,sha256=jJzO4zBexh8SqSKp6YKOXdMDSv4AL4Ztl5Xi-5c4KyY,17869
 abstractcore/core/__init__.py,sha256=2h-86U4QkCQ4gzZ4iRusSTMlkODiUS6tKjZHiEXz6rM,684
 abstractcore/core/enums.py,sha256=BhkVnHC-X1_377JDmqd-2mnem9GdBLqixWlYzlP_FJU,695
 abstractcore/core/factory.py,sha256=UdrNwQAvifvFS3LMjF5KO87m-2n1bJBryTs9pvesYcI,2804
@@ -29,6 +32,17 @@ abstractcore/media/base.py,sha256=vWdxscqTGTvd3oc4IzzsBTWhUrznWcqM7M_sFyq6-eE,15
 abstractcore/media/capabilities.py,sha256=qqKvXGkUT-FNnbFS-EYx8KCT9SZOovO2h4N7ucrHgBA,12844
 abstractcore/media/types.py,sha256=jG-g_2_gzl8eOgEalk9x3Ikhni9GoGfoRjkZWaBhV30,10165
 abstractcore/media/vision_fallback.py,sha256=XcEV5T9ekqd4DRBrhJvxgX5j_puxSlofvuUIfQc2vmg,10629
+abstractcore/media/handlers/__init__.py,sha256=HBqFo15JX1q7RM11076iFQUfPvInLlOizX-LGSznLuI,404
+abstractcore/media/handlers/anthropic_handler.py,sha256=iwcHKnHgHoQGpJKlJmwFJWBvrYg9lAzAnndybwsWZRA,12427
+abstractcore/media/handlers/local_handler.py,sha256=xfMV2Ztre3eUkDno4aSGob96oWUlgicZ3VChs-txjXU,23033
+abstractcore/media/handlers/openai_handler.py,sha256=o0H_WQ_NQt133my55xYQmq6_QFGafghF8sPTrqr1f0Q,9726
+abstractcore/media/processors/__init__.py,sha256=tExCZwVhD9Qzn3D99-zQcU-T1324YtiLkWjIfWLC708,442
+abstractcore/media/processors/image_processor.py,sha256=wj-f1W71ZCs4AZdmyTKZvnMee83GkiXKuZ6QvJwd3Lo,22577
+abstractcore/media/processors/office_processor.py,sha256=MqhLDWNtjHEpiMgpFaf7tbj8iDcTCf_zelWrHZkr7Z4,18580
+abstractcore/media/processors/pdf_processor.py,sha256=qniYt7cTYYPVRi_cS1IsXztOldeY0bqdn7sdbELBU9k,17157
+abstractcore/media/processors/text_processor.py,sha256=E28FtT2_jzsvMIDwZi6aVWuu_pSyAPSBa96fe4YYcU8,21092
+abstractcore/media/utils/__init__.py,sha256=30-CTif91iRKOXJ4njGiduWAt-xp31U7NafMBNvgdO0,460
+abstractcore/media/utils/image_scaler.py,sha256=QrYqoNQc8tzGu7I9Sf_E-Iv7ei2oLh714AGiX3yACNM,11338
 abstractcore/processing/__init__.py,sha256=t6hiakQjcZROT4pw9ZFt2q6fF3vf5VpdMKG2EWlsFd8,540
 abstractcore/processing/basic_extractor.py,sha256=3x-3BdIHgLvqLnLF6K1-P4qVaLIpAnNIIutaJi7lDQM,49832
 abstractcore/processing/basic_judge.py,sha256=tKWJrg_tY4vCHzWgXxz0ZjgLXBYYfpMcpG7vl03hJcM,32218
@@ -63,10 +77,10 @@ abstractcore/utils/message_preprocessor.py,sha256=GdHkm6tmrgjm3PwHRSCjIsq1XLkbhy
 abstractcore/utils/self_fixes.py,sha256=QEDwNTW80iQM4ftfEY3Ghz69F018oKwLM9yeRCYZOvw,5886
 abstractcore/utils/structured_logging.py,sha256=Vm-HviSa42G9DJCWmaEv4a0QG3NMsADD3ictLOs4En0,19952
 abstractcore/utils/token_utils.py,sha256=eLwFmJ68p9WMFD_MHLMmeJRW6Oqx_4hKELB8FNQ2Mnk,21097
-abstractcore/utils/version.py,sha256=ykpU7S-ZbOgwDZo_6zYttC6y8VPe3CuV0anATrFRej8,605
-abstractcore-2.4.4.dist-info/licenses/LICENSE,sha256=PI2v_4HMvd6050uDD_4AY_8PzBnu2asa3RKbdDjowTA,1078
-abstractcore-2.4.4.dist-info/METADATA,sha256=h6Wn0s43Xlng3K0bOw4o1LcT293rVoRPgionXu3kQKg,27596
-abstractcore-2.4.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-abstractcore-2.4.4.dist-info/entry_points.txt,sha256=di-rxy4iD6A3j8DmQHeVmXYlncgCJKZGamyjrQXEfcU,357
-abstractcore-2.4.4.dist-info/top_level.txt,sha256=DiNHBI35SIawW3N9Z-z0y6cQYNbXd32pvBkW0RLfScs,13
-abstractcore-2.4.4.dist-info/RECORD,,
+abstractcore/utils/version.py,sha256=WKRMOS_TRIxsNu-vJqfCYHA335-rya9xBBMzhx_S-Z8,605
+abstractcore-2.4.5.dist-info/licenses/LICENSE,sha256=PI2v_4HMvd6050uDD_4AY_8PzBnu2asa3RKbdDjowTA,1078
+abstractcore-2.4.5.dist-info/METADATA,sha256=9w6Q7NZXePxhRYnmloyJ6Nd2DFQ7YY4294OMF-6QYuY,27596
+abstractcore-2.4.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+abstractcore-2.4.5.dist-info/entry_points.txt,sha256=UdVmchBC_Lt3H4Vlkt5js-QDAkVlBbkCu1yCsswk-KE,454
+abstractcore-2.4.5.dist-info/top_level.txt,sha256=DiNHBI35SIawW3N9Z-z0y6cQYNbXd32pvBkW0RLfScs,13
+abstractcore-2.4.5.dist-info/RECORD,,

{abstractcore-2.4.4.dist-info → abstractcore-2.4.5.dist-info}/entry_points.txt

@@ -1,5 +1,7 @@
 [console_scripts]
 abstractcore = abstractcore.cli.main:main
+abstractcore-chat = abstractcore.utils.cli:main
+abstractcore-config = abstractcore.cli.main:main
 abstractcore-extractor = abstractcore.apps.extractor:main
 abstractcore-judge = abstractcore.apps.judge:main
 abstractcore-summarizer = abstractcore.apps.summarizer:main