abstractcore 2.5.0__py3-none-any.whl → 2.5.3__py3-none-any.whl

abstractcore/media/handlers/openai_handler.py

@@ -30,6 +30,9 @@ class OpenAIMediaHandler(BaseProviderMediaHandler):
         """
         super().__init__("openai", model_capabilities, **kwargs)
 
+        # Store model name for Qwen-specific optimizations
+        self.model_name = kwargs.get('model_name', '')
+
         # OpenAI-specific configuration
         self.max_image_size = kwargs.get('max_image_size', 20 * 1024 * 1024)  # 20MB
         self.supported_image_detail = kwargs.get('supported_image_detail', ['auto', 'low', 'high'])
@@ -118,11 +121,64 @@ class OpenAIMediaHandler(BaseProviderMediaHandler):
         # Add detail level if supported by model
         if self.model_capabilities.get('vision_support'):
             detail_level = media_content.metadata.get('detail_level', 'auto')
+            self.logger.debug(f"OpenAI Handler - MediaContent metadata: {media_content.metadata}")
+            self.logger.debug(f"OpenAI Handler - Found detail_level: {detail_level}")
+            
+            # Auto-adjust detail level for Qwen models to prevent context overflow
+            if self._is_qwen_model() and detail_level == 'auto':
+                detail_level = self._get_optimal_detail_for_qwen(media_content)
+                self.logger.debug(f"OpenAI Handler - Qwen auto-adjusted detail_level: {detail_level}")
+            
             if detail_level in self.supported_image_detail:
                 image_obj["image_url"]["detail"] = detail_level
+                self.logger.info(f"OpenAI Handler - Setting detail level to '{detail_level}' for image")
+            else:
+                self.logger.warning(f"OpenAI Handler - Invalid detail level '{detail_level}', supported: {self.supported_image_detail}")
 
         return image_obj
 
+    def _is_qwen_model(self) -> bool:
+        """Check if the current model is a Qwen vision model."""
+        if not hasattr(self, 'model_name') or not self.model_name:
+            return False
+        
+        model_name_lower = self.model_name.lower()
+        return any(qwen_variant in model_name_lower for qwen_variant in [
+            'qwen3-vl', 'qwen2.5-vl', 'qwen-vl', 'qwen/qwen3-vl', 'qwen/qwen2.5-vl'
+        ])
+
+    def _get_optimal_detail_for_qwen(self, media_content: MediaContent) -> str:
+        """
+        Determine optimal detail level for Qwen models based on context constraints.
+        
+        According to SiliconFlow documentation:
+        - detail=low: 256 tokens per image (448x448 resize)
+        - detail=high: Variable tokens based on resolution (can be 24,576+ tokens)
+        
+        For Qwen3-VL-30B with 131,072 token context limit, we should use detail=low
+        when processing multiple images to avoid context overflow.
+        """
+        # Get model context limit
+        max_tokens = self.model_capabilities.get('max_tokens', 32768)
+        max_image_tokens = self.model_capabilities.get('max_image_tokens', 24576)
+        
+        # Estimate how many images we might be processing
+        # This is a heuristic - in practice we'd need the full batch context
+        estimated_images = getattr(self, '_estimated_image_count', 1)
+        
+        # Calculate potential token usage with high detail
+        high_detail_tokens = estimated_images * max_image_tokens
+        
+        # Use low detail if high detail would consume >60% of context
+        context_threshold = max_tokens * 0.6
+        
+        if high_detail_tokens > context_threshold:
+            self.logger.info(f"Using detail=low for Qwen model: {estimated_images} images would consume "
+                           f"{high_detail_tokens:,} tokens (>{context_threshold:,} threshold)")
+            return 'low'
+        else:
+            return 'high'
+
     def _format_text_for_openai(self, media_content: MediaContent) -> Dict[str, Any]:
         """
         Format text/document content for OpenAI API.
@@ -226,12 +282,15 @@ class OpenAIMediaHandler(BaseProviderMediaHandler):
             Estimated token count
         """
         if media_content.media_type == MediaType.IMAGE:
-            # OpenAI image token estimation
-            # Base cost varies by detail level and image size
+            # Image token estimation varies by model
             detail_level = media_content.metadata.get('detail_level', 'auto')
 
             if detail_level == 'low':
-                return 85  # Low detail images use 85 tokens
+                # Qwen models use 256 tokens for low detail, OpenAI uses 85
+                if self._is_qwen_model():
+                    return 256  # Qwen low detail token count
+                else:
+                    return 85   # OpenAI low detail token count
             else:
                 # High detail calculation based on image dimensions
                 width = media_content.metadata.get('final_size', [512, 512])[0]

abstractcore/media/processors/__init__.py

@@ -10,4 +10,14 @@ from .text_processor import TextProcessor
 from .pdf_processor import PDFProcessor
 from .office_processor import OfficeProcessor
 
-__all__ = ['ImageProcessor', 'TextProcessor', 'PDFProcessor', 'OfficeProcessor']
+# Import Glyph processor if available
+try:
+    from ...compression.glyph_processor import GlyphProcessor
+    GLYPH_AVAILABLE = True
+except ImportError:
+    GlyphProcessor = None
+    GLYPH_AVAILABLE = False
+
+__all__ = ['ImageProcessor', 'TextProcessor', 'PDFProcessor', 'OfficeProcessor']
+if GLYPH_AVAILABLE:
+    __all__.append('GlyphProcessor')

abstractcore/media/processors/direct_pdf_processor.py

@@ -0,0 +1,210 @@
+"""
+Direct PDF-to-image processor for Glyph compression.
+
+This processor converts PDF pages directly to images without text extraction,
+preserving all visual elements including mathematical formulas, tables, and images.
+Supports multi-page layouts (e.g., 2 pages per image) for optimal compression.
+"""
+
+from pathlib import Path
+from typing import Optional, Dict, Any, List, Union, Tuple
+import tempfile
+import os
+import hashlib
+import math
+
+try:
+    import pdf2image
+    PDF2IMAGE_AVAILABLE = True
+except ImportError:
+    PDF2IMAGE_AVAILABLE = False
+    pdf2image = None
+
+try:
+    from PIL import Image
+    PIL_AVAILABLE = True
+except ImportError:
+    PIL_AVAILABLE = False
+    Image = None
+
+from ..base import BaseMediaHandler, MediaProcessingError
+from ..types import MediaContent, MediaType, ContentFormat
+
+
+class DirectPDFProcessor(BaseMediaHandler):
+    """
+    Direct PDF-to-image processor that preserves all visual elements.
+    
+    Converts PDF pages directly to images without text extraction,
+    maintaining perfect fidelity of mathematical formulas, tables, and images.
+    """
+    
+    def __init__(self, **kwargs):
+        """Initialize the direct PDF processor."""
+        super().__init__(**kwargs)
+        
+        if not PDF2IMAGE_AVAILABLE:
+            raise MediaProcessingError("pdf2image is required for DirectPDFProcessor")
+        
+        if not PIL_AVAILABLE:
+            raise MediaProcessingError("PIL/Pillow is required for DirectPDFProcessor")
+        
+        # Configuration
+        self.pages_per_image = kwargs.get('pages_per_image', 2)  # 2 pages per image by default
+        self.dpi = kwargs.get('dpi', 150)  # Higher DPI for better quality
+        self.layout = kwargs.get('layout', 'horizontal')  # 'horizontal' or 'vertical'
+        self.gap = kwargs.get('gap', 20)  # Gap between pages in pixels
+        
+        self.logger.debug(f"DirectPDFProcessor initialized: {self.pages_per_image} pages per image")
+    
+    def _process_internal(self, file_path: Path, media_type: MediaType, **kwargs) -> MediaContent:
+        """Process PDF directly to images."""
+        if media_type != MediaType.DOCUMENT:
+            raise MediaProcessingError(f"DirectPDFProcessor only handles documents, got {media_type}")
+        
+        try:
+            # Convert PDF pages to images
+            image_paths = self._convert_pdf_to_combined_images(file_path)
+            
+            # For now, return the first combined image
+            # In a full implementation, this would return all images
+            if image_paths:
+                with open(image_paths[0], 'rb') as f:
+                    image_data = f.read()
+                
+                # Encode as base64 for MediaContent
+                import base64
+                encoded_data = base64.b64encode(image_data).decode('utf-8')
+                
+                # Get session info for metadata
+                from ...config import get_config_manager
+                config_manager = get_config_manager()
+                glyph_cache_base = Path(config_manager.config.cache.glyph_cache_dir).expanduser()
+                pdf_hash = hashlib.md5(str(file_path).encode()).hexdigest()[:8]
+                session_id = f"pdf_{pdf_hash}_{len(image_paths)}pages"
+                
+                metadata = {
+                    'processing_method': 'direct_pdf_conversion',
+                    'pages_per_image': self.pages_per_image,
+                    'total_images': len(image_paths),
+                    'dpi': self.dpi,
+                    'layout': self.layout,
+                    'image_paths': [str(p) for p in image_paths],
+                    'glyph_session_id': session_id,
+                    'glyph_cache_dir': str(glyph_cache_base / session_id)
+                }
+                
+                return self._create_media_content(
+                    content=encoded_data,
+                    file_path=file_path,
+                    media_type=MediaType.IMAGE,  # Return as image
+                    content_format=ContentFormat.BASE64,
+                    mime_type="image/png",
+                    **metadata
+                )
+            else:
+                raise MediaProcessingError("No images generated from PDF")
+                
+        except Exception as e:
+            raise MediaProcessingError(f"Failed to process PDF directly: {str(e)}") from e
+    
+    def _convert_pdf_to_combined_images(self, pdf_path: Path) -> List[Path]:
+        """Convert PDF to combined images with multiple pages per image."""
+        
+        # Convert all PDF pages to individual images
+        individual_images = pdf2image.convert_from_path(
+            pdf_path,
+            dpi=self.dpi,
+            fmt='PNG'
+        )
+        
+        self.logger.info(f"Converted PDF to {len(individual_images)} individual page images")
+        
+        # Use AbstractCore's centralized Glyph cache directory
+        from ...config import get_config_manager
+        config_manager = get_config_manager()
+        glyph_cache_base = Path(config_manager.config.cache.glyph_cache_dir).expanduser()
+        
+        # Calculate number of combined images that will be created
+        num_combined_images = math.ceil(len(individual_images) / self.pages_per_image)
+        
+        # Create a unique subdirectory for this PDF processing session
+        pdf_hash = hashlib.md5(str(pdf_path).encode()).hexdigest()[:8]
+        session_id = f"pdf_{pdf_hash}_{num_combined_images}pages"
+        glyph_dir = glyph_cache_base / session_id
+        glyph_dir.mkdir(parents=True, exist_ok=True)
+        
+        # CRITICAL DEBUG LOG: Show exactly where images are being generated
+        self.logger.debug(f"🎯 GENERATING GLYPH IMAGES IN CACHE DIRECTORY: {glyph_dir}")
+        self.logger.info(f"DirectPDFProcessor: Creating {self.pages_per_image} pages per image in {glyph_dir}")
+        
+        # Combine pages into multi-page images
+        combined_images = []
+        
+        try:
+            for i in range(0, len(individual_images), self.pages_per_image):
+                # Get pages for this combined image
+                pages_batch = individual_images[i:i + self.pages_per_image]
+                
+                # Create combined image
+                combined_image = self._combine_pages(pages_batch, i // self.pages_per_image)
+                
+                # Save combined image in Glyph cache
+                output_path = glyph_dir / f"image_{i // self.pages_per_image + 1:03d}.png"
+                combined_image.save(output_path, 'PNG', optimize=True)
+                combined_images.append(output_path)
+                
+                # CRITICAL DEBUG LOG: Show each image as it's created
+                self.logger.debug(f"📄 CREATED GLYPH IMAGE: {output_path} (pages {i+1}-{min(i+self.pages_per_image, len(individual_images))})")
+        
+        except Exception as e:
+            # Clean up cache directory on error
+            import shutil
+            shutil.rmtree(glyph_dir, ignore_errors=True)
+            raise e
+        
+        # CRITICAL DEBUG LOG: Final summary with exact paths
+        self.logger.info(f"Created {len(combined_images)} combined images from {len(individual_images)} pages")
+        self.logger.debug(f"🎯 ALL GLYPH IMAGES STORED IN CACHE: {glyph_dir}")
+        for i, img_path in enumerate(combined_images, 1):
+            self.logger.debug(f"   📄 Image {i}: {img_path}")
+        
+        return combined_images
+    
+    def _combine_pages(self, pages: List['Image.Image'], batch_index: int) -> 'Image.Image':
+        """Combine multiple PDF pages into a single image."""
+        if not pages:
+            raise ValueError("No pages to combine")
+        
+        if len(pages) == 1:
+            return pages[0]
+        
+        # Calculate dimensions for combined image
+        if self.layout == 'horizontal':
+            # Side-by-side layout (like an open book)
+            total_width = sum(page.width for page in pages) + self.gap * (len(pages) - 1)
+            total_height = max(page.height for page in pages)
+        else:
+            # Vertical layout (pages stacked)
+            total_width = max(page.width for page in pages)
+            total_height = sum(page.height for page in pages) + self.gap * (len(pages) - 1)
+        
+        # Create new image with white background
+        combined = Image.new('RGB', (total_width, total_height), 'white')
+        
+        # Paste pages into combined image
+        current_x, current_y = 0, 0
+        
+        for page in pages:
+            combined.paste(page, (current_x, current_y))
+            
+            if self.layout == 'horizontal':
+                current_x += page.width + self.gap
+            else:
+                current_y += page.height + self.gap
+        
+        return combined
+    
+    def get_combined_image_paths(self, pdf_path: Path) -> List[Path]:
+        """Get paths to all combined images (for external use)."""
+        return self._convert_pdf_to_combined_images(pdf_path)

abstractcore/media/processors/glyph_pdf_processor.py

@@ -0,0 +1,227 @@
+"""
+Glyph-optimized PDF processor that preserves mathematical notation and table formatting.
+
+This processor extracts PDF content while maintaining compact mathematical expressions
+and tabular data formatting for optimal visual compression.
+"""
+
+from pathlib import Path
+from typing import Optional, Dict, Any, List, Union, Tuple
+import re
+
+try:
+    import pymupdf as fitz
+    PYMUPDF_AVAILABLE = True
+except ImportError:
+    PYMUPDF_AVAILABLE = False
+    fitz = None
+
+from ..base import BaseMediaHandler, MediaProcessingError
+from ..types import MediaContent, MediaType, ContentFormat
+
+
+class GlyphPDFProcessor(BaseMediaHandler):
+    """
+    Glyph-optimized PDF processor that preserves mathematical notation and tables.
+    
+    Designed specifically for visual compression where maintaining compact
+    mathematical expressions and table layouts is crucial for compression ratio.
+    """
+    
+    def __init__(self, **kwargs):
+        """Initialize the Glyph PDF processor."""
+        super().__init__(**kwargs)
+        
+        if not PYMUPDF_AVAILABLE:
+            raise MediaProcessingError("PyMuPDF is required for GlyphPDFProcessor")
+        
+        # Glyph-specific settings
+        self.preserve_math_notation = kwargs.get('preserve_math_notation', True)
+        self.preserve_table_layout = kwargs.get('preserve_table_layout', True)
+        self.compact_whitespace = kwargs.get('compact_whitespace', True)
+        
+        self.logger.debug("GlyphPDFProcessor initialized for visual compression")
+    
+    def _process_internal(self, file_path: Path, media_type: MediaType, **kwargs) -> MediaContent:
+        """Process PDF with Glyph optimization."""
+        if media_type != MediaType.DOCUMENT:
+            raise MediaProcessingError(f"GlyphPDFProcessor only handles documents, got {media_type}")
+        
+        try:
+            # Extract content with Glyph optimizations
+            content, metadata = self._extract_glyph_optimized_content(file_path)
+            
+            return self._create_media_content(
+                content=content,
+                file_path=file_path,
+                media_type=media_type,
+                content_format=ContentFormat.TEXT,
+                mime_type="application/pdf",
+                **metadata
+            )
+            
+        except Exception as e:
+            raise MediaProcessingError(f"Failed to process PDF for Glyph: {str(e)}") from e
+    
+    def _extract_glyph_optimized_content(self, file_path: Path) -> Tuple[str, Dict[str, Any]]:
+        """Extract PDF content optimized for Glyph visual compression."""
+        doc = fitz.open(str(file_path))
+        
+        content_parts = []
+        total_chars = 0
+        page_count = 0
+        
+        try:
+            for page_num in range(len(doc)):
+                page = doc[page_num]
+                page_count += 1
+                
+                # Get text blocks with position information
+                blocks = page.get_text("dict")
+                
+                # Process blocks to preserve mathematical notation and tables
+                page_content = self._process_page_blocks(blocks, page_num)
+                
+                if page_content.strip():
+                    content_parts.append(page_content)
+                    total_chars += len(page_content)
+            
+            # Combine all pages
+            full_content = "\n\n".join(content_parts)
+            
+            # Apply Glyph-specific optimizations
+            optimized_content = self._apply_glyph_optimizations(full_content)
+            
+            metadata = {
+                'page_count': page_count,
+                'character_count': len(optimized_content),
+                'processing_method': 'glyph_optimized',
+                'math_notation_preserved': self.preserve_math_notation,
+                'table_layout_preserved': self.preserve_table_layout
+            }
+            
+            return optimized_content, metadata
+            
+        finally:
+            doc.close()
+    
+    def _process_page_blocks(self, blocks: Dict, page_num: int) -> str:
+        """Process page blocks while preserving mathematical and tabular content."""
+        page_lines = []
+        
+        for block in blocks.get("blocks", []):
+            if "lines" not in block:
+                continue
+            
+            # Check if this block looks like a table
+            if self._is_table_block(block):
+                table_content = self._extract_table_content(block)
+                if table_content:
+                    page_lines.append(table_content)
+            else:
+                # Process as regular text, preserving math notation
+                block_text = self._extract_block_text(block)
+                if block_text.strip():
+                    page_lines.append(block_text)
+        
+        return "\n".join(page_lines)
+    
+    def _is_table_block(self, block: Dict) -> bool:
+        """Detect if a block represents tabular data."""
+        lines = block.get("lines", [])
+        if len(lines) < 2:
+            return False
+        
+        # Look for patterns indicating tabular structure
+        # - Multiple columns of aligned text
+        # - Consistent spacing patterns
+        # - Numeric data in columns
+        
+        x_positions = []
+        for line in lines:
+            for span in line.get("spans", []):
+                bbox = span.get("bbox", [])
+                if len(bbox) >= 4:
+                    x_positions.append(bbox[0])  # Left x coordinate
+        
+        if len(x_positions) < 4:
+            return False
+        
+        # Check for multiple distinct column positions
+        unique_x = sorted(set(round(x, 1) for x in x_positions))
+        return len(unique_x) >= 3  # At least 3 columns suggests a table
+    
+    def _extract_table_content(self, block: Dict) -> str:
+        """Extract table content in a compact format."""
+        lines = block.get("lines", [])
+        table_rows = []
+        
+        for line in lines:
+            row_parts = []
+            spans = sorted(line.get("spans", []), key=lambda s: s.get("bbox", [0])[0])
+            
+            for span in spans:
+                text = span.get("text", "").strip()
+                if text:
+                    row_parts.append(text)
+            
+            if row_parts:
+                # Use compact table format (pipe-separated)
+                table_rows.append(" | ".join(row_parts))
+        
+        if table_rows:
+            return "\n".join(table_rows)
+        return ""
+    
+    def _extract_block_text(self, block: Dict) -> str:
+        """Extract text from a block, preserving mathematical notation."""
+        lines = block.get("lines", [])
+        block_lines = []
+        
+        for line in lines:
+            line_text = ""
+            for span in line.get("spans", []):
+                text = span.get("text", "")
+                
+                # Preserve mathematical symbols and notation
+                if self.preserve_math_notation:
+                    text = self._preserve_math_symbols(text)
+                
+                line_text += text
+            
+            if line_text.strip():
+                block_lines.append(line_text.strip())
+        
+        return "\n".join(block_lines)
+    
+    def _preserve_math_symbols(self, text: str) -> str:
+        """Preserve mathematical symbols and compact notation."""
+        # Don't expand mathematical symbols - keep them as-is
+        # This prevents "α" from becoming "alpha", "∑" from becoming "sum", etc.
+        
+        # Remove excessive whitespace around mathematical operators
+        text = re.sub(r'\s*([+\-×÷=<>≤≥≠∈∉∪∩∀∃∑∏∫])\s*', r'\1', text)
+        
+        # Preserve subscripts and superscripts in compact form
+        # Keep Unicode mathematical symbols intact
+        
+        return text
+    
+    def _apply_glyph_optimizations(self, content: str) -> str:
+        """Apply final optimizations for Glyph visual compression."""
+        if not self.compact_whitespace:
+            return content
+        
+        # Remove excessive blank lines (keep max 1)
+        content = re.sub(r'\n\s*\n\s*\n+', '\n\n', content)
+        
+        # Remove trailing whitespace
+        lines = [line.rstrip() for line in content.split('\n')]
+        
+        # Remove excessive spaces (keep max 2 consecutive spaces)
+        optimized_lines = []
+        for line in lines:
+            line = re.sub(r'  +', '  ', line)  # Max 2 spaces
+            optimized_lines.append(line)
+        
+        return '\n'.join(optimized_lines)

abstractcore/media/processors/image_processor.py

@@ -5,6 +5,8 @@ This module provides comprehensive image processing capabilities using PIL,
 optimized for vision model inputs across different providers.
 """
 
+from __future__ import annotations  # PEP 563 - deferred type hint evaluation for optional dependencies
+
 import base64
 import io
 import mimetypes
@@ -99,7 +101,11 @@ class ImageProcessor(BaseMediaHandler):
 
         try:
             # Override defaults with kwargs
-            target_format = kwargs.get('target_format', 'jpeg')
+            # Preserve original format unless explicitly specified
+            original_format = file_path.suffix.lower().lstrip('.')
+            if original_format == 'jpg':
+                original_format = 'jpeg'
+            target_format = kwargs.get('target_format', original_format if original_format in ['png', 'jpeg', 'webp', 'gif'] else 'jpeg')
             model_name = kwargs.get('model_name', None)
 
             # Use model-specific maximum resolution if available

abstractcore/media/processors/text_processor.py

@@ -50,12 +50,25 @@ class TextProcessor(BaseMediaHandler):
 
         # Set capabilities for text processing
         from ..types import MediaCapabilities
+        # TextProcessor can handle any text file through its plain text fallback
+        # We list common formats but the processor is not limited to these
         self.capabilities = MediaCapabilities(
             vision_support=False,
             audio_support=False,
             video_support=False,
             document_support=True,
-            supported_document_formats=['txt', 'md', 'csv', 'tsv', 'json', 'xml', 'html', 'htm'],
+            supported_document_formats=[
+                # Core text formats
+                'txt', 'md', 'markdown', 'csv', 'tsv',
+                'json', 'jsonl', 'xml', 'html', 'htm',
+                'yaml', 'yml', 'toml', 'ini', 'cfg', 'conf',
+                # Programming languages (common examples)
+                'py', 'js', 'java', 'c', 'cpp', 'go', 'rs', 'rb', 'php',
+                'r', 'R', 'rmd', 'Rmd', 'sql', 'sh',
+                # Notebooks and documentation
+                'ipynb', 'qmd', 'rst', 'tex', 'bib',
+                # Any other text-based format through fallback processing
+            ],
             max_file_size=self.max_file_size
         )
 
@@ -541,7 +554,8 @@ class TextProcessor(BaseMediaHandler):
         """
         return {
             'processor_type': 'TextProcessor',
-            'supported_formats': ['txt', 'md', 'csv', 'tsv', 'json', 'xml', 'html', 'htm'],
+            'supported_formats': self.capabilities.supported_document_formats,
+            'supports_any_text_file': True,  # Through plain text fallback
             'capabilities': {
                 'default_encoding': self.default_encoding,
                 'csv_delimiter': self.csv_delimiter,
@@ -549,7 +563,8 @@ class TextProcessor(BaseMediaHandler):
                 'preserve_structure': self.preserve_structure,
                 'pandas_integration': PANDAS_AVAILABLE,
                 'structured_formatting': True,
-                'metadata_extraction': True
+                'metadata_extraction': True,
+                'plain_text_fallback': True  # Can handle any text file
             },
             'dependencies': {
                 'pandas': PANDAS_AVAILABLE