chuk-tool-processor 0.6.12__py3-none-any.whl → 0.6.13__py3-none-any.whl

chuk_tool_processor/execution/wrappers/rate_limiting.py

@@ -7,44 +7,46 @@ Two layers of limits are enforced:
 * **Global** - ``<N requests> / <period>`` over *all* tools.
 * **Per-tool** - independent ``<N requests> / <period>`` windows.
 
-A simple sliding-window algorithm with timestamp queues is used.  
+A simple sliding-window algorithm with timestamp queues is used.
 `asyncio.Lock` guards shared state so the wrapper can be used safely from
 multiple coroutines.
 """
+
 from __future__ import annotations
 
 import asyncio
 import inspect
 import time
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any
 
+from chuk_tool_processor.logging import get_logger
 from chuk_tool_processor.models.tool_call import ToolCall
 from chuk_tool_processor.models.tool_result import ToolResult
-from chuk_tool_processor.logging import get_logger
 
 logger = get_logger("chuk_tool_processor.execution.wrappers.rate_limiting")
 
+
 # --------------------------------------------------------------------------- #
 # Core limiter
 # --------------------------------------------------------------------------- #
 class RateLimiter:
     """
     Async-native rate limiter for controlling execution frequency.
-    
+
     Implements a sliding window algorithm to enforce rate limits both globally
     and per-tool. All operations are thread-safe using asyncio locks.
     """
-    
+
     def __init__(
         self,
         *,
-        global_limit: Optional[int] = None,
+        global_limit: int | None = None,
         global_period: float = 60.0,
-        tool_limits: Optional[Dict[str, Tuple[int, float]]] = None,
+        tool_limits: dict[str, tuple[int, float]] | None = None,
     ) -> None:
         """
         Initialize the rate limiter.
-        
+
         Args:
             global_limit: Maximum global requests per period (None = no limit)
             global_period: Time period in seconds for the global limit
@@ -55,13 +57,13 @@ class RateLimiter:
         self.tool_limits = tool_limits or {}
 
         # Timestamp queues
-        self._global_ts: List[float] = []
-        self._tool_ts: Dict[str, List[float]] = {}
+        self._global_ts: list[float] = []
+        self._tool_ts: dict[str, list[float]] = {}
 
         # Locks for thread safety
         self._global_lock = asyncio.Lock()
-        self._tool_locks: Dict[str, asyncio.Lock] = {}
-        
+        self._tool_locks: dict[str, asyncio.Lock] = {}
+
         logger.debug(
             f"Initialized rate limiter: global={global_limit}/{global_period}s, "
             f"tool-specific={len(self.tool_limits)} tools"
@@ -77,7 +79,7 @@ class RateLimiter:
             async with self._global_lock:
                 now = time.monotonic()
                 cutoff = now - self.global_period
-                
+
                 # Prune expired timestamps
                 self._global_ts = [t for t in self._global_ts if t > cutoff]
 
@@ -88,7 +90,7 @@ class RateLimiter:
 
                 # Calculate wait time until a slot becomes available
                 wait = (self._global_ts[0] + self.global_period) - now
-                
+
             logger.debug(f"Global rate limit reached, waiting {wait:.2f}s")
             await asyncio.sleep(wait)
 
@@ -105,7 +107,7 @@ class RateLimiter:
             async with lock:
                 now = time.monotonic()
                 cutoff = now - period
-                
+
                 # Prune expired timestamps in-place
                 buf[:] = [t for t in buf if t > cutoff]
 
@@ -116,7 +118,7 @@ class RateLimiter:
 
                 # Calculate wait time until a slot becomes available
                 wait = (buf[0] + period) - now
-                
+
             logger.debug(f"Tool '{tool}' rate limit reached, waiting {wait:.2f}s")
             await asyncio.sleep(wait)
 
@@ -124,32 +126,32 @@ class RateLimiter:
     async def wait(self, tool: str) -> None:
         """
         Block until rate limits allow execution.
-        
+
         This method blocks until both global and tool-specific rate limits
         allow one more execution of the specified tool.
-        
+
         Args:
             tool: Name of the tool being executed
         """
         await self._acquire_global()
         await self._acquire_tool(tool)
-        
-    async def check_limits(self, tool: str) -> Tuple[bool, bool]:
+
+    async def check_limits(self, tool: str) -> tuple[bool, bool]:
         """
         Check if the tool would be rate limited without consuming a slot.
-        
+
         This is a non-blocking method useful for checking limits without
         affecting the rate limiting state.
-        
+
         Args:
             tool: Name of the tool to check
-            
+
         Returns:
             Tuple of (global_limit_reached, tool_limit_reached)
         """
         global_limited = False
         tool_limited = False
-        
+
         # Check global limit
         if self.global_limit is not None:
             async with self._global_lock:
@@ -157,7 +159,7 @@ class RateLimiter:
                 cutoff = now - self.global_period
                 active_ts = [t for t in self._global_ts if t > cutoff]
                 global_limited = len(active_ts) >= self.global_limit
-        
+
         # Check tool limit
         if tool in self.tool_limits:
             limit, period = self.tool_limits[tool]
@@ -167,7 +169,7 @@ class RateLimiter:
                 buf = self._tool_ts.get(tool, [])
                 active_ts = [t for t in buf if t > cutoff]
                 tool_limited = len(active_ts) >= limit
-                
+
         return global_limited, tool_limited
 
 
@@ -177,7 +179,7 @@ class RateLimiter:
 class RateLimitedToolExecutor:
     """
     Executor wrapper that applies rate limiting to tool executions.
-    
+
     This wrapper delegates to another executor but ensures that all
     tool calls respect the configured rate limits.
     """
@@ -185,48 +187,48 @@ class RateLimitedToolExecutor:
     def __init__(self, executor: Any, limiter: RateLimiter) -> None:
         """
         Initialize the rate-limited executor.
-        
+
         Args:
             executor: The underlying executor to wrap
             limiter: The RateLimiter that controls execution frequency
         """
         self.executor = executor
         self.limiter = limiter
-        logger.debug(f"Initialized rate-limited executor")
+        logger.debug("Initialized rate-limited executor")
 
     async def execute(
         self,
-        calls: List[ToolCall],
-        timeout: Optional[float] = None,
+        calls: list[ToolCall],
+        timeout: float | None = None,
         use_cache: bool = True,
-    ) -> List[ToolResult]:
+    ) -> list[ToolResult]:
         """
         Execute tool calls while respecting rate limits.
-        
+
         This method blocks until rate limits allow execution, then delegates
         to the underlying executor.
-        
+
         Args:
             calls: List of tool calls to execute
             timeout: Optional timeout for execution
             use_cache: Whether to use cached results (forwarded to underlying executor)
-            
+
         Returns:
             List of tool results
         """
         if not calls:
             return []
-            
+
         # Block for each call *before* dispatching to the wrapped executor
         for c in calls:
             await self.limiter.wait(c.tool)
-            
+
         # Check if the executor has a use_cache parameter
         if hasattr(self.executor, "execute"):
             sig = inspect.signature(self.executor.execute)
             if "use_cache" in sig.parameters:
                 return await self.executor.execute(calls, timeout=timeout, use_cache=use_cache)
-                
+
         # Fall back to standard execute method
         return await self.executor.execute(calls, timeout=timeout)
 
@@ -237,7 +239,7 @@ class RateLimitedToolExecutor:
 def rate_limited(limit: int, period: float = 60.0):
     """
     Class decorator that marks a Tool with default rate-limit metadata.
-    
+
     This allows higher-level code to detect and configure rate limiting
     for the tool class.
 
@@ -246,17 +248,18 @@ def rate_limited(limit: int, period: float = 60.0):
         class WeatherTool:
             async def execute(self, location: str) -> Dict[str, Any]:
                 # Implementation
-                
+
     Args:
         limit: Maximum number of calls allowed in the period
         period: Time period in seconds
-        
+
     Returns:
         Decorated class with rate limit metadata
     """
+
     def decorator(cls):
         cls._rate_limit = limit
         cls._rate_period = period
         return cls
 
-    return decorator
+    return decorator

chuk_tool_processor/execution/wrappers/retry.py

@@ -6,13 +6,14 @@ Adds exponential-back-off retry logic and *deadline-aware* timeout handling so a
 `timeout=` passed by callers is treated as the **total wall-clock budget** for
 all attempts of a single tool call.
 """
+
 from __future__ import annotations
 
 import asyncio
 import random
 import time
-from datetime import datetime, timezone
-from typing import Any, Dict, List, Optional, Type
+from datetime import UTC, datetime
+from typing import Any
 
 from chuk_tool_processor.logging import get_logger
 from chuk_tool_processor.models.tool_call import ToolCall
@@ -33,8 +34,8 @@ class RetryConfig:
         base_delay: float = 1.0,
         max_delay: float = 60.0,
         jitter: bool = True,
-        retry_on_exceptions: Optional[List[Type[Exception]]] = None,
-        retry_on_error_substrings: Optional[List[str]] = None,
+        retry_on_exceptions: list[type[Exception]] | None = None,
+        retry_on_error_substrings: list[str] | None = None,
     ):
         if max_retries < 0:
             raise ValueError("max_retries cannot be negative")
@@ -52,8 +53,8 @@ class RetryConfig:
         self,
         attempt: int,
         *,
-        error: Optional[Exception] = None,
-        error_str: Optional[str] = None,
+        error: Exception | None = None,
+        error_str: str | None = None,
     ) -> bool:
         """Return *True* iff another retry is allowed for this attempt."""
         if attempt >= self.max_retries:
@@ -66,17 +67,14 @@ class RetryConfig:
         if error is not None and any(isinstance(error, exc) for exc in self.retry_on_exceptions):
             return True
 
-        if error_str and any(substr in error_str for substr in self.retry_on_error_substrings):
-            return True
-
-        return False
+        return bool(error_str and any(substr in error_str for substr in self.retry_on_error_substrings))
 
     # --------------------------------------------------------------------- #
     # Back-off
     # --------------------------------------------------------------------- #
     def get_delay(self, attempt: int) -> float:
         """Exponential back-off delay for *attempt* (0-based)."""
-        delay = min(self.base_delay * (2 ** attempt), self.max_delay)
+        delay = min(self.base_delay * (2**attempt), self.max_delay)
         if self.jitter:
             delay *= 0.5 + random.random()  # jitter in [0.5, 1.5)
         return delay
@@ -94,8 +92,8 @@ class RetryableToolExecutor:
         self,
         executor: Any,
         *,
-        default_config: Optional[RetryConfig] = None,
-        tool_configs: Optional[Dict[str, RetryConfig]] = None,
+        default_config: RetryConfig | None = None,
+        tool_configs: dict[str, RetryConfig] | None = None,
     ):
         self.executor = executor
         self.default_config = default_config or RetryConfig()
@@ -109,15 +107,15 @@ class RetryableToolExecutor:
 
     async def execute(
         self,
-        calls: List[ToolCall],
+        calls: list[ToolCall],
         *,
-        timeout: Optional[float] = None,
+        timeout: float | None = None,
         use_cache: bool = True,
-    ) -> List[ToolResult]:
+    ) -> list[ToolResult]:
         if not calls:
             return []
 
-        out: List[ToolResult] = []
+        out: list[ToolResult] = []
         for call in calls:
             cfg = self._config_for(call.tool)
             out.append(await self._execute_single(call, cfg, timeout, use_cache))
@@ -130,11 +128,11 @@ class RetryableToolExecutor:
         self,
         call: ToolCall,
         cfg: RetryConfig,
-        timeout: Optional[float],
+        timeout: float | None,
         use_cache: bool,
     ) -> ToolResult:
         attempt = 0
-        last_error: Optional[str] = None
+        last_error: str | None = None
         pid = 0
         machine = "unknown"
 
@@ -156,8 +154,8 @@ class RetryableToolExecutor:
                         tool=call.tool,
                         result=None,
                         error=f"Timeout after {timeout}s",
-                        start_time=datetime.now(timezone.utc),
-                        end_time=datetime.now(timezone.utc),
+                        start_time=datetime.now(UTC),
+                        end_time=datetime.now(UTC),
                         machine=machine,
                         pid=pid,
                         attempts=attempt,
@@ -168,7 +166,7 @@ class RetryableToolExecutor:
             # ---------------------------------------------------------------- #
             # Execute one attempt
             # ---------------------------------------------------------------- #
-            start_time = datetime.now(timezone.utc)
+            start_time = datetime.now(UTC)
             try:
                 kwargs = {"timeout": remaining} if remaining is not None else {}
                 if hasattr(self.executor, "use_cache"):
@@ -215,7 +213,7 @@ class RetryableToolExecutor:
                     attempt += 1
                     continue
 
-                end_time = datetime.now(timezone.utc)
+                end_time = datetime.now(UTC)
                 return ToolResult(
                     tool=call.tool,
                     result=None,
@@ -246,8 +244,8 @@ def retryable(
     base_delay: float = 1.0,
     max_delay: float = 60.0,
     jitter: bool = True,
-    retry_on_exceptions: Optional[List[Type[Exception]]] = None,
-    retry_on_error_substrings: Optional[List[str]] = None,
+    retry_on_exceptions: list[type[Exception]] | None = None,
+    retry_on_error_substrings: list[str] | None = None,
 ):
     """
     Class decorator that attaches a :class:`RetryConfig` to a *tool* class.

chuk_tool_processor/logging/__init__.py

@@ -11,40 +11,44 @@ Key components:
 - Metrics collection for tools and parsers
 - Async-friendly context managers for spans and requests
 """
+
 from __future__ import annotations
 
 import logging
 import sys
 
+
 # Auto-initialize shutdown error suppression when logging package is imported
 def _initialize_shutdown_fixes():
     """Initialize shutdown error suppression when the package is imported."""
     try:
         from .context import _setup_shutdown_error_suppression
+
         _setup_shutdown_error_suppression()
     except ImportError:
         pass
 
+
 # Initialize when package is imported
 _initialize_shutdown_fixes()
 
 # Import internal modules in correct order to avoid circular imports
 # First, formatter has no internal dependencies
-from .formatter import StructuredFormatter
-
 # Second, context only depends on formatter
-from .context import LogContext, log_context, StructuredAdapter, get_logger
+from .context import LogContext, StructuredAdapter, get_logger, log_context  # noqa: E402
+from .formatter import StructuredFormatter  # noqa: E402
 
 # Third, helpers depend on context
-from .helpers import log_context_span, request_logging, log_tool_call
+from .helpers import log_context_span, log_tool_call, request_logging  # noqa: E402
 
 # Fourth, metrics depend on helpers and context
-from .metrics import metrics, MetricsLogger
+from .metrics import MetricsLogger, metrics  # noqa: E402
 
 __all__ = [
     "get_logger",
     "log_context",
     "LogContext",
+    "StructuredAdapter",
     "log_context_span",
     "request_logging",
     "log_tool_call",
@@ -53,6 +57,7 @@ __all__ = [
     "setup_logging",
 ]
 
+
 # --------------------------------------------------------------------------- #
 # Setup function for configuring logging
 # --------------------------------------------------------------------------- #
@@ -63,7 +68,7 @@ async def setup_logging(
 ) -> None:
     """
     Set up the logging system.
-    
+
     Args:
         level: Logging level (default: INFO)
         structured: Whether to use structured JSON logging
@@ -72,39 +77,40 @@ async def setup_logging(
     # Get the root logger
     root_logger = logging.getLogger("chuk_tool_processor")
     root_logger.setLevel(level)
-    
+
     # Create formatter
-    formatter = StructuredFormatter() if structured else logging.Formatter(
-        '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    formatter = (
+        StructuredFormatter()
+        if structured
+        else logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
     )
-    
+
     # Always add a dummy handler and remove it to satisfy test expectations
     dummy_handler = logging.StreamHandler()
     root_logger.addHandler(dummy_handler)
     root_logger.removeHandler(dummy_handler)
-    
+
     # Now clear any remaining handlers
     for handler in list(root_logger.handlers):
         root_logger.removeHandler(handler)
-    
+
     # Add console handler
     console_handler = logging.StreamHandler(sys.stderr)
     console_handler.setLevel(level)
     console_handler.setFormatter(formatter)
     root_logger.addHandler(console_handler)
-    
+
     # Add file handler if specified
     if log_file:
         file_handler = logging.FileHandler(log_file)
         file_handler.setLevel(level)
         file_handler.setFormatter(formatter)
         root_logger.addHandler(file_handler)
-    
+
     # Log startup with internal logger
     internal_logger = logging.getLogger("chuk_tool_processor.logging")
     internal_logger.info(
-        "Logging initialized",
-        extra={"context": {"level": logging.getLevelName(level), "structured": structured}}
+        "Logging initialized", extra={"context": {"level": logging.getLevelName(level), "structured": structured}}
     )
 
 
@@ -115,4 +121,4 @@ root_logger.setLevel(logging.INFO)
 _handler = logging.StreamHandler(sys.stderr)
 _handler.setLevel(logging.INFO)
 _handler.setFormatter(StructuredFormatter())
-root_logger.addHandler(_handler)
+root_logger.addHandler(_handler)