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

abstractcore/media/types.py

@@ -207,15 +207,51 @@ FILE_TYPE_MAPPINGS = {
     'gif': MediaType.IMAGE, 'bmp': MediaType.IMAGE, 'tif': MediaType.IMAGE,
     'tiff': MediaType.IMAGE, 'webp': MediaType.IMAGE, 'ico': MediaType.IMAGE,
 
-    # Documents
+    # Documents (binary formats that need special processing)
     'pdf': MediaType.DOCUMENT, 'doc': MediaType.DOCUMENT, 'docx': MediaType.DOCUMENT,
     'xls': MediaType.DOCUMENT, 'xlsx': MediaType.DOCUMENT, 'ppt': MediaType.DOCUMENT,
     'pptx': MediaType.DOCUMENT, 'odt': MediaType.DOCUMENT, 'rtf': MediaType.DOCUMENT,
 
-    # Text formats
-    'txt': MediaType.TEXT, 'md': MediaType.TEXT, 'csv': MediaType.TEXT,
-    'tsv': MediaType.TEXT, 'json': MediaType.TEXT, 'xml': MediaType.TEXT,
-    'html': MediaType.TEXT, 'htm': MediaType.TEXT,
+    # Text formats - Common markup and data formats
+    'txt': MediaType.TEXT, 'md': MediaType.TEXT, 'markdown': MediaType.TEXT,
+    'csv': MediaType.TEXT, 'tsv': MediaType.TEXT,
+    'json': MediaType.TEXT, 'jsonl': MediaType.TEXT, 'ndjson': MediaType.TEXT,
+    'xml': MediaType.TEXT, 'html': MediaType.TEXT, 'htm': MediaType.TEXT,
+    'yaml': MediaType.TEXT, 'yml': MediaType.TEXT, 'toml': MediaType.TEXT,
+    'ini': MediaType.TEXT, 'cfg': MediaType.TEXT, 'conf': MediaType.TEXT,
+
+    # Text formats - Programming and scripting languages
+    'py': MediaType.TEXT, 'pyw': MediaType.TEXT, 'pyx': MediaType.TEXT,
+    'js': MediaType.TEXT, 'jsx': MediaType.TEXT, 'ts': MediaType.TEXT, 'tsx': MediaType.TEXT,
+    'java': MediaType.TEXT, 'kt': MediaType.TEXT, 'scala': MediaType.TEXT,
+    'c': MediaType.TEXT, 'cpp': MediaType.TEXT, 'cc': MediaType.TEXT, 'cxx': MediaType.TEXT,
+    'h': MediaType.TEXT, 'hpp': MediaType.TEXT, 'hxx': MediaType.TEXT,
+    'cs': MediaType.TEXT, 'go': MediaType.TEXT, 'rs': MediaType.TEXT, 'swift': MediaType.TEXT,
+    'rb': MediaType.TEXT, 'php': MediaType.TEXT, 'pl': MediaType.TEXT, 'pm': MediaType.TEXT,
+    'sh': MediaType.TEXT, 'bash': MediaType.TEXT, 'zsh': MediaType.TEXT, 'fish': MediaType.TEXT,
+    'r': MediaType.TEXT, 'R': MediaType.TEXT, 'rmd': MediaType.TEXT, 'Rmd': MediaType.TEXT,
+    'jl': MediaType.TEXT, 'matlab': MediaType.TEXT, 'm': MediaType.TEXT,
+    'sql': MediaType.TEXT, 'lua': MediaType.TEXT, 'vim': MediaType.TEXT,
+    'dart': MediaType.TEXT, 'ex': MediaType.TEXT, 'exs': MediaType.TEXT,
+    'erl': MediaType.TEXT, 'hrl': MediaType.TEXT, 'clj': MediaType.TEXT, 'cljs': MediaType.TEXT,
+
+    # Text formats - Notebooks and documentation
+    'ipynb': MediaType.TEXT, 'qmd': MediaType.TEXT, 'rst': MediaType.TEXT,
+    'tex': MediaType.TEXT, 'latex': MediaType.TEXT, 'bib': MediaType.TEXT,
+    'org': MediaType.TEXT, 'adoc': MediaType.TEXT, 'asciidoc': MediaType.TEXT,
+
+    # Text formats - Web and styles
+    'css': MediaType.TEXT, 'scss': MediaType.TEXT, 'sass': MediaType.TEXT, 'less': MediaType.TEXT,
+    'vue': MediaType.TEXT, 'svelte': MediaType.TEXT,
+
+    # Text formats - Build and config files
+    'gradle': MediaType.TEXT, 'cmake': MediaType.TEXT, 'make': MediaType.TEXT,
+    'dockerfile': MediaType.TEXT, 'containerfile': MediaType.TEXT,
+    'gitignore': MediaType.TEXT, 'gitattributes': MediaType.TEXT,
+    'env': MediaType.TEXT, 'properties': MediaType.TEXT,
+
+    # Text formats - Log and output files
+    'log': MediaType.TEXT, 'out': MediaType.TEXT, 'err': MediaType.TEXT,
 
     # Audio
     'mp3': MediaType.AUDIO, 'wav': MediaType.AUDIO, 'm4a': MediaType.AUDIO,
@@ -227,9 +263,66 @@ FILE_TYPE_MAPPINGS = {
 }
 
 
+def is_text_file(file_path: Union[str, Path]) -> bool:
+    """
+    Detect if a file is text-based by attempting to read it.
+
+    This is a heuristic check that samples the beginning of the file
+    to determine if it contains text content.
+
+    Args:
+        file_path: Path to the file
+
+    Returns:
+        True if file appears to be text-based, False otherwise
+    """
+    path = Path(file_path)
+
+    if not path.exists():
+        return False
+
+    # Check file size - avoid reading very large files
+    try:
+        file_size = path.stat().st_size
+        if file_size == 0:
+            return True  # Empty files are text
+
+        # Sample first 8KB to detect if it's text
+        sample_size = min(8192, file_size)
+
+        with open(path, 'rb') as f:
+            sample = f.read(sample_size)
+
+        # Check for null bytes (strong indicator of binary)
+        if b'\x00' in sample:
+            return False
+
+        # Try to decode as UTF-8
+        try:
+            sample.decode('utf-8')
+            return True
+        except UnicodeDecodeError:
+            pass
+
+        # Try other common encodings
+        for encoding in ['latin-1', 'cp1252', 'iso-8859-1']:
+            try:
+                sample.decode(encoding)
+                return True
+            except (UnicodeDecodeError, LookupError):
+                continue
+
+        # If we can't decode it, it's probably binary
+        return False
+
+    except Exception:
+        # On any error, assume it's not text
+        return False
+
+
 def detect_media_type(file_path: Union[str, Path]) -> MediaType:
     """
-    Detect the media type of a file based on its extension.
+    Detect the media type of a file based on its extension and content.
 
     Args:
         file_path: Path to the file
@@ -240,7 +333,71 @@ def detect_media_type(file_path: Union[str, Path]) -> MediaType:
     path = Path(file_path)
     extension = path.suffix.lower().lstrip('.')
 
-    return FILE_TYPE_MAPPINGS.get(extension, MediaType.DOCUMENT)
+    # First check the known extension mappings
+    if extension in FILE_TYPE_MAPPINGS:
+        return FILE_TYPE_MAPPINGS[extension]
+
+    # For unknown extensions, try to detect if it's a text file
+    # This handles cases like .R, .Rmd, .ipynb, and any other text-based files
+    if is_text_file(path):
+        return MediaType.TEXT
+
+    # Fall back to DOCUMENT for binary files with unknown extensions
+    return MediaType.DOCUMENT
+
+
+def get_all_supported_extensions() -> Dict[str, List[str]]:
+    """
+    Get all supported file extensions organized by media type.
+
+    This function provides programmatic access to all file extensions
+    that AbstractCore can process.
+
+    Returns:
+        Dictionary mapping media type names to lists of supported extensions.
+
+    Example:
+        >>> from abstractcore.media.types import get_all_supported_extensions
+        >>> formats = get_all_supported_extensions()
+        >>> print(f"Text formats: {len(formats['text'])} extensions")
+        Text formats: 70+ extensions
+        >>> print(formats['text'][:5])
+        ['txt', 'md', 'markdown', 'csv', 'tsv']
+    """
+    result = {}
+    for ext, media_type in FILE_TYPE_MAPPINGS.items():
+        type_name = media_type.value
+        if type_name not in result:
+            result[type_name] = []
+        result[type_name].append(ext)
+
+    # Sort extensions within each type for consistency
+    for type_name in result:
+        result[type_name].sort()
+
+    return result
+
+
+def get_supported_extensions_by_type(media_type: MediaType) -> List[str]:
+    """
+    Get all supported file extensions for a specific media type.
+
+    Args:
+        media_type: The MediaType to query
+
+    Returns:
+        List of file extensions (without dots) supported for this type
+
+    Example:
+        >>> from abstractcore.media.types import get_supported_extensions_by_type, MediaType
+        >>> text_exts = get_supported_extensions_by_type(MediaType.TEXT)
+        >>> 'r' in text_exts  # R scripts
+        True
+        >>> 'ipynb' in text_exts  # Jupyter notebooks
+        True
+    """
+    extensions = [ext for ext, mt in FILE_TYPE_MAPPINGS.items() if mt == media_type]
+    return sorted(extensions)
 
 
 def create_media_content(

abstractcore/media/utils/image_scaler.py

@@ -8,7 +8,6 @@ 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
@@ -17,6 +16,7 @@ except ImportError:
     PIL_AVAILABLE = False
 
 from ..base import MediaProcessingError
+from ...utils.structured_logging import get_logger
 
 
 class ScalingMode(Enum):
@@ -36,7 +36,7 @@ class ModelOptimizedScaler:
     """
 
     def __init__(self):
-        self.logger = logging.getLogger(__name__)
+        self.logger = get_logger(__name__)
 
         if not PIL_AVAILABLE:
             raise MediaProcessingError("PIL (Pillow) is required for image scaling")

abstractcore/media/vision_fallback.py

@@ -5,11 +5,11 @@ Implements two-stage pipeline: vision model → description → text-only model
 Uses unified AbstractCore configuration system.
 """
 
-import logging
 from pathlib import Path
 from typing import Optional, Dict, Any
+from ..utils.structured_logging import get_logger
 
-logger = logging.getLogger(__name__)
+logger = get_logger(__name__)
 
 
 class VisionNotConfiguredError(Exception):

abstractcore/providers/__init__.py

@@ -22,6 +22,16 @@ from .registry import (
     get_available_models_for_provider
 )
 
+# Model capability filtering (new system)
+from .model_capabilities import (
+    ModelInputCapability,
+    ModelOutputCapability,
+    get_model_input_capabilities,
+    get_model_output_capabilities,
+    filter_models_by_capabilities,
+    get_capability_summary
+)
+
 __all__ = [
     # Provider classes
     'BaseProvider',
@@ -43,4 +53,12 @@ __all__ = [
     'get_all_providers_status',
     'create_provider',
     'get_available_models_for_provider',
+
+    # Model capability filtering (new system)
+    'ModelInputCapability',
+    'ModelOutputCapability',
+    'get_model_input_capabilities',
+    'get_model_output_capabilities',
+    'filter_models_by_capabilities',
+    'get_capability_summary',
 ]

abstractcore/providers/anthropic_provider.py

@@ -5,7 +5,7 @@ Anthropic provider implementation.
 import os
 import json
 import time
-from typing import List, Dict, Any, Optional, Union, Iterator, Type
+from typing import List, Dict, Any, Optional, Union, Iterator, AsyncIterator, Type
 
 try:
     from pydantic import BaseModel
@@ -16,7 +16,7 @@ except ImportError:
 from .base import BaseProvider
 from ..core.types import GenerateResponse
 from ..media import MediaHandler
-from ..exceptions import AuthenticationError, ProviderAPIError, ModelNotFoundError, format_model_error
+from ..exceptions import AuthenticationError, ProviderAPIError, ModelNotFoundError, format_model_error, format_auth_error
 from ..tools import UniversalToolHandler, execute_tools
 from ..events import EventType
 
@@ -30,7 +30,8 @@ except ImportError:
 class AnthropicProvider(BaseProvider):
     """Anthropic Claude API provider with full integration"""
 
-    def __init__(self, model: str = "claude-3-haiku-20240307", api_key: Optional[str] = None, **kwargs):
+    def __init__(self, model: str = "claude-3-haiku-20240307", api_key: Optional[str] = None,
+                 base_url: Optional[str] = None, **kwargs):
         super().__init__(model, **kwargs)
         self.provider = "anthropic"
 
@@ -42,8 +43,15 @@ class AnthropicProvider(BaseProvider):
         if not self.api_key:
             raise ValueError("Anthropic API key required. Set ANTHROPIC_API_KEY environment variable.")
 
-        # Initialize client with timeout
-        self.client = anthropic.Anthropic(api_key=self.api_key, timeout=self._timeout)
+        # Get base URL from param or environment
+        self.base_url = base_url or os.getenv("ANTHROPIC_BASE_URL")
+
+        # Initialize client with timeout and optional base_url
+        client_kwargs = {"api_key": self.api_key, "timeout": self._timeout}
+        if self.base_url:
+            client_kwargs["base_url"] = self.base_url
+        self.client = anthropic.Anthropic(**client_kwargs)
+        self._async_client = None  # Lazy-loaded async client
 
         # Initialize tool handler
         self.tool_handler = UniversalToolHandler(model)
@@ -56,6 +64,16 @@ class AnthropicProvider(BaseProvider):
         """Public generate method that includes telemetry"""
         return self.generate_with_telemetry(*args, **kwargs)
 
+    @property
+    def async_client(self):
+        """Lazy-load AsyncAnthropic client for native async operations."""
+        if self._async_client is None:
+            client_kwargs = {"api_key": self.api_key, "timeout": self._timeout}
+            if self.base_url:
+                client_kwargs["base_url"] = self.base_url
+            self._async_client = anthropic.AsyncAnthropic(**client_kwargs)
+        return self._async_client
+
     def _generate_internal(self,
                           prompt: str,
                           messages: Optional[List[Dict[str, str]]] = None,
@@ -207,7 +225,7 @@ class AnthropicProvider(BaseProvider):
             error_str = str(e).lower()
 
             if 'api_key' in error_str or 'authentication' in error_str:
-                raise AuthenticationError(f"Anthropic authentication failed: {str(e)}")
+                raise AuthenticationError(format_auth_error("anthropic", str(e)))
             elif ('not_found_error' in error_str and 'model:' in error_str) or '404' in error_str:
                 # Model not found - show available models
                 available_models = self.list_available_models(api_key=self.api_key)
@@ -216,6 +234,182 @@ class AnthropicProvider(BaseProvider):
             else:
                 raise ProviderAPIError(f"Anthropic API error: {str(e)}")
 
+    async def _agenerate_internal(self,
+                                   prompt: str,
+                                   messages: Optional[List[Dict[str, str]]] = None,
+                                   system_prompt: Optional[str] = None,
+                                   tools: Optional[List[Dict[str, Any]]] = None,
+                                   media: Optional[List['MediaContent']] = None,
+                                   stream: bool = False,
+                                   response_model: Optional[Type[BaseModel]] = None,
+                                   **kwargs) -> Union[GenerateResponse, AsyncIterator[GenerateResponse]]:
+        """Native async implementation using AsyncAnthropic - 3-10x faster for batch operations."""
+
+        # Build messages array (same logic as sync)
+        api_messages = []
+
+        # Add conversation history
+        if messages:
+            for msg in messages:
+                # Skip system messages as they're handled separately
+                if msg.get("role") != "system":
+                    # Convert assistant role if needed
+                    role = msg["role"]
+                    if role == "assistant":
+                        api_messages.append({
+                            "role": "assistant",
+                            "content": msg["content"]
+                        })
+                    else:
+                        api_messages.append({
+                            "role": "user",
+                            "content": msg["content"]
+                        })
+
+        # Add current prompt as user message
+        if prompt and prompt not in [msg.get("content") for msg in (messages or [])]:
+            # Handle multimodal message with media content
+            if media:
+                try:
+                    from ..media.handlers import AnthropicMediaHandler
+                    media_handler = AnthropicMediaHandler(self.model_capabilities)
+
+                    # Create multimodal message combining text and media
+                    multimodal_message = media_handler.create_multimodal_message(prompt, media)
+                    api_messages.append(multimodal_message)
+                except ImportError:
+                    self.logger.warning("Media processing not available. Install with: pip install abstractcore[media]")
+                    api_messages.append({"role": "user", "content": prompt})
+                except Exception as e:
+                    self.logger.warning(f"Failed to process media content: {e}")
+                    api_messages.append({"role": "user", "content": prompt})
+            else:
+                api_messages.append({"role": "user", "content": prompt})
+
+        # Prepare API call parameters (same logic as sync)
+        generation_kwargs = self._prepare_generation_kwargs(**kwargs)
+        max_output_tokens = self._get_provider_max_tokens_param(generation_kwargs)
+
+        call_params = {
+            "model": self.model,
+            "messages": api_messages,
+            "max_tokens": max_output_tokens,
+            "temperature": kwargs.get("temperature", self.temperature),
+            "stream": stream
+        }
+
+        # Add system prompt if provided (Anthropic-specific: separate parameter)
+        if system_prompt:
+            call_params["system"] = system_prompt
+
+        # Add top_p if specified
+        if kwargs.get("top_p") or self.top_p < 1.0:
+            call_params["top_p"] = kwargs.get("top_p", self.top_p)
+
+        # Add top_k if specified
+        if kwargs.get("top_k") or self.top_k:
+            call_params["top_k"] = kwargs.get("top_k", self.top_k)
+
+        # Handle seed parameter (Anthropic doesn't support seed natively)
+        seed_value = kwargs.get("seed", self.seed)
+        if seed_value is not None:
+            import warnings
+            warnings.warn(
+                f"Seed parameter ({seed_value}) is not supported by Anthropic Claude API. "
+                f"For deterministic outputs, use temperature=0.0 which may provide more consistent results, "
+                f"though true determinism is not guaranteed.",
+                UserWarning,
+                stacklevel=3
+            )
+            self.logger.warning(f"Seed {seed_value} requested but not supported by Anthropic API")
+
+        # Handle structured output using the "tool trick"
+        structured_tool_name = None
+        if response_model and PYDANTIC_AVAILABLE:
+            structured_tool = self._create_structured_output_tool(response_model)
+
+            if tools:
+                tools = list(tools) + [structured_tool]
+            else:
+                tools = [structured_tool]
+
+            structured_tool_name = structured_tool["name"]
+
+            if api_messages and api_messages[-1]["role"] == "user":
+                api_messages[-1]["content"] += f"\n\nPlease use the {structured_tool_name} tool to provide your response."
+
+        # Add tools if provided
+        if tools:
+            if self.tool_handler.supports_native:
+                call_params["tools"] = self._format_tools_for_anthropic(tools)
+
+                if structured_tool_name:
+                    call_params["tool_choice"] = {"type": "tool", "name": structured_tool_name}
+                elif kwargs.get("tool_choice"):
+                    call_params["tool_choice"] = {"type": kwargs.get("tool_choice", "auto")}
+            else:
+                tool_prompt = self.tool_handler.format_tools_prompt(tools)
+                if call_params.get("system"):
+                    call_params["system"] += f"\n\n{tool_prompt}"
+                else:
+                    call_params["system"] = tool_prompt
+
+        # Make async API call
+        try:
+            if stream:
+                return self._async_stream_response(call_params, tools)
+            else:
+                start_time = time.time()
+                response = await self.async_client.messages.create(**call_params)
+                gen_time = round((time.time() - start_time) * 1000, 1)
+
+                formatted = self._format_response(response)
+                formatted.gen_time = gen_time
+
+                if tools and (formatted.has_tool_calls() or
+                             (self.tool_handler.supports_prompted and formatted.content)):
+                    formatted = self._handle_tool_execution(formatted, tools)
+
+                return formatted
+        except Exception as e:
+            error_str = str(e).lower()
+
+            if 'api_key' in error_str or 'authentication' in error_str:
+                raise AuthenticationError(format_auth_error("anthropic", str(e)))
+            elif ('not_found_error' in error_str and 'model:' in error_str) or '404' in error_str:
+                available_models = self.list_available_models(api_key=self.api_key)
+                error_message = format_model_error("Anthropic", self.model, available_models)
+                raise ModelNotFoundError(error_message)
+            else:
+                raise ProviderAPIError(f"Anthropic API error: {str(e)}")
+
+    async def _async_stream_response(self, call_params: Dict[str, Any], tools: Optional[List[Dict[str, Any]]] = None) -> AsyncIterator[GenerateResponse]:
+        """Native async streaming with Anthropic's context manager pattern."""
+        stream_params = {k: v for k, v in call_params.items() if k != 'stream'}
+
+        try:
+            async with self.async_client.messages.stream(**stream_params) as stream:
+                async for chunk in stream:
+                    yield GenerateResponse(
+                        content=getattr(chunk, 'content', ''),
+                        model=self.model,
+                        finish_reason=getattr(chunk, 'finish_reason', None),
+                        raw_response=chunk
+                    )
+        except Exception as e:
+            raise ProviderAPIError(f"Anthropic streaming error: {str(e)}")
+
+    def unload(self) -> None:
+        """Close async client if it was created."""
+        if self._async_client is not None:
+            import asyncio
+            try:
+                loop = asyncio.get_running_loop()
+                loop.create_task(self._async_client.close())
+            except RuntimeError:
+                import asyncio
+                asyncio.run(self._async_client.close())
+
     def _format_tools_for_anthropic(self, tools: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
         """Format tools for Anthropic API format"""
         formatted_tools = []
@@ -455,9 +649,21 @@ class AnthropicProvider(BaseProvider):
         # Create new client with updated timeout
         self.client = anthropic.Anthropic(api_key=self.api_key, timeout=self._timeout)
     def list_available_models(self, **kwargs) -> List[str]:
-        """List available models from Anthropic API."""
+        """
+        List available models from Anthropic API.
+
+        Args:
+            **kwargs: Optional parameters including:
+                - api_key: Anthropic API key
+                - input_capabilities: List of ModelInputCapability enums to filter by input capability
+                - output_capabilities: List of ModelOutputCapability enums to filter by output capability
+
+        Returns:
+            List of model names, optionally filtered by capabilities
+        """
         try:
             import httpx
+            from .model_capabilities import filter_models_by_capabilities
 
             # Use provided API key or instance API key
             api_key = kwargs.get('api_key', self.api_key)
@@ -481,7 +687,21 @@ class AnthropicProvider(BaseProvider):
                 data = response.json()
                 models = [model["id"] for model in data.get("data", [])]
                 self.logger.debug(f"Retrieved {len(models)} models from Anthropic API")
-                return sorted(models, reverse=True)  # Latest models first
+                models = sorted(models, reverse=True)  # Latest models first
+
+                # Apply new capability filtering if provided
+                input_capabilities = kwargs.get('input_capabilities')
+                output_capabilities = kwargs.get('output_capabilities')
+                
+                if input_capabilities or output_capabilities:
+                    models = filter_models_by_capabilities(
+                        models, 
+                        input_capabilities=input_capabilities,
+                        output_capabilities=output_capabilities
+                    )
+
+
+                return models
             else:
                 self.logger.warning(f"Anthropic API returned status {response.status_code}")
                 return []