onetool-mcp 1.0.0b1__py3-none-any.whl → 1.0.0rc2__py3-none-any.whl

ot/stats/timing.py

@@ -1,57 +1,57 @@
-"""Timing context manager for tool call statistics.
-
-Provides a reusable context manager that handles timing, success/error
-tracking, and stats recording for tool calls.
-"""
-
-from __future__ import annotations
-
-import time
-from contextlib import contextmanager
-from typing import TYPE_CHECKING
-
-from ot.stats.jsonl_writer import get_client_name, record_tool_stats
-
-if TYPE_CHECKING:
-    from collections.abc import Iterator
-
-
-@contextmanager
-def timed_tool_call(tool_name: str, client: str | None = None) -> Iterator[None]:
-    """Context manager for timing tool calls and recording stats.
-
-    Measures execution time, tracks success/failure, and records stats
-    to the global stats writer.
-
-    Args:
-        tool_name: Fully qualified tool name (e.g., "brave.search")
-        client: MCP client name. If None, uses global client name.
-
-    Yields:
-        None
-
-    Example:
-        with timed_tool_call("brave.search"):
-            result = brave.search(query="test")
-    """
-    if client is None:
-        client = get_client_name()
-
-    start_time = time.monotonic()
-    error_type: str | None = None
-    success = True
-
-    try:
-        yield
-    except Exception as e:
-        success = False
-        error_type = type(e).__name__
-        raise
-    finally:
-        duration_ms = int((time.monotonic() - start_time) * 1000)
-        record_tool_stats(
-            tool=tool_name,
-            duration_ms=duration_ms,
-            success=success,
-            error_type=error_type,
-        )
+"""Timing context manager for tool call statistics.
+
+Provides a reusable context manager that handles timing, success/error
+tracking, and stats recording for tool calls.
+"""
+
+from __future__ import annotations
+
+import time
+from contextlib import contextmanager
+from typing import TYPE_CHECKING
+
+from ot.stats.jsonl_writer import get_client_name, record_tool_stats
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+
+@contextmanager
+def timed_tool_call(tool_name: str, client: str | None = None) -> Iterator[None]:
+    """Context manager for timing tool calls and recording stats.
+
+    Measures execution time, tracks success/failure, and records stats
+    to the global stats writer.
+
+    Args:
+        tool_name: Fully qualified tool name (e.g., "brave.search")
+        client: MCP client name. If None, uses global client name.
+
+    Yields:
+        None
+
+    Example:
+        with timed_tool_call("brave.search"):
+            result = brave.search(query="test")
+    """
+    if client is None:
+        client = get_client_name()
+
+    start_time = time.monotonic()
+    error_type: str | None = None
+    success = True
+
+    try:
+        yield
+    except Exception as e:
+        success = False
+        error_type = type(e).__name__
+        raise
+    finally:
+        duration_ms = int((time.monotonic() - start_time) * 1000)
+        record_tool_stats(
+            tool=tool_name,
+            duration_ms=duration_ms,
+            success=success,
+            error_type=error_type,
+        )

ot/support.py

@@ -1,63 +1,63 @@
-"""Centralized support information for OneTool.
-
-Single source of truth for donation/support links, messages, and version.
-"""
-
-from __future__ import annotations
-
-from importlib.metadata import PackageNotFoundError, version
-
-# Support URLs
-KOFI_URL = "https://ko-fi.com/beycom"
-KOFI_HANDLE = "beycom"
-
-# Support messages
-SUPPORT_MESSAGE = "If you find OneTool useful, please consider supporting development!"
-SUPPORT_MESSAGE_SHORT = "Support OneTool development"
-
-# For HTML reports
-SUPPORT_HTML_TITLE = "Support OneTool"
-SUPPORT_HTML_MESSAGE = "If you find this project useful, please consider buying me a coffee!"
-SUPPORT_HTML_BUTTON_TEXT = "Buy me a coffee on Ko-fi"
-
-
-def get_support_dict() -> dict[str, str]:
-    """Get support info as a dictionary for JSON output.
-
-    Returns:
-        Dict with support URLs and messages
-    """
-    return {
-        "message": SUPPORT_MESSAGE,
-        "kofi_url": KOFI_URL,
-    }
-
-
-def get_startup_message() -> str:
-    """Get support message for server startup logs.
-
-    Returns:
-        Formatted startup message with support link
-    """
-    return f"{SUPPORT_MESSAGE_SHORT}: {KOFI_URL}"
-
-
-def get_support_banner() -> str:
-    """Get Rich-formatted support message for CLI banners.
-
-    Returns:
-        Rich markup string for console.print()
-    """
-    return f"[yellow]☕ Please buy me a coffee:[/yellow] [link={KOFI_URL}]{KOFI_URL}[/link]"
-
-
-def get_version() -> str:
-    """Get OneTool package version.
-
-    Returns:
-        Version string, or "dev" if not installed as a package.
-    """
-    try:
-        return version("onetool")
-    except PackageNotFoundError:
-        return "dev"
+"""Centralized support information for OneTool.
+
+Single source of truth for donation/support links, messages, and version.
+"""
+
+from __future__ import annotations
+
+from importlib.metadata import PackageNotFoundError, version
+
+# Support URLs
+KOFI_URL = "https://ko-fi.com/beycom"
+KOFI_HANDLE = "beycom"
+
+# Support messages
+SUPPORT_MESSAGE = "If you find OneTool useful, please consider supporting development!"
+SUPPORT_MESSAGE_SHORT = "Support OneTool development"
+
+# For HTML reports
+SUPPORT_HTML_TITLE = "Support OneTool"
+SUPPORT_HTML_MESSAGE = "If you find this project useful, please consider buying me a coffee!"
+SUPPORT_HTML_BUTTON_TEXT = "Buy me a coffee on Ko-fi"
+
+
+def get_support_dict() -> dict[str, str]:
+    """Get support info as a dictionary for JSON output.
+
+    Returns:
+        Dict with support URLs and messages
+    """
+    return {
+        "message": SUPPORT_MESSAGE,
+        "kofi_url": KOFI_URL,
+    }
+
+
+def get_startup_message() -> str:
+    """Get support message for server startup logs.
+
+    Returns:
+        Formatted startup message with support link
+    """
+    return f"{SUPPORT_MESSAGE_SHORT}: {KOFI_URL}"
+
+
+def get_support_banner() -> str:
+    """Get Rich-formatted support message for CLI banners.
+
+    Returns:
+        Rich markup string for console.print()
+    """
+    return f"[yellow]☕ Please buy me a coffee:[/yellow] [link={KOFI_URL}]{KOFI_URL}[/link]"
+
+
+def get_version() -> str:
+    """Get OneTool package version.
+
+    Returns:
+        Version string, or "dev" if not installed as a package.
+    """
+    try:
+        return version("onetool")
+    except PackageNotFoundError:
+        return "dev"

ot/tools.py

@@ -93,7 +93,7 @@ def get_pack(name: str) -> Any:
         results = brave.search(query="python")
 
         llm = get_pack("llm")
-        summary = llm.transform(input=text, prompt="Summarize")
+        summary = llm.transform(data=text, prompt="Summarize")
     """
     from ot.executor.pack_proxy import build_execution_namespace
     from ot.executor.tool_loader import load_tool_registry

ot/utils/batch.py

@@ -1,161 +1,161 @@
-"""Batch processing utilities for OneTool.
-
-Provides concurrent execution helpers for tools that process multiple items.
-
-Example:
-    from ot.utils import batch_execute, normalize_items
-
-    # Process URLs concurrently
-    def fetch_one(url: str, label: str) -> tuple[str, str]:
-        result = fetch(url)
-        return label, result
-
-    urls = ["https://a.com", ("https://b.com", "Custom Label")]
-    normalized = normalize_items(urls)  # [(url, label), ...]
-    results = batch_execute(fetch_one, normalized, max_workers=5)
-"""
-
-from __future__ import annotations
-
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from typing import TYPE_CHECKING, Any, TypeVar
-
-if TYPE_CHECKING:
-    from collections.abc import Callable
-
-__all__ = ["batch_execute", "format_batch_results", "normalize_items"]
-
-T = TypeVar("T")
-R = TypeVar("R")
-
-
-def normalize_items(
-    items: list[str] | list[tuple[str, str]],
-) -> list[tuple[str, str]]:
-    """Normalize a list of items to (value, label) tuples.
-
-    Accepts items as either:
-    - A string (used as both value and label)
-    - A tuple of (value, label)
-
-    This is the standard pattern for batch operations in OneTool,
-    allowing users to provide custom labels for results.
-
-    Args:
-        items: List of items as strings or (value, label) tuples
-
-    Returns:
-        List of (value, label) tuples
-
-    Example:
-        # Simple list
-        normalize_items(["a", "b", "c"])
-        # Returns: [("a", "a"), ("b", "b"), ("c", "c")]
-
-        # Mixed list
-        normalize_items(["a", ("b", "Custom B")])
-        # Returns: [("a", "a"), ("b", "Custom B")]
-
-        # Labeled list
-        normalize_items([
-            ("https://example.com", "Example"),
-            ("https://docs.python.org", "Python Docs"),
-        ])
-        # Returns: [("https://example.com", "Example"), ...]
-    """
-    normalized: list[tuple[str, str]] = []
-    for item in items:
-        if isinstance(item, str):
-            normalized.append((item, item))
-        else:
-            normalized.append(item)
-    return normalized
-
-
-def batch_execute(
-    func: Callable[[str, str], tuple[str, R]],
-    items: list[tuple[str, str]],
-    *,
-    max_workers: int | None = None,
-    preserve_order: bool = True,
-) -> dict[str, R]:
-    """Execute a function concurrently on multiple items.
-
-    Runs the provided function on each item using a ThreadPoolExecutor.
-    The function receives (value, label) and must return (label, result).
-
-    Args:
-        func: Function taking (value: str, label: str) and returning (label, result)
-        items: List of (value, label) tuples (use normalize_items to prepare)
-        max_workers: Maximum concurrent workers. Defaults to len(items) (up to 10)
-        preserve_order: If True (default), results maintain input order
-
-    Returns:
-        Dict mapping labels to results
-
-    Example:
-        def search_one(query: str, label: str) -> tuple[str, str]:
-            result = some_search(query)
-            return label, result
-
-        items = normalize_items(["query1", ("query2", "Custom")])
-        results = batch_execute(search_one, items, max_workers=5)
-        # results = {"query1": ..., "Custom": ...}
-    """
-    if not items:
-        return {}
-
-    if max_workers is None:
-        max_workers = min(len(items), 10)
-
-    results: dict[str, R] = {}
-
-    with ThreadPoolExecutor(max_workers=max_workers) as executor:
-        futures = {
-            executor.submit(func, value, label): label for value, label in items
-        }
-        for future in as_completed(futures):
-            label, result = future.result()
-            results[label] = result
-
-    if preserve_order:
-        # Rebuild dict in original order
-        ordered: dict[str, R] = {}
-        for _, label in items:
-            if label in results:
-                ordered[label] = results[label]
-        return ordered
-
-    return results
-
-
-def format_batch_results(
-    results: dict[str, Any],
-    items: list[tuple[str, str]],
-    separator: str = "===",
-) -> str:
-    """Format batch results as labeled sections.
-
-    Creates a formatted string with section headers for each result,
-    preserving the original order from the items list.
-
-    Args:
-        results: Dict mapping labels to result strings
-        items: Original list of (value, label) tuples for ordering
-        separator: Section separator character(s) (default: "===")
-
-    Returns:
-        Formatted string with sections like "=== Label ===\\n{content}"
-
-    Example:
-        results = {"A": "content a", "B": "content b"}
-        items = [("x", "A"), ("y", "B")]
-        output = format_batch_results(results, items)
-        # "=== A ===\\ncontent a\\n\\n=== B ===\\ncontent b"
-    """
-    sections = []
-    for _, label in items:
-        if label in results:
-            content = results[label]
-            sections.append(f"{separator} {label} {separator}\n{content}")
-    return "\n\n".join(sections)
+"""Batch processing utilities for OneTool.
+
+Provides concurrent execution helpers for tools that process multiple items.
+
+Example:
+    from ot.utils import batch_execute, normalize_items
+
+    # Process URLs concurrently
+    def fetch_one(url: str, label: str) -> tuple[str, str]:
+        result = fetch(url)
+        return label, result
+
+    urls = ["https://a.com", ("https://b.com", "Custom Label")]
+    normalized = normalize_items(urls)  # [(url, label), ...]
+    results = batch_execute(fetch_one, normalized, max_workers=5)
+"""
+
+from __future__ import annotations
+
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import TYPE_CHECKING, Any, TypeVar
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+__all__ = ["batch_execute", "format_batch_results", "normalize_items"]
+
+T = TypeVar("T")
+R = TypeVar("R")
+
+
+def normalize_items(
+    items: list[str] | list[tuple[str, str]],
+) -> list[tuple[str, str]]:
+    """Normalize a list of items to (value, label) tuples.
+
+    Accepts items as either:
+    - A string (used as both value and label)
+    - A tuple of (value, label)
+
+    This is the standard pattern for batch operations in OneTool,
+    allowing users to provide custom labels for results.
+
+    Args:
+        items: List of items as strings or (value, label) tuples
+
+    Returns:
+        List of (value, label) tuples
+
+    Example:
+        # Simple list
+        normalize_items(["a", "b", "c"])
+        # Returns: [("a", "a"), ("b", "b"), ("c", "c")]
+
+        # Mixed list
+        normalize_items(["a", ("b", "Custom B")])
+        # Returns: [("a", "a"), ("b", "Custom B")]
+
+        # Labeled list
+        normalize_items([
+            ("https://example.com", "Example"),
+            ("https://docs.python.org", "Python Docs"),
+        ])
+        # Returns: [("https://example.com", "Example"), ...]
+    """
+    normalized: list[tuple[str, str]] = []
+    for item in items:
+        if isinstance(item, str):
+            normalized.append((item, item))
+        else:
+            normalized.append(item)
+    return normalized
+
+
+def batch_execute(
+    func: Callable[[str, str], tuple[str, R]],
+    items: list[tuple[str, str]],
+    *,
+    max_workers: int | None = None,
+    preserve_order: bool = True,
+) -> dict[str, R]:
+    """Execute a function concurrently on multiple items.
+
+    Runs the provided function on each item using a ThreadPoolExecutor.
+    The function receives (value, label) and must return (label, result).
+
+    Args:
+        func: Function taking (value: str, label: str) and returning (label, result)
+        items: List of (value, label) tuples (use normalize_items to prepare)
+        max_workers: Maximum concurrent workers. Defaults to len(items) (up to 10)
+        preserve_order: If True (default), results maintain input order
+
+    Returns:
+        Dict mapping labels to results
+
+    Example:
+        def search_one(query: str, label: str) -> tuple[str, str]:
+            result = some_search(query)
+            return label, result
+
+        items = normalize_items(["query1", ("query2", "Custom")])
+        results = batch_execute(search_one, items, max_workers=5)
+        # results = {"query1": ..., "Custom": ...}
+    """
+    if not items:
+        return {}
+
+    if max_workers is None:
+        max_workers = min(len(items), 10)
+
+    results: dict[str, R] = {}
+
+    with ThreadPoolExecutor(max_workers=max_workers) as executor:
+        futures = {
+            executor.submit(func, value, label): label for value, label in items
+        }
+        for future in as_completed(futures):
+            label, result = future.result()
+            results[label] = result
+
+    if preserve_order:
+        # Rebuild dict in original order
+        ordered: dict[str, R] = {}
+        for _, label in items:
+            if label in results:
+                ordered[label] = results[label]
+        return ordered
+
+    return results
+
+
+def format_batch_results(
+    results: dict[str, Any],
+    items: list[tuple[str, str]],
+    separator: str = "===",
+) -> str:
+    """Format batch results as labeled sections.
+
+    Creates a formatted string with section headers for each result,
+    preserving the original order from the items list.
+
+    Args:
+        results: Dict mapping labels to result strings
+        items: Original list of (value, label) tuples for ordering
+        separator: Section separator character(s) (default: "===")
+
+    Returns:
+        Formatted string with sections like "=== Label ===\\n{content}"
+
+    Example:
+        results = {"A": "content a", "B": "content b"}
+        items = [("x", "A"), ("y", "B")]
+        output = format_batch_results(results, items)
+        # "=== A ===\\ncontent a\\n\\n=== B ===\\ncontent b"
+    """
+    sections = []
+    for _, label in items:
+        if label in results:
+            content = results[label]
+            sections.append(f"{separator} {label} {separator}\n{content}")
+    return "\n\n".join(sections)