abstractcore 2.5.2__py3-none-any.whl → 2.6.0__py3-none-any.whl

abstractcore/compression/config.py

@@ -0,0 +1,279 @@
+"""
+Glyph compression configuration classes.
+"""
+
+import os
+from dataclasses import dataclass, field
+from typing import Dict, Optional, Any
+from pathlib import Path
+
+
+@dataclass
+class RenderingConfig:
+    """Configuration for text rendering to images."""
+    
+    # Font configuration (EXTREME density optimization)
+    font_path: str = "Verdana.ttf"
+    font_name: Optional[str] = "OCRB"  # Default to OCRB for optimal readability
+    font_size: int = 7  # Minimum readable font size
+    line_height: int = 8  # Ultra-tight line spacing
+    
+    # Layout configuration (VLM-optimized defaults)
+    dpi: int = 72  # 72 for higher compression, 96 for better quality
+    target_width: Optional[int] = None  # Target image width in pixels (default: 1024 for VLMs)
+    target_height: Optional[int] = None  # Target image height in pixels (default: 768 for VLMs)
+    margin_x: int = 10  # Generous margins for better readability
+    margin_y: int = 10  # Generous margins for better readability
+    page_width: int = 595  # A4 width in points (used when target dimensions not set)
+    page_height: int = 842  # A4 height in points (used when target dimensions not set)
+    
+    # Optimization settings
+    auto_crop_width: bool = True
+    auto_crop_last_page: bool = True
+    newline_markup: str = '<font color="#FF0000"> \\n </font>'
+    
+    # Multi-column layout (optimized for readability)
+    columns: int = 2  # 2-column layout for optimal balance
+    column_gap: int = 10  # Optimal gap between columns
+    
+    # Text formatting options
+    render_format: bool = True  # Enable markdown-like formatting
+    
+    def copy(self) -> 'RenderingConfig':
+        """Create a copy of this configuration."""
+        return RenderingConfig(
+            font_path=self.font_path,
+            font_name=self.font_name,
+            font_size=self.font_size,
+            line_height=self.line_height,
+            dpi=self.dpi,
+            target_width=self.target_width,
+            target_height=self.target_height,
+            margin_x=self.margin_x,
+            margin_y=self.margin_y,
+            page_width=self.page_width,
+            page_height=self.page_height,
+            auto_crop_width=self.auto_crop_width,
+            auto_crop_last_page=self.auto_crop_last_page,
+            newline_markup=self.newline_markup,
+            columns=self.columns,
+            column_gap=self.column_gap,
+            render_format=self.render_format
+        )
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary."""
+        return {
+            'font_path': self.font_path,
+            'font_name': self.font_name,
+            'font_size': self.font_size,
+            'line_height': self.line_height,
+            'dpi': self.dpi,
+            'target_width': self.target_width,
+            'target_height': self.target_height,
+            'margin_x': self.margin_x,
+            'margin_y': self.margin_y,
+            'page_width': self.page_width,
+            'page_height': self.page_height,
+            'auto_crop_width': self.auto_crop_width,
+            'auto_crop_last_page': self.auto_crop_last_page,
+            'newline_markup': self.newline_markup,
+            'columns': self.columns,
+            'column_gap': self.column_gap,
+            'render_format': self.render_format
+        }
+
+
+@dataclass
+class GlyphConfig:
+    """Main configuration for Glyph compression."""
+    
+    # Core settings
+    enabled: bool = True
+    global_default: str = "auto"  # auto, always, never
+    quality_threshold: float = 0.95
+    min_token_threshold: int = 10000  # Minimum tokens to consider compression
+    target_compression_ratio: float = 3.0
+    
+    # Cache settings
+    cache_directory: str = field(default_factory=lambda: str(Path.home() / ".abstractcore" / "glyph_cache"))
+    cache_size_gb: float = 1.0
+    cache_ttl_days: int = 7
+    
+    # Provider optimization
+    provider_optimization: bool = True
+    preferred_provider: str = "openai/gpt-4o"
+    
+    # Rendering configuration
+    rendering: RenderingConfig = field(default_factory=RenderingConfig)
+    
+    # App-specific defaults
+    app_defaults: Dict[str, str] = field(default_factory=dict)
+    
+    # Provider-specific profiles
+    provider_profiles: Dict[str, Dict[str, Any]] = field(default_factory=dict)
+    
+    # Processing settings
+    temp_dir: Optional[str] = None
+    max_concurrent_compressions: int = 2
+    processing_timeout: int = 300  # 5 minutes
+    
+    @classmethod
+    def default(cls) -> 'GlyphConfig':
+        """Create default configuration."""
+        config = cls()
+        
+        # Set up default provider profiles based on Glyph research
+        config.provider_profiles = {
+            "openai": {
+                "dpi": 72,
+                "font_size": 9,
+                "quality_threshold": 0.93,
+                "newline_markup": '<font color="#FF0000"> \\n </font>'
+            },
+            "anthropic": {
+                "dpi": 96,
+                "font_size": 10,
+                "quality_threshold": 0.96,
+                "font_path": "Verdana.ttf"
+            },
+            "ollama": {
+                "dpi": 72,
+                "font_size": 9,
+                "auto_crop_width": True,
+                "auto_crop_last_page": True
+            },
+            "lmstudio": {
+                "dpi": 96,
+                "font_size": 10,
+                "quality_threshold": 0.94
+            }
+        }
+        
+        # Set up default app preferences
+        config.app_defaults = {
+            "summarizer": "always",
+            "extractor": "never", 
+            "judge": "auto",
+            "cli": "auto"
+        }
+        
+        return config
+    
+    @classmethod
+    def from_abstractcore_config(cls) -> 'GlyphConfig':
+        """Load Glyph config from AbstractCore's centralized configuration."""
+        try:
+            # Try to load from AbstractCore config system
+            from ..config import get_config_manager
+            config_manager = get_config_manager()
+            
+            # Check if glyph_compression section exists
+            if hasattr(config_manager.config, 'glyph_compression'):
+                glyph_section = config_manager.config.glyph_compression
+                config = cls.default()
+                
+                # Update with user settings
+                config.enabled = getattr(glyph_section, 'enabled', config.enabled)
+                config.global_default = getattr(glyph_section, 'global_default', config.global_default)
+                config.quality_threshold = getattr(glyph_section, 'quality_threshold', config.quality_threshold)
+                config.cache_directory = getattr(glyph_section, 'cache_directory', config.cache_directory)
+                config.preferred_provider = getattr(glyph_section, 'preferred_provider', config.preferred_provider)
+                
+                # Update app defaults
+                if hasattr(glyph_section, 'app_defaults'):
+                    config.app_defaults.update(glyph_section.app_defaults)
+                
+                # Update provider profiles
+                if hasattr(glyph_section, 'provider_profiles'):
+                    for provider, profile in glyph_section.provider_profiles.items():
+                        if provider in config.provider_profiles:
+                            config.provider_profiles[provider].update(profile)
+                        else:
+                            config.provider_profiles[provider] = profile
+                
+                return config
+            else:
+                # No glyph config section, return defaults
+                return cls.default()
+                
+        except (ImportError, AttributeError):
+            # Fallback to default if config system not available
+            return cls.default()
+    
+    def save_to_abstractcore_config(self):
+        """Save Glyph config to AbstractCore's centralized configuration."""
+        try:
+            # Try to save to AbstractCore config system
+            from ..config import get_config_manager
+            config_manager = get_config_manager()
+            
+            # Create glyph_compression section
+            glyph_config = {
+                'enabled': self.enabled,
+                'global_default': self.global_default,
+                'quality_threshold': self.quality_threshold,
+                'cache_directory': self.cache_directory,
+                'preferred_provider': self.preferred_provider,
+                'app_defaults': self.app_defaults,
+                'provider_profiles': self.provider_profiles
+            }
+            
+            # Save configuration
+            config_manager.set_glyph_compression(glyph_config)
+            config_manager.save()
+            
+        except (ImportError, AttributeError):
+            # Silently fail if config system not available
+            # Could implement file-based fallback here if needed
+            pass
+    
+    def get_provider_config(self, provider: str, model: str = None) -> RenderingConfig:
+        """Get provider-specific rendering configuration."""
+        base_config = self.rendering.copy()
+        
+        # Apply provider-specific settings
+        if provider in self.provider_profiles:
+            profile = self.provider_profiles[provider]
+            
+            # Update rendering config with provider settings
+            if 'dpi' in profile:
+                base_config.dpi = profile['dpi']
+            if 'font_size' in profile:
+                base_config.font_size = profile['font_size']
+            if 'font_path' in profile:
+                base_config.font_path = profile['font_path']
+            if 'newline_markup' in profile:
+                base_config.newline_markup = profile['newline_markup']
+            if 'auto_crop_width' in profile:
+                base_config.auto_crop_width = profile['auto_crop_width']
+            if 'auto_crop_last_page' in profile:
+                base_config.auto_crop_last_page = profile['auto_crop_last_page']
+        
+        return base_config
+    
+    def should_compress(self, content_length: int, provider: str, model: str, user_preference: str = None) -> bool:
+        """Determine if content should be compressed."""
+        # Check user preference first
+        preference = user_preference or self.global_default
+        
+        if preference == "never":
+            return False
+        elif preference == "always":
+            return True
+        
+        # Auto-decision logic
+        if content_length < self.min_token_threshold:
+            return False  # Too small to benefit
+        
+        # Check if provider supports vision
+        try:
+            from ..media.capabilities import get_model_capabilities
+            capabilities = get_model_capabilities(provider, model)
+            if not capabilities.get('vision_support', False):
+                return False  # Provider doesn't support vision
+        except:
+            # Conservative approach if capabilities unknown
+            return False
+        
+        return True  # Beneficial for large content with vision support

abstractcore/compression/exceptions.py

@@ -0,0 +1,30 @@
+"""
+Glyph compression exceptions.
+"""
+
+from ..exceptions import AbstractCoreError
+
+
+class CompressionError(AbstractCoreError):
+    """Base exception for compression-related errors."""
+    pass
+
+
+class CompressionQualityError(CompressionError):
+    """Exception raised when compression quality is below threshold."""
+    
+    def __init__(self, message: str, quality_score: float = None, threshold: float = None):
+        super().__init__(message)
+        self.quality_score = quality_score
+        self.threshold = threshold
+
+
+class RenderingError(CompressionError):
+    """Exception raised when text rendering fails."""
+    pass
+
+
+class CompressionCacheError(CompressionError):
+    """Exception raised when compression cache operations fail."""
+    pass
+

abstractcore/compression/glyph_processor.py

@@ -0,0 +1,381 @@
+"""
+Glyph visual-text compression processor for AbstractCore.
+
+Based on the actual Glyph implementation using reportlab for PDF generation
+and pdf2image for conversion, with provider-specific optimization.
+"""
+
+import time
+import json
+from pathlib import Path
+from typing import List, Optional, Union, Dict, Any
+
+from ..media.base import BaseMediaHandler
+from ..media.types import MediaContent, MediaType, ContentFormat
+from ..utils.structured_logging import get_logger
+from ..utils.token_utils import TokenUtils
+
+from .config import GlyphConfig, RenderingConfig
+from .quality import QualityValidator, CompressionStats
+from .cache import CompressionCache
+# ReportLab renderers removed - now using PIL renderer exclusively
+from .pil_text_renderer import PILTextRenderer
+from .text_formatter import TextFormatter, FormattingConfig
+from .exceptions import CompressionError, CompressionQualityError
+
+
+class GlyphProcessor(BaseMediaHandler):
+    """
+    Glyph visual-text compression processor for AbstractCore.
+    
+    Transforms long textual sequences into optimized images for processing
+    by Vision-Language Models (VLMs), achieving 3-4x token compression.
+    """
+    
+    def __init__(self, config: Optional[GlyphConfig] = None, **kwargs):
+        """
+        Initialize Glyph processor.
+        
+        Args:
+            config: Glyph configuration
+            **kwargs: Additional configuration passed to base handler
+        """
+        super().__init__(**kwargs)
+        
+        self.config = config or GlyphConfig.from_abstractcore_config()
+        self.logger = get_logger(self.__class__.__name__)
+        
+        # Initialize components
+        self.pil_text_renderer = None  # Lazy initialization
+        self.quality_validator = QualityValidator()
+        self.cache = CompressionCache(
+            cache_dir=self.config.cache_directory,
+            max_size_gb=self.config.cache_size_gb,
+            ttl_days=self.config.cache_ttl_days
+        )
+        
+        # Initialize text formatter
+        self.text_formatter = TextFormatter(FormattingConfig())
+        
+        # Load provider profiles
+        self.provider_profiles = self.config.provider_profiles
+        
+        self.logger.debug("GlyphProcessor initialized")
+    
+    def _get_pil_text_renderer(self) -> 'PILTextRenderer':
+        """Get or create PIL text renderer instance (lazy initialization)."""
+        if self.pil_text_renderer is None:
+            self.pil_text_renderer = PILTextRenderer(self.config)
+        return self.pil_text_renderer
+    
+    def can_process(self, content: str, provider: str, model: str) -> bool:
+        """
+        Determine if content should be compressed using Glyph.
+        
+        Args:
+            content: Text content to evaluate
+            provider: Provider name
+            model: Model name
+            
+        Returns:
+            True if compression should be applied
+        """
+        # Check if compression is enabled
+        if not self.config.enabled:
+            return False
+        
+        # Estimate token count
+        token_count = TokenUtils.estimate_tokens(content, model)
+        
+        # Check minimum token threshold
+        if token_count < self.config.min_token_threshold:
+            return False
+        
+        # Check if provider supports vision
+        try:
+            # Lazy import to avoid circular dependency
+            from ..media.capabilities import get_model_capabilities
+            capabilities = get_model_capabilities(provider, model)
+            if not capabilities.get('vision_support', False):
+                return False
+        except Exception:
+            # Conservative approach if capabilities unknown
+            return False
+        
+        return True
+    
+    def process_text(self, content: str, provider: str = None, model: str = None, user_preference: str = "auto") -> List[MediaContent]:
+        """
+        Process text content into compressed visual format.
+        
+        Args:
+            content: Text content to compress
+            provider: Provider name for optimization
+            model: Model name for optimization
+            
+        Returns:
+            List of MediaContent objects with compressed images
+        """
+        start_time = time.time()
+        
+        try:
+            # Get provider-specific configuration
+            render_config = self._get_provider_config(provider, model)
+            
+            # Apply text formatting if enabled
+            processed_content = content
+            text_segments = None
+            if render_config.render_format:
+                self.logger.debug("Applying text formatting")
+                text_segments = self.text_formatter.format_text(content)
+                # For now, convert back to string for compatibility with existing renderer
+                processed_content = self.text_formatter.format_text_to_string(content)
+                self.logger.debug("Text formatting applied", 
+                                original_length=len(content),
+                                formatted_length=len(processed_content),
+                                segments_count=len(text_segments))
+            else:
+                self.logger.debug("Text formatting disabled, using raw content")
+            
+            # Check cache first (use processed content for cache key)
+            cache_key = self._generate_cache_key(processed_content, render_config)
+            if cached_result := self.cache.get(cache_key):
+                self.logger.debug(f"Using cached compression for key {cache_key[:16]}...")
+                return self._create_media_content_from_images(cached_result, processed_content, provider, render_config)
+            
+            # Always use PIL text renderer (ReportLab removed)
+            self.logger.debug("Using PIL text renderer")
+            pil_renderer = self._get_pil_text_renderer()
+            
+            if render_config.render_format and text_segments:
+                # Use formatted text segments
+                self.logger.debug("Rendering with text formatting")
+                images = pil_renderer.segments_to_images(
+                    segments=text_segments,
+                    config=render_config,
+                    output_dir=self.config.temp_dir,
+                    unique_id=cache_key[:16]
+                )
+            else:
+                # Convert plain text to segments for PIL renderer
+                self.logger.debug("Rendering plain text (no formatting)")
+                from .text_formatter import TextSegment
+                plain_segments = [TextSegment(text=processed_content)]
+                images = pil_renderer.segments_to_images(
+                    segments=plain_segments,
+                config=render_config,
+                output_dir=self.config.temp_dir,
+                unique_id=cache_key[:16]
+            )
+            
+            # Quality validation (bypass if user explicitly wants compression)
+            quality_score = self.quality_validator.assess(content, images, provider)
+            min_threshold = self.quality_validator.get_provider_threshold(provider)
+            
+            if user_preference != "always" and quality_score < min_threshold:
+                raise CompressionQualityError(
+                    f"Compression quality {quality_score:.3f} below threshold {min_threshold:.3f} for {provider}",
+                    quality_score=quality_score,
+                    threshold=min_threshold
+                )
+            elif user_preference == "always" and quality_score < min_threshold:
+                self.logger.warning(f"Compression quality {quality_score:.3f} below threshold {min_threshold:.3f} for {provider}, but proceeding due to 'always' preference")
+            
+            # Calculate compression statistics
+            original_tokens = TokenUtils.estimate_tokens(processed_content, model)
+            # Calculate accurate token count using proper VLM token calculation
+            from ..utils.vlm_token_calculator import VLMTokenCalculator
+            from pathlib import Path
+            
+            calculator = VLMTokenCalculator()
+            try:
+                # Extract image paths from MediaContent objects
+                image_paths = []
+                for img in images:
+                    if hasattr(img, 'metadata') and img.metadata.get('temp_file_path'):
+                        image_paths.append(Path(img.metadata['temp_file_path']))
+                    elif hasattr(img, 'file_path') and img.file_path:
+                        image_paths.append(Path(img.file_path))
+                
+                if image_paths:
+                    token_analysis = calculator.calculate_tokens_for_images(
+                        image_paths=image_paths,
+                        provider=provider or 'openai',
+                        model=model or ''
+                    )
+                    compressed_tokens = token_analysis['total_tokens']
+                    self.logger.info(f"Accurate token calculation: {compressed_tokens} tokens for {len(image_paths)} images")
+                else:
+                    # Fallback calculation
+                    base_tokens = calculator.PROVIDER_CONFIGS.get(provider or 'openai', {}).get('base_tokens', 512)
+                    compressed_tokens = len(images) * base_tokens
+                    self.logger.warning(f"Using fallback token estimation: {compressed_tokens} tokens")
+                    
+            except Exception as e:
+                self.logger.warning(f"VLM token calculation failed, using fallback: {e}")
+                compressed_tokens = len(images) * 1500  # Conservative fallback
+            compression_ratio = original_tokens / compressed_tokens if compressed_tokens > 0 else 1.0
+            
+            compression_stats = CompressionStats(
+                compression_ratio=compression_ratio,
+                quality_score=quality_score,
+                token_savings=original_tokens - compressed_tokens,
+                processing_time=time.time() - start_time,
+                provider_optimized=provider or "unknown",
+                original_tokens=original_tokens,
+                compressed_tokens=compressed_tokens
+            )
+            
+            # Cache successful compression
+            self.cache.set(cache_key, images, compression_stats.to_dict())
+            
+            # Create MediaContent objects
+            media_contents = self._create_media_content_from_images(
+                images, processed_content, provider, render_config, compression_stats
+            )
+            
+            self.logger.info(
+                f"Glyph compression completed: {compression_ratio:.1f}x ratio, "
+                f"{quality_score:.1%} quality, {len(images)} images"
+            )
+            
+            return media_contents
+            
+        except Exception as e:
+            self.logger.error(f"Glyph compression failed: {e}")
+            raise CompressionError(f"Compression failed: {e}") from e
+    
+    def _get_provider_config(self, provider: str, model: str) -> RenderingConfig:
+        """Get provider-specific rendering configuration."""
+        return self.config.get_provider_config(provider, model)
+    
+    def _generate_cache_key(self, content: str, config: RenderingConfig) -> str:
+        """Generate cache key from content and configuration."""
+        import hashlib
+        
+        # Create hash of content + configuration
+        content_hash = hashlib.sha256(content.encode('utf-8')).hexdigest()[:16]
+        config_hash = hashlib.sha256(
+            json.dumps(config.to_dict(), sort_keys=True).encode('utf-8')
+        ).hexdigest()[:8]
+        
+        return f"{content_hash}_{config_hash}"
+    
+    def _create_media_content_from_images(
+        self, 
+        images: List[Path], 
+        original_content: str,
+        provider: str,
+        render_config: RenderingConfig,
+        compression_stats: Optional[CompressionStats] = None
+    ) -> List[MediaContent]:
+        """Create MediaContent objects from rendered images."""
+        import base64
+        
+        media_contents = []
+        
+        for i, img_path in enumerate(images):
+            if not img_path.exists():
+                continue
+            
+            # Read and encode image
+            with open(img_path, 'rb') as f:
+                image_data = f.read()
+            
+            base64_data = base64.b64encode(image_data).decode('utf-8')
+            
+            # Create metadata
+            metadata = {
+                "compression_ratio": compression_stats.compression_ratio if compression_stats else None,
+                "quality_score": compression_stats.quality_score if compression_stats else None,
+                "rendering_config": render_config.to_dict(),
+                "provider_optimized": provider,
+                "glyph_version": "1.0",
+                "processing_time": compression_stats.processing_time if compression_stats else None,
+                "image_index": i,
+                "total_images": len(images),
+                "original_content_length": len(original_content),
+                "dpi": render_config.dpi,
+                "font_config": {
+                    "font_path": render_config.font_path,
+                    "font_size": render_config.font_size,
+                    "line_height": render_config.line_height
+                }
+            }
+            
+            # Create MediaContent
+            media_content = MediaContent(
+                media_type=MediaType.IMAGE,
+                content=base64_data,
+                content_format=ContentFormat.BASE64,
+                mime_type="image/png",
+                file_path=str(img_path),
+                metadata=metadata
+            )
+            
+            media_contents.append(media_content)
+        
+        return media_contents
+    
+    def _process_internal(self, file_path: Path, media_type: MediaType, **kwargs) -> MediaContent:
+        """
+        Internal processing method for file-based compression.
+        
+        Args:
+            file_path: Path to text file
+            media_type: Detected media type
+            **kwargs: Additional parameters including provider and model
+            
+        Returns:
+            MediaContent with compressed representation
+        """
+        # Read file content
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+        except Exception as e:
+            raise CompressionError(f"Failed to read file {file_path}: {e}")
+        
+        # Extract provider and model from kwargs
+        provider = kwargs.get('provider')
+        model = kwargs.get('model')
+        
+        # Process text content
+        media_contents = self.process_text(content, provider, model)
+        
+        # Return first image (for single file processing)
+        if media_contents:
+            return media_contents[0]
+        else:
+            raise CompressionError("No compressed content generated")
+    
+    def supports_media_type(self, media_type: MediaType) -> bool:
+        """Check if this processor supports the media type."""
+        # Glyph processor handles text content for compression
+        return media_type in [MediaType.TEXT, MediaType.DOCUMENT]
+    
+    def supports_format(self, media_type: MediaType, format_ext: str) -> bool:
+        """Check if this processor supports the format."""
+        if media_type in [MediaType.TEXT, MediaType.DOCUMENT]:
+            # Support text-based formats
+            supported_formats = {'txt', 'md', 'csv', 'tsv', 'json', 'yaml', 'yml'}
+            return format_ext.lower() in supported_formats
+        return False
+    
+    def get_compression_stats(self) -> Dict[str, Any]:
+        """Get compression statistics."""
+        cache_stats = self.cache.get_stats()
+        
+        return {
+            'processor': 'GlyphProcessor',
+            'version': '1.0',
+            'cache_stats': cache_stats,
+            'config': {
+                'enabled': self.config.enabled,
+                'quality_threshold': self.config.quality_threshold,
+                'min_token_threshold': self.config.min_token_threshold,
+                'target_compression_ratio': self.config.target_compression_ratio
+            },
+            'provider_profiles': list(self.provider_profiles.keys())
+        }
+