abstractcore 2.9.1__py3-none-any.whl → 2.11.4__py3-none-any.whl

abstractcore/utils/structured_logging.py

@@ -57,7 +57,7 @@ def _get_config_defaults():
             "NONE": logging.CRITICAL + 10  # Higher than CRITICAL to effectively disable logging
         }
 
-        console_level = level_map.get(logging_config.console_level, logging.WARNING)
+        console_level = level_map.get(logging_config.console_level, logging.ERROR)
         file_level = level_map.get(logging_config.file_level, logging.DEBUG)
 
         # Use log_base_dir if file logging enabled
@@ -66,6 +66,27 @@ def _get_config_defaults():
             # Expand user home directory
             log_dir = str(Path(logging_config.log_base_dir).expanduser())
 
+        # Environment overrides (optional)
+        env_console = os.getenv("ABSTRACTCORE_CONSOLE_LOG_LEVEL")
+        if isinstance(env_console, str) and env_console.strip():
+            env_level = env_console.strip().upper()
+            if env_level == "NONE":
+                console_level = None
+            else:
+                console_level = level_map.get(env_level, console_level)
+
+        env_file = os.getenv("ABSTRACTCORE_FILE_LOG_LEVEL")
+        if isinstance(env_file, str) and env_file.strip():
+            env_level = env_file.strip().upper()
+            if env_level == "NONE":
+                file_level = None
+            else:
+                file_level = level_map.get(env_level, file_level)
+
+        env_log_dir = os.getenv("ABSTRACTCORE_LOG_BASE_DIR")
+        if isinstance(env_log_dir, str) and env_log_dir.strip():
+            log_dir = str(Path(env_log_dir.strip()).expanduser())
+
         return {
             'console_level': console_level,
             'file_level': file_level,
@@ -77,7 +98,7 @@ def _get_config_defaults():
     except Exception:
         # Fallback to hardcoded defaults if config unavailable
         return {
-            'console_level': logging.WARNING,
+            'console_level': logging.ERROR,
             'file_level': logging.DEBUG,
             'log_dir': None,
             'verbatim_enabled': True,
@@ -89,7 +110,7 @@ def _get_config_defaults():
 LOG_LEVEL_COLORS = {
     'DEBUG': Fore.CYAN + Style.DIM,           # Cyan, dimmed (less prominent)
     'INFO': Fore.GREEN,                       # Green (informational, good)
-    'WARNING': Fore.YELLOW + Style.BRIGHT,    # Bright yellow (attention)
+    'WARNING': "\033[38;5;214m" + Style.BRIGHT,  # Orange (attention)
     'ERROR': Fore.RED,                        # Red (error)
     'CRITICAL': Fore.RED + Style.BRIGHT       # Bright red (critical)
 }
@@ -215,7 +236,7 @@ class LogConfig:
         root_logger.handlers.clear()
 
         # Console handler
-        if self.console_level is not None:
+        if self.console_level is not None and self.console_level < (logging.CRITICAL + 10):
             console_handler = logging.StreamHandler(sys.stdout)
             console_handler.setLevel(self.console_level)
 
@@ -260,8 +281,8 @@ class LogConfig:
         if effective_levels:
             root_logger.setLevel(min(effective_levels))
         else:
-            # No handlers enabled, set to WARNING as a safe default
-            root_logger.setLevel(logging.WARNING)
+            # No handlers enabled, set to ERROR as a safe default
+            root_logger.setLevel(logging.ERROR)
 
 
 # Global config instance
@@ -493,7 +514,7 @@ def get_logger(name: str) -> StructuredLogger:
 
 
 def configure_logging(
-    console_level: Optional[int] = logging.WARNING,
+    console_level: Optional[int] = logging.ERROR,
     file_level: Optional[int] = logging.DEBUG,
     log_dir: Optional[str] = None,
     verbatim_enabled: bool = True,
@@ -577,4 +598,4 @@ def suppress_stdout_stderr():
             yield
         finally:
             sys.stdout = old_stdout
-            sys.stderr = old_stderr
+            sys.stderr = old_stderr

abstractcore/utils/token_utils.py

@@ -230,12 +230,14 @@ class TokenUtils:
             return ContentType.NATURAL_LANGUAGE
             
         # Sample first 1000 chars for efficiency
+        #[WARNING:TRUNCATION] bounded sample for heuristic detection (performance)
         sample = text[:1000]
         
         # JSON detection
         if sample.strip().startswith(('{', '[')):
             try:
                 import json
+                #[WARNING:TRUNCATION] bounded JSON probe for heuristic detection (performance)
                 json.loads(sample[:500])  # Try to parse a portion
                 return ContentType.JSON
             except:

abstractcore/utils/truncation.py

@@ -0,0 +1,29 @@
+"""Truncation utilities (explicit + searchable).
+
+Policy authority: ADR-0026 (docs/adr/0026-truncation-policy-and-contract.md).
+
+All lossy truncation must:
+- be explicit in the returned text (marker),
+- and be searchable in code via `#[WARNING:TRUNCATION]`.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def preview_text(value: Any, *, max_chars: int, marker: str = "… (truncated)") -> str:
+    """Return `value` as a bounded preview with an explicit truncation marker."""
+    s = str(value or "")
+    if max_chars <= 0:
+        #[WARNING:TRUNCATION] bounded preview requested with max_chars<=0
+        return ""
+    max_chars_i = int(max_chars)
+    if len(s) <= max_chars_i:
+        return s
+    #[WARNING:TRUNCATION] bounded preview (logs/telemetry/UI)
+    keep = max(0, max_chars_i - len(marker))
+    if keep <= 0:
+        return marker[:max_chars_i].rstrip()
+    return s[:keep].rstrip() + marker
+

abstractcore/utils/version.py

@@ -2,13 +2,12 @@
 Version management for AbstractCore.
 
 This module provides the package version as a static constant that serves as the
-single source of truth for the Python code. The version is also maintained in
-pyproject.toml for packaging, requiring manual synchronization during releases.
+single source of truth. Packaging reads the version from this module via
+`[tool.setuptools.dynamic]` in `pyproject.toml`.
 
 This approach ensures reliable version access in all deployment scenarios,
 including when the package is installed from PyPI where pyproject.toml is not available.
 """
 
 # Package version - update this when releasing new versions
-# This must be manually synchronized with the version in pyproject.toml
-__version__ = "2.9.1"
+__version__ = "2.11.4"

abstractcore/utils/vlm_token_calculator.py

@@ -24,7 +24,12 @@ from typing import Tuple, Dict, Any, Optional, List
 from pathlib import Path
 import logging
 
-from PIL import Image
+try:
+    from PIL import Image
+    PIL_AVAILABLE = True
+except ImportError:  # pragma: no cover
+    Image = None
+    PIL_AVAILABLE = False
 
 from ..utils.structured_logging import get_logger
 from ..architectures.detection import get_model_capabilities, detect_architecture
@@ -143,6 +148,11 @@ class VLMTokenCalculator:
         """
         # Get image dimensions
         if image_path and image_path.exists():
+            if not PIL_AVAILABLE:
+                raise ImportError(
+                    "PIL/Pillow is required to read image files for token calculation. "
+                    "Install with: pip install \"abstractcore[media]\""
+                )
             try:
                 with Image.open(image_path) as img:
                     width, height = img.size
@@ -653,4 +663,4 @@ def calculate_glyph_compression_ratio(original_tokens: int,
                                     model: str = '') -> Dict[str, Any]:
     """Calculate accurate Glyph compression ratio."""
     calculator = VLMTokenCalculator()
-    return calculator.get_compression_ratio(original_tokens, image_paths, provider, model)
+    return calculator.get_compression_ratio(original_tokens, image_paths, provider, model)