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

chuk_tool_processor/core/__init__.py

@@ -1 +1 @@
-# chuk_tool_processor/core/__init__.py
+# chuk_tool_processor/core/__init__.py

chuk_tool_processor/core/exceptions.py

@@ -1,14 +1,16 @@
 # chuk_tool_processor/exceptions.py
-from typing import Optional, Any, Dict
+from typing import Any
 
 
 class ToolProcessorError(Exception):
     """Base exception for all tool processor errors."""
+
     pass
 
 
 class ToolNotFoundError(ToolProcessorError):
     """Raised when a requested tool is not found in the registry."""
+
     def __init__(self, tool_name: str):
         self.tool_name = tool_name
         super().__init__(f"Tool '{tool_name}' not found in registry")
@@ -16,7 +18,8 @@ class ToolNotFoundError(ToolProcessorError):
 
 class ToolExecutionError(ToolProcessorError):
     """Raised when a tool execution fails."""
-    def __init__(self, tool_name: str, original_error: Optional[Exception] = None):
+
+    def __init__(self, tool_name: str, original_error: Exception | None = None):
         self.tool_name = tool_name
         self.original_error = original_error
         message = f"Tool '{tool_name}' execution failed"
@@ -27,6 +30,7 @@ class ToolExecutionError(ToolProcessorError):
 
 class ToolTimeoutError(ToolExecutionError):
     """Raised when a tool execution times out."""
+
     def __init__(self, tool_name: str, timeout: float):
         self.timeout = timeout
         super().__init__(tool_name, Exception(f"Execution timed out after {timeout}s"))
@@ -34,7 +38,8 @@ class ToolTimeoutError(ToolExecutionError):
 
 class ToolValidationError(ToolProcessorError):
     """Raised when tool arguments or results fail validation."""
-    def __init__(self, tool_name: str, errors: Dict[str, Any]):
+
+    def __init__(self, tool_name: str, errors: dict[str, Any]):
         self.tool_name = tool_name
         self.errors = errors
         super().__init__(f"Validation failed for tool '{tool_name}': {errors}")
@@ -42,4 +47,5 @@ class ToolValidationError(ToolProcessorError):
 
 class ParserError(ToolProcessorError):
     """Raised when parsing tool calls from raw input fails."""
-    pass
+
+    pass

chuk_tool_processor/core/processor.py

@@ -7,23 +7,24 @@ This module provides the central ToolProcessor class which handles:
 - Tool execution using configurable strategies
 - Application of execution wrappers (caching, retries, etc.)
 """
+
 from __future__ import annotations
 
 import asyncio
-import time
-import json
 import hashlib
-from typing import Any, Dict, List, Optional, Type, Union, Set
+import json
+import time
+from typing import Any
 
+from chuk_tool_processor.execution.strategies.inprocess_strategy import InProcessStrategy
+from chuk_tool_processor.execution.wrappers.caching import CachingToolExecutor, InMemoryCache
+from chuk_tool_processor.execution.wrappers.rate_limiting import RateLimitedToolExecutor, RateLimiter
+from chuk_tool_processor.execution.wrappers.retry import RetryableToolExecutor, RetryConfig
+from chuk_tool_processor.logging import get_logger, log_context_span, log_tool_call, metrics, request_logging
 from chuk_tool_processor.models.tool_call import ToolCall
 from chuk_tool_processor.models.tool_result import ToolResult
+from chuk_tool_processor.plugins.discovery import discover_default_plugins, plugin_registry
 from chuk_tool_processor.registry import ToolRegistryInterface, ToolRegistryProvider
-from chuk_tool_processor.execution.strategies.inprocess_strategy import InProcessStrategy
-from chuk_tool_processor.execution.wrappers.caching import CacheInterface, InMemoryCache, CachingToolExecutor
-from chuk_tool_processor.execution.wrappers.rate_limiting import RateLimiter, RateLimitedToolExecutor
-from chuk_tool_processor.execution.wrappers.retry import RetryConfig, RetryableToolExecutor
-from chuk_tool_processor.plugins.discovery import plugin_registry, discover_default_plugins
-from chuk_tool_processor.logging import get_logger, log_context_span, request_logging, log_tool_call, metrics
 
 
 class ToolProcessor:
@@ -34,18 +35,18 @@ class ToolProcessor:
 
     def __init__(
         self,
-        registry: Optional[ToolRegistryInterface] = None,
-        strategy = None,
+        registry: ToolRegistryInterface | None = None,
+        strategy=None,
         default_timeout: float = 10.0,
-        max_concurrency: Optional[int] = None,
+        max_concurrency: int | None = None,
         enable_caching: bool = True,
         cache_ttl: int = 300,
         enable_rate_limiting: bool = False,
-        global_rate_limit: Optional[int] = None,
-        tool_rate_limits: Optional[Dict[str, tuple]] = None,
+        global_rate_limit: int | None = None,
+        tool_rate_limits: dict[str, tuple] | None = None,
         enable_retries: bool = True,
         max_retries: int = 3,
-        parser_plugins: Optional[List[str]] = None,
+        parser_plugins: list[str] | None = None,
     ):
         """
         Initialize the tool processor.
@@ -66,7 +67,7 @@ class ToolProcessor:
                 If None, uses all available parsers.
         """
         self.logger = get_logger("chuk_tool_processor.processor")
-        
+
         # Store initialization parameters for lazy initialization
         self._registry = registry
         self._strategy = strategy
@@ -80,13 +81,13 @@ class ToolProcessor:
         self.enable_retries = enable_retries
         self.max_retries = max_retries
         self.parser_plugin_names = parser_plugins
-        
+
         # Placeholder for initialized components
         self.registry = None
         self.strategy = None
         self.executor = None
         self.parsers = []
-        
+
         # Flag for tracking initialization state
         self._initialized = False
         self._init_lock = asyncio.Lock()
@@ -94,28 +95,28 @@ class ToolProcessor:
     async def initialize(self) -> None:
         """
         Initialize the processor asynchronously.
-        
+
         This method ensures all components are properly initialized before use.
         It is called automatically by other methods if needed.
         """
         # Fast path if already initialized
         if self._initialized:
             return
-            
+
         # Ensure only one initialization happens at a time
         async with self._init_lock:
             # Double-check pattern after acquiring lock
             if self._initialized:
                 return
-                
+
             self.logger.debug("Initializing tool processor")
-            
+
             # Get the registry
             if self._registry is not None:
                 self.registry = self._registry
             else:
                 self.registry = await ToolRegistryProvider.get_registry()
-            
+
             # Create execution strategy if needed
             if self._strategy is not None:
                 self.strategy = self._strategy
@@ -125,10 +126,10 @@ class ToolProcessor:
                     default_timeout=self.default_timeout,
                     max_concurrency=self.max_concurrency,
                 )
-            
+
             # Set up the executor chain with optional wrappers
             executor = self.strategy
-            
+
             # Apply wrappers in reverse order (innermost first)
             if self.enable_retries:
                 self.logger.debug("Enabling retry logic")
@@ -136,7 +137,7 @@ class ToolProcessor:
                     executor=executor,
                     default_config=RetryConfig(max_retries=self.max_retries),
                 )
-                
+
             if self.enable_rate_limiting:
                 self.logger.debug("Enabling rate limiting")
                 rate_limiter = RateLimiter(
@@ -147,7 +148,7 @@ class ToolProcessor:
                     executor=executor,
                     limiter=rate_limiter,
                 )
-                
+
             if self.enable_caching:
                 self.logger.debug("Enabling result caching")
                 cache = InMemoryCache(default_ttl=self.cache_ttl)
@@ -156,16 +157,16 @@ class ToolProcessor:
                     cache=cache,
                     default_ttl=self.cache_ttl,
                 )
-            
+
             self.executor = executor
-            
+
             # Initialize parser plugins
             # Discover plugins if not already done
             plugins = plugin_registry.list_plugins().get("parser", [])
             if not plugins:
                 discover_default_plugins()
                 plugins = plugin_registry.list_plugins().get("parser", [])
-                
+
             # Get parser plugins
             if self.parser_plugin_names:
                 self.parsers = [
@@ -174,42 +175,40 @@ class ToolProcessor:
                     if plugin_registry.get_plugin("parser", name)
                 ]
             else:
-                self.parsers = [
-                    plugin_registry.get_plugin("parser", name) for name in plugins
-                ]
-            
+                self.parsers = [plugin_registry.get_plugin("parser", name) for name in plugins]
+
             self.logger.debug(f"Initialized with {len(self.parsers)} parser plugins")
             self._initialized = True
 
     async def process(
         self,
-        data: Union[str, Dict[str, Any], List[Dict[str, Any]]],
-        timeout: Optional[float] = None,
-        use_cache: bool = True,
-        request_id: Optional[str] = None,
-    ) -> List[ToolResult]:
+        data: str | dict[str, Any] | list[dict[str, Any]],
+        timeout: float | None = None,
+        use_cache: bool = True,  # noqa: ARG002
+        request_id: str | None = None,
+    ) -> list[ToolResult]:
         """
         Process tool calls from various input formats.
-        
+
         This method handles different input types:
         - String: Parses tool calls from text using registered parsers
         - Dict: Processes an OpenAI-style tool_calls object
         - List[Dict]: Processes a list of individual tool calls
-        
+
         Args:
             data: Input data containing tool calls
             timeout: Optional timeout for execution
             use_cache: Whether to use cached results
             request_id: Optional request ID for logging
-            
+
         Returns:
             List of tool results
         """
         # Ensure initialization
         await self.initialize()
-        
+
         # Create request context
-        async with request_logging(request_id) as req_id:
+        async with request_logging(request_id):
             # Handle different input types
             if isinstance(data, str):
                 # Text processing
@@ -224,13 +223,13 @@ class ToolProcessor:
                             function = tc["function"]
                             name = function.get("name")
                             args_str = function.get("arguments", "{}")
-                            
+
                             # Parse arguments
                             try:
                                 args = json.loads(args_str) if isinstance(args_str, str) else args_str
                             except json.JSONDecodeError:
                                 args = {"raw": args_str}
-                                
+
                             if name:
                                 calls.append(ToolCall(tool=name, arguments=args, id=tc.get("id")))
                 else:
@@ -242,13 +241,13 @@ class ToolProcessor:
             else:
                 self.logger.warning(f"Unsupported input type: {type(data)}")
                 return []
-                
+
             if not calls:
                 self.logger.debug("No tool calls found")
                 return []
-                
+
             self.logger.debug(f"Found {len(calls)} tool calls")
-            
+
             # Execute tool calls
             async with log_context_span("tool_execution", {"num_calls": len(calls)}):
                 # Check if any tools are unknown
@@ -257,17 +256,17 @@ class ToolProcessor:
                     tool = await self.registry.get_tool(call.tool)
                     if not tool:
                         unknown_tools.append(call.tool)
-                
+
                 if unknown_tools:
                     self.logger.warning(f"Unknown tools: {unknown_tools}")
-                
+
                 # Execute tools
                 results = await self.executor.execute(calls, timeout=timeout)
-                
+
                 # Log metrics for each tool call
-                for call, result in zip(calls, results):
+                for call, result in zip(calls, results, strict=False):
                     await log_tool_call(call, result)
-                    
+
                     # Record metrics
                     duration = (result.end_time - result.start_time).total_seconds()
                     await metrics.log_tool_execution(
@@ -278,19 +277,19 @@ class ToolProcessor:
                         cached=getattr(result, "cached", False),
                         attempts=getattr(result, "attempts", 1),
                     )
-                
+
                 return results
 
     async def process_text(
         self,
         text: str,
-        timeout: Optional[float] = None,
+        timeout: float | None = None,
         use_cache: bool = True,
-        request_id: Optional[str] = None,
-    ) -> List[ToolResult]:
+        request_id: str | None = None,
+    ) -> list[ToolResult]:
         """
         Process text to extract and execute tool calls.
-        
+
         Legacy alias for process() with string input.
 
         Args:
@@ -308,35 +307,33 @@ class ToolProcessor:
             use_cache=use_cache,
             request_id=request_id,
         )
-    
+
     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 a list of ToolCall objects directly.
-        
+
         Args:
             calls: List of tool calls to execute
             timeout: Optional execution timeout
             use_cache: Whether to use cached results
-            
+
         Returns:
             List of tool results
         """
         # Ensure initialization
         await self.initialize()
-        
+
         # Execute with the configured executor
         return await self.executor.execute(
-            calls=calls,
-            timeout=timeout,
-            use_cache=use_cache if hasattr(self.executor, "use_cache") else True
+            calls=calls, timeout=timeout, use_cache=use_cache if hasattr(self.executor, "use_cache") else True
         )
 
-    async def _extract_tool_calls(self, text: str) -> List[ToolCall]:
+    async def _extract_tool_calls(self, text: str) -> list[ToolCall]:
         """
         Extract tool calls from text using all available parsers.
 
@@ -346,19 +343,19 @@ class ToolProcessor:
         Returns:
             List of tool calls.
         """
-        all_calls: List[ToolCall] = []
+        all_calls: list[ToolCall] = []
 
         # Try each parser
         async with log_context_span("parsing", {"text_length": len(text)}):
             parse_tasks = []
-            
+
             # Create parsing tasks
             for parser in self.parsers:
                 parse_tasks.append(self._try_parser(parser, text))
-                
+
             # Execute all parsers concurrently
             parser_results = await asyncio.gather(*parse_tasks, return_exceptions=True)
-            
+
             # Collect successful results
             for result in parser_results:
                 if isinstance(result, Exception):
@@ -370,29 +367,29 @@ class ToolProcessor:
         # Remove duplicates - use a stable digest instead of hashing a
         # frozenset of argument items (which breaks on unhashable types).
         # ------------------------------------------------------------------ #
-        def _args_digest(args: Dict[str, Any]) -> str:
+        def _args_digest(args: dict[str, Any]) -> str:
             """Return a stable hash for any JSON-serialisable payload."""
             blob = json.dumps(args, sort_keys=True, default=str)
             return hashlib.md5(blob.encode()).hexdigest()
 
-        unique_calls: Dict[str, ToolCall] = {}
+        unique_calls: dict[str, ToolCall] = {}
         for call in all_calls:
             key = f"{call.tool}:{_args_digest(call.arguments)}"
             unique_calls[key] = call
 
         return list(unique_calls.values())
-    
-    async def _try_parser(self, parser, text: str) -> List[ToolCall]:
+
+    async def _try_parser(self, parser, text: str) -> list[ToolCall]:
         """Try a single parser with metrics and logging."""
         parser_name = parser.__class__.__name__
-        
+
         async with log_context_span(f"parser.{parser_name}", log_duration=True):
             start_time = time.time()
-            
+
             try:
                 # Try to parse
                 calls = await parser.try_parse(text)
-                
+
                 # Log success
                 duration = time.time() - start_time
                 await metrics.log_parser_metric(
@@ -401,9 +398,9 @@ class ToolProcessor:
                     duration=duration,
                     num_calls=len(calls),
                 )
-                
+
                 return calls
-                
+
             except Exception as e:
                 # Log failure
                 duration = time.time() - start_time
@@ -418,36 +415,38 @@ class ToolProcessor:
 
 
 # Create a global processor instance
-_global_processor: Optional[ToolProcessor] = None
+_global_processor: ToolProcessor | None = None
 _processor_lock = asyncio.Lock()
 
+
 async def get_default_processor() -> ToolProcessor:
     """Get or initialize the default global processor."""
     global _global_processor
-    
+
     if _global_processor is None:
         async with _processor_lock:
             if _global_processor is None:
                 _global_processor = ToolProcessor()
                 await _global_processor.initialize()
-                
+
     return _global_processor
 
+
 async def process(
-    data: Union[str, Dict[str, Any], List[Dict[str, Any]]],
-    timeout: Optional[float] = None,
+    data: str | dict[str, Any] | list[dict[str, Any]],
+    timeout: float | None = None,
     use_cache: bool = True,
-    request_id: Optional[str] = None,
-) -> List[ToolResult]:
+    request_id: str | None = None,
+) -> list[ToolResult]:
     """
     Process tool calls with the default processor.
-    
+
     Args:
         data: Input data (text, dict, or list of dicts)
         timeout: Optional timeout for execution
         use_cache: Whether to use cached results
         request_id: Optional request ID for logging
-        
+
     Returns:
         List of tool results
     """
@@ -459,15 +458,16 @@ async def process(
         request_id=request_id,
     )
 
+
 async def process_text(
     text: str,
-    timeout: Optional[float] = None,
+    timeout: float | None = None,
     use_cache: bool = True,
-    request_id: Optional[str] = None,
-) -> List[ToolResult]:
+    request_id: str | None = None,
+) -> list[ToolResult]:
     """
     Process text with the default processor.
-    
+
     Legacy alias for backward compatibility.
 
     Args:
@@ -485,4 +485,4 @@ async def process_text(
         timeout=timeout,
         use_cache=use_cache,
         request_id=request_id,
-    )
+    )