chuk-tool-processor 0.6.4__py3-none-any.whl → 0.9.7__py3-none-any.whl

chuk_tool_processor/logging/formatter.py

@@ -2,12 +2,13 @@
 """
 Structured JSON formatter for logging.
 """
+
 from __future__ import annotations
 
 import json
 import logging
-from datetime import datetime, timezone
-from typing import Any, Dict
+from datetime import UTC, datetime
+from typing import Any
 
 __all__ = ["StructuredFormatter"]
 
@@ -15,7 +16,7 @@ __all__ = ["StructuredFormatter"]
 class StructuredFormatter(logging.Formatter):
     """
     JSON formatter that can serialize BaseModels, datetimes, sets, etc.
-    
+
     This formatter converts log records to JSON format with proper handling
     of various Python types, ensuring logs are machine-readable and structured.
     """
@@ -24,10 +25,10 @@ class StructuredFormatter(logging.Formatter):
     def _json_default(obj: Any) -> Any:
         """
         Custom JSON serializer for handling special types.
-        
+
         Args:
             obj: Object to serialize
-            
+
         Returns:
             JSON-serializable representation
         """
@@ -36,42 +37,42 @@ class StructuredFormatter(logging.Formatter):
             # Import pydantic inside the method to avoid global import errors
             # This allows the formatter to work even if pydantic is not installed
             from pydantic import BaseModel
+
             if isinstance(obj, BaseModel):
                 return obj.model_dump()
         except (ImportError, AttributeError):
             # Either pydantic is not installed or the object doesn't have model_dump
             pass
-            
+
         # Handle dates and datetimes
         try:
             from datetime import date
-            if isinstance(obj, (datetime, date)):
+
+            if isinstance(obj, datetime | date):
                 return obj.isoformat()
         except ImportError:
             pass
-            
+
         # Sets → list
-        if isinstance(obj, (set, frozenset)):
+        if isinstance(obj, set | frozenset):
             return list(obj)
-            
+
         # Fall back to string representation
         return str(obj)
 
     def format(self, record: logging.LogRecord) -> str:
         """
         Format a log record as JSON.
-        
+
         Args:
             record: Log record to format
-            
+
         Returns:
             JSON string representation
         """
         # Build base data structure
-        data: Dict[str, Any] = {
-            "timestamp": datetime.fromtimestamp(record.created, timezone.utc)
-            .isoformat()
-            .replace("+00:00", "Z"),
+        data: dict[str, Any] = {
+            "timestamp": datetime.fromtimestamp(record.created, UTC).isoformat().replace("+00:00", "Z"),
             "level": record.levelname,
             "message": record.getMessage(),
             "logger": record.name,
@@ -81,18 +82,18 @@ class StructuredFormatter(logging.Formatter):
             "line": record.lineno,
             "function": record.funcName,
         }
-        
+
         # Add exception traceback if present
         if record.exc_info:
             data["traceback"] = self.formatException(record.exc_info)
-            
+
         # Add extra fields if present
         if hasattr(record, "extra"):
             data.update(record.extra)
-            
+
         # Add context if present
         if hasattr(record, "context"):
             data["context"] = record.context
-            
+
         # Serialize to JSON
-        return json.dumps(data, default=self._json_default)
+        return json.dumps(data, default=self._json_default)

chuk_tool_processor/logging/helpers.py

@@ -2,44 +2,40 @@
 """
 Async-native logging helpers for tracing and monitoring tool execution.
 """
+
 from __future__ import annotations
 
 import time
 import uuid
+from collections.abc import AsyncGenerator
 from contextlib import asynccontextmanager
-from datetime import datetime, timezone
-from typing import Any, Dict, Optional, AsyncGenerator
+from datetime import UTC, datetime
+from typing import Any
 
 # Import context directly - avoid circular imports
 from .context import get_logger, log_context
 
-__all__ = [
-    "log_context_span",
-    "request_logging",
-    "log_tool_call"
-]
+__all__ = ["log_context_span", "request_logging", "log_tool_call"]
+
 
 # --------------------------------------------------------------------------- #
 # async context-manager helpers
 # --------------------------------------------------------------------------- #
 @asynccontextmanager
 async def log_context_span(
-    operation: str, 
-    extra: Optional[Dict[str, Any]] = None, 
-    *, 
-    log_duration: bool = True
+    operation: str, extra: dict[str, Any] | None = None, *, log_duration: bool = True
 ) -> AsyncGenerator[None, None]:
     """
     Create an async context manager for a logging span.
-    
+
     This context manager tracks the execution of an operation,
     logging its start, completion, and duration.
-    
+
     Args:
         operation: Name of the operation
         extra: Optional additional context to include
         log_duration: Whether to log the duration
-        
+
     Yields:
         Nothing
     """
@@ -49,28 +45,22 @@ async def log_context_span(
     span_ctx = {
         "span_id": span_id,
         "operation": operation,
-        "start_time": datetime.fromtimestamp(start, timezone.utc)
-        .isoformat()
-        .replace("+00:00", "Z"),
+        "start_time": datetime.fromtimestamp(start, UTC).isoformat().replace("+00:00", "Z"),
     }
     if extra:
         span_ctx.update(extra)
     prev = log_context.get_copy()
     log_context.update(span_ctx)
 
-    logger.info("Starting %s", operation)
+    logger.debug("Starting %s", operation)
     try:
         yield
         if log_duration:
-            logger.info(
-                "Completed %s", operation, extra={"context": {"duration": time.time() - start}}
-            )
+            logger.debug("Completed %s", operation, extra={"context": {"duration": time.time() - start}})
         else:
-            logger.info("Completed %s", operation)
+            logger.debug("Completed %s", operation)
     except Exception as exc:
-        logger.exception(
-            "Error in %s: %s", operation, exc, extra={"context": {"duration": time.time() - start}}
-        )
+        logger.exception("Error in %s: %s", operation, exc, extra={"context": {"duration": time.time() - start}})
         raise
     finally:
         log_context.clear()
@@ -79,28 +69,26 @@ async def log_context_span(
 
 
 @asynccontextmanager
-async def request_logging(
-    request_id: Optional[str] = None
-) -> AsyncGenerator[str, None]:
+async def request_logging(request_id: str | None = None) -> AsyncGenerator[str, None]:
     """
     Create an async context manager for request logging.
-    
+
     This context manager tracks a request from start to finish,
     including duration and any errors.
-    
+
     Args:
         request_id: Optional request ID (generated if not provided)
-        
+
     Yields:
         The request ID
     """
     logger = get_logger("chuk_tool_processor.request")
     request_id = log_context.start_request(request_id)
     start = time.time()
-    logger.info("Starting request %s", request_id)
+    logger.debug("Starting request %s", request_id)
     try:
         yield request_id
-        logger.info(
+        logger.debug(
             "Completed request %s",
             request_id,
             extra={"context": {"duration": time.time() - start}},
@@ -123,7 +111,7 @@ async def request_logging(
 async def log_tool_call(tool_call: Any, tool_result: Any) -> None:
     """
     Log a tool call and its result.
-    
+
     Args:
         tool_call: The tool call object
         tool_result: The tool result object
@@ -140,24 +128,22 @@ async def log_tool_call(tool_call: Any, tool_result: Any) -> None:
         "tool": tool_call.tool,
         "arguments": tool_call.arguments,
         "result": (
-            tool_result.result.model_dump()
-            if hasattr(tool_result.result, "model_dump")
-            else tool_result.result
+            tool_result.result.model_dump() if hasattr(tool_result.result, "model_dump") else tool_result.result
         ),
         "error": tool_result.error,
         "duration": dur,
         "machine": tool_result.machine,
         "pid": tool_result.pid,
     }
-    
+
     # Add optional fields safely (handle MagicMock in tests)
     try:
         if hasattr(tool_result, "cached") and tool_result.cached:
             ctx["cached"] = True
     except (TypeError, ValueError):
         pass
-    
-    # Handle attempts field specifically    
+
+    # Handle attempts field specifically
     if hasattr(tool_result, "attempts"):
         try:
             # First, try direct attribute access and direct comparison
@@ -173,7 +159,7 @@ async def log_tool_call(tool_call: Any, tool_result: Any) -> None:
             except (TypeError, ValueError):
                 # If all else fails, just include the value
                 ctx["attempts"] = tool_result.attempts
-            
+
     try:
         if hasattr(tool_result, "stream_id") and tool_result.stream_id:
             ctx["stream_id"] = tool_result.stream_id
@@ -184,4 +170,4 @@ async def log_tool_call(tool_call: Any, tool_result: Any) -> None:
     if tool_result.error:
         logger.error("Tool %s failed: %s", tool_call.tool, tool_result.error, extra={"context": ctx})
     else:
-        logger.info("Tool %s succeeded in %.3fs", tool_call.tool, dur, extra={"context": ctx})
+        logger.debug("Tool %s succeeded in %.3fs", tool_call.tool, dur, extra={"context": ctx})

chuk_tool_processor/logging/metrics.py

@@ -2,10 +2,8 @@
 """
 Metrics logging for tool execution.
 """
-from __future__ import annotations
 
-import asyncio
-from typing import Dict, Any, Optional
+from __future__ import annotations
 
 # Import directly from context to avoid circular imports
 from .context import get_logger
@@ -16,11 +14,11 @@ __all__ = ["metrics", "MetricsLogger"]
 class MetricsLogger:
     """
     Logger for collecting and reporting metrics about tool execution.
-    
+
     Provides methods to log tool execution metrics and parser metrics
     in a structured format.
     """
-    
+
     def __init__(self):
         """Initialize with logger."""
         self.logger = get_logger("chuk_tool_processor.metrics")
@@ -32,13 +30,13 @@ class MetricsLogger:
         success: bool,
         duration: float,
         *,
-        error: Optional[str] = None,
+        error: str | None = None,
         cached: bool = False,
         attempts: int = 1,
     ) -> None:
         """
         Log metrics for a tool execution.
-        
+
         Args:
             tool: Name of the tool
             success: Whether execution was successful
@@ -47,7 +45,7 @@ class MetricsLogger:
             cached: Whether the result was retrieved from cache
             attempts: Number of execution attempts
         """
-        self.logger.info(
+        self.logger.debug(
             f"Tool execution metric: {tool}",
             extra={
                 "context": {
@@ -71,14 +69,14 @@ class MetricsLogger:
     ) -> None:
         """
         Log metrics for a parser.
-        
+
         Args:
             parser: Name of the parser
             success: Whether parsing was successful
             duration: Parsing duration in seconds
             num_calls: Number of tool calls parsed
         """
-        self.logger.info(
+        self.logger.debug(
             f"Parser metric: {parser}",
             extra={
                 "context": {
@@ -90,18 +88,18 @@ class MetricsLogger:
                 }
             },
         )
-        
+
     async def log_registry_metric(
         self,
         operation: str,
         success: bool,
         duration: float,
-        tool: Optional[str] = None,
-        namespace: Optional[str] = None,
+        tool: str | None = None,
+        namespace: str | None = None,
     ) -> None:
         """
         Log metrics for registry operations.
-        
+
         Args:
             operation: Type of registry operation
             success: Whether operation was successful
@@ -125,4 +123,4 @@ class MetricsLogger:
 
 
 # Create global instance
-metrics = MetricsLogger()
+metrics = MetricsLogger()

chuk_tool_processor/mcp/__init__.py

@@ -7,22 +7,18 @@ Updated to support the latest MCP transports:
 - SSE (Server-Sent Events)
 - HTTP Streamable (modern replacement for SSE, spec 2025-03-26)
 """
-from chuk_tool_processor.mcp.transport import (
-    MCPBaseTransport, 
-    StdioTransport, 
-    SSETransport, 
-    HTTPStreamableTransport
-)
-from chuk_tool_processor.mcp.stream_manager import StreamManager
+
 from chuk_tool_processor.mcp.mcp_tool import MCPTool
 from chuk_tool_processor.mcp.register_mcp_tools import register_mcp_tools
-from chuk_tool_processor.mcp.setup_mcp_stdio import setup_mcp_stdio
-from chuk_tool_processor.mcp.setup_mcp_sse import setup_mcp_sse
 from chuk_tool_processor.mcp.setup_mcp_http_streamable import setup_mcp_http_streamable
+from chuk_tool_processor.mcp.setup_mcp_sse import setup_mcp_sse
+from chuk_tool_processor.mcp.setup_mcp_stdio import setup_mcp_stdio
+from chuk_tool_processor.mcp.stream_manager import StreamManager
+from chuk_tool_processor.mcp.transport import HTTPStreamableTransport, MCPBaseTransport, SSETransport, StdioTransport
 
 __all__ = [
     "MCPBaseTransport",
-    "StdioTransport", 
+    "StdioTransport",
     "SSETransport",
     "HTTPStreamableTransport",
     "StreamManager",
@@ -30,5 +26,5 @@ __all__ = [
     "register_mcp_tools",
     "setup_mcp_stdio",
     "setup_mcp_sse",
-    "setup_mcp_http_streamable"
-]
+    "setup_mcp_http_streamable",
+]