tooluniverse 1.0.7__py3-none-any.whl → 1.0.8__py3-none-any.whl

tooluniverse/__init__.py

@@ -1,39 +1,54 @@
 from importlib.metadata import version
+import os
 import warnings
 from typing import Any, Optional, List
+
 from .execute_function import ToolUniverse
 from .base_tool import BaseTool
 from .default_config import default_tool_files
+from .tool_registry import register_tool, get_tool_registry
+
+_LIGHT_IMPORT = os.getenv("TOOLUNIVERSE_LIGHT_IMPORT", "false").lower() in (
+    "true",
+    "1",
+    "yes",
+)
 
 # Version information - read from package metadata or pyproject.toml
 __version__ = version("tooluniverse")
-from .tool_registry import register_tool, get_tool_registry
 
 # Import tools with graceful fallback
-try:
-    from . import tools
+if not _LIGHT_IMPORT:
+    try:
+        from . import tools
 
-    _TOOLS_AVAILABLE = True
-except ImportError:
+        _TOOLS_AVAILABLE = True
+    except ImportError:
+        _TOOLS_AVAILABLE = False
+        tools = None  # type: ignore
+else:
     _TOOLS_AVAILABLE = False
     tools = None  # type: ignore
 
 # Check if lazy loading is enabled
-# LAZY_LOADING_ENABLED = os.getenv('TOOLUNIVERSE_LAZY_LOADING', 'true').lower() in ('true', '1', 'yes')
+# LAZY_LOADING_ENABLED = os.getenv('TOOLUNIVERSE_LAZY_LOADING', 'true').lower() in (
+#     'true', '1', 'yes'
+# )
 LAZY_LOADING_ENABLED = (
     False  # LAZY LOADING DISABLED BECAUSE IT'S STILL UNDER DEVELOPMENT
 )
 
 # Import MCP functionality
-try:
-    from .mcp_integration import _patch_tooluniverse
+if not _LIGHT_IMPORT:
+    try:
+        from .mcp_integration import _patch_tooluniverse
 
-    # Automatically patch ToolUniverse with MCP methods
-    _patch_tooluniverse()
+        # Automatically patch ToolUniverse with MCP methods
+        _patch_tooluniverse()
 
-except ImportError:
-    # MCP functionality not available
-    pass
+    except ImportError:
+        # MCP functionality not available
+        pass
 
 # Import SMCP with graceful fallback and consistent signatures for type checking
 try:
@@ -162,7 +177,7 @@ ComposeTool: Any
 CellosaurusSearchTool: Any
 CellosaurusQueryConverterTool: Any
 CellosaurusGetCellLineInfoTool: Any
-if not LAZY_LOADING_ENABLED:
+if not _LIGHT_IMPORT and not LAZY_LOADING_ENABLED:
     # Import all tool classes immediately (old behavior) with warning suppression  # noqa: E501
     with warnings.catch_warnings():
         warnings.filterwarnings("ignore", category=DeprecationWarning)

tooluniverse/admetai_tool.py

@@ -30,13 +30,15 @@ class ADMETAITool(BaseTool):
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
+        # Initialize the model once during tool initialization
+        self.model = ADMETModel()
 
     def _predict(self, smiles: str) -> dict:
         """
         Gets ADMET predictions for the given smiles
         """
-        model = ADMETModel()
-        preds = model.predict(smiles=smiles)
+        # Reuse the pre-loaded model instead of creating a new one
+        preds = self.model.predict(smiles=smiles)
         return preds
 
     def run(self, arguments: dict) -> dict:
@@ -47,7 +49,8 @@ class ADMETAITool(BaseTool):
             smiles: The SMILES string(s) of the molecule(s).
 
         Returns:
-            A dictionary mapping each SMILES string to a subdictionary of selected ADMET properties and their predicted values.
+            A dictionary mapping each SMILES string to a subdictionary of
+            selected ADMET properties and their predicted values.
         """
         smiles = arguments.get("smiles", [])
         if not smiles:
@@ -65,7 +68,8 @@ class ADMETAITool(BaseTool):
             ):
                 return {"error": "No predictions could be extracted."}
 
-            # Expand columns to include _drugbank_approved_percentile columns if present
+            # Expand columns to include _drugbank_approved_percentile columns
+            # if present
             if columns is not None:
                 expanded_columns = []
                 for col in columns:

tooluniverse/base_tool.py

@@ -13,11 +13,15 @@ import json
 from pathlib import Path
 from typing import no_type_check, Optional, Dict, Any
 import hashlib
+import inspect
 
 
 class BaseTool:
+    STATIC_CACHE_VERSION = "1"
+
     def __init__(self, tool_config):
         self.tool_config = self._apply_defaults(tool_config)
+        self._cached_version_hash: Optional[str] = None
 
     @classmethod
     def get_default_config_file(cls):
@@ -286,6 +290,38 @@ class BaseTool:
         """
         return self.tool_config.get("cacheable", True)
 
+    def get_cache_namespace(self) -> str:
+        """Return cache namespace identifier for this tool."""
+        return self.tool_config.get("name", self.__class__.__name__)
+
+    def get_cache_version(self) -> str:
+        """Return a stable cache version fingerprint for this tool."""
+        if self._cached_version_hash:
+            return self._cached_version_hash
+
+        hasher = hashlib.sha256()
+        hasher.update(self.STATIC_CACHE_VERSION.encode("utf-8"))
+
+        try:
+            source = inspect.getsource(self.__class__)
+            hasher.update(source.encode("utf-8"))
+        except (OSError, TypeError):
+            pass
+
+        try:
+            schema = json.dumps(self.tool_config.get("parameter", {}), sort_keys=True)
+            hasher.update(schema.encode("utf-8"))
+        except (TypeError, ValueError):
+            pass
+
+        self._cached_version_hash = hasher.hexdigest()[:16]
+        return self._cached_version_hash
+
+    def get_cache_ttl(self, result: Any = None) -> Optional[int]:
+        """Return TTL (seconds) for cached results; None means no expiration."""
+        ttl = self.tool_config.get("cache_ttl")
+        return int(ttl) if ttl is not None else None
+
     def get_tool_info(self) -> Dict[str, Any]:
         """
         Get comprehensive information about this tool.

tooluniverse/biogrid_tool.py

@@ -0,0 +1,118 @@
+"""
+BioGRID Database REST API Tool
+
+This tool provides access to protein and genetic interaction data from the BioGRID database.
+BioGRID is a comprehensive database of physical and genetic interactions.
+"""
+
+import requests
+from typing import Dict, Any, List
+from .base_tool import BaseTool
+from .tool_registry import register_tool
+
+BIOGRID_BASE_URL = "https://webservice.thebiogrid.org"
+
+
+@register_tool("BioGRIDRESTTool")
+class BioGRIDRESTTool(BaseTool):
+    """
+    BioGRID Database REST API tool.
+    Generic wrapper for BioGRID API endpoints defined in ppi_tools.json.
+    """
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+        fields = tool_config.get("fields", {})
+        parameter = tool_config.get("parameter", {})
+
+        self.endpoint_template: str = fields.get("endpoint", "/interactions/")
+        self.required: List[str] = parameter.get("required", [])
+        self.output_format: str = fields.get("return_format", "JSON")
+
+    def _build_url(self, arguments: Dict[str, Any]) -> str | Dict[str, Any]:
+        """Build URL for BioGRID API request."""
+        url_path = self.endpoint_template
+        return BIOGRID_BASE_URL + url_path
+
+    def _build_params(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Build parameters for BioGRID API request."""
+        params = {"format": "json", "interSpeciesExcluded": "false"}
+
+        # Check for API key
+        api_key = arguments.get("api_key") or arguments.get("accesskey")
+        if not api_key:
+            # Try to get from environment variable
+            import os
+
+            api_key = os.getenv("BIOGRID_API_KEY")
+
+        if not api_key:
+            raise ValueError(
+                "BioGRID API key is required. Please provide 'api_key' parameter "
+                "or set BIOGRID_API_KEY environment variable. "
+                "Register at: https://webservice.thebiogrid.org/"
+            )
+
+        params["accesskey"] = api_key
+
+        # Map gene names to BioGRID format
+        if "gene_names" in arguments:
+            gene_names = arguments["gene_names"]
+            if isinstance(gene_names, list):
+                params["geneList"] = "|".join(gene_names)
+            else:
+                params["geneList"] = str(gene_names)
+
+        # Add other parameters
+        if "organism" in arguments:
+            # Convert organism name to taxonomy ID
+            organism = arguments["organism"]
+            if organism.lower() == "homo sapiens":
+                params["organism"] = 9606
+            elif organism.lower() == "mus musculus":
+                params["organism"] = 10090
+            else:
+                params["organism"] = organism
+
+        if "interaction_type" in arguments:
+            interaction_type = arguments["interaction_type"]
+            if interaction_type == "physical":
+                params["evidenceList"] = "physical"
+            elif interaction_type == "genetic":
+                params["evidenceList"] = "genetic"
+            # "both" means no evidence filter
+
+        if "limit" in arguments:
+            params["max"] = arguments["limit"]
+
+        return params
+
+    def _make_request(self, url: str, params: Dict[str, Any]) -> Dict[str, Any]:
+        """Perform a GET request and handle common errors."""
+        try:
+            response = requests.get(url, params=params, timeout=30)
+            response.raise_for_status()
+
+            if self.output_format == "JSON":
+                return response.json()
+            else:
+                return {"data": response.text}
+
+        except requests.exceptions.RequestException as e:
+            return {"error": f"Request failed: {str(e)}"}
+        except Exception as e:
+            return {"error": f"Unexpected error: {str(e)}"}
+
+    def run(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Execute the tool with given arguments."""
+        # Validate required parameters
+        for param in self.required:
+            if param not in arguments:
+                return {"error": f"Missing required parameter: {param}"}
+
+        url = self._build_url(arguments)
+        if isinstance(url, dict) and "error" in url:
+            return url
+
+        params = self._build_params(arguments)
+        return self._make_request(url, params)

tooluniverse/build_optimizer.py

@@ -0,0 +1,87 @@
+"""Build optimization utilities for ToolUniverse tools."""
+
+import json
+import hashlib
+from pathlib import Path
+from typing import Dict, Any, Set, Tuple
+
+
+def calculate_tool_hash(tool_config: Dict[str, Any]) -> str:
+    """Calculate a hash for tool configuration to detect changes."""
+    # Create a normalized version of the config for hashing
+    normalized_config = {}
+    for key, value in sorted(tool_config.items()):
+        if key not in ["timestamp", "last_updated", "created_at"]:
+            normalized_config[key] = value
+
+    config_str = json.dumps(normalized_config, sort_keys=True, separators=(",", ":"))
+    return hashlib.md5(config_str.encode("utf-8")).hexdigest()
+
+
+def load_metadata(metadata_file: Path) -> Dict[str, str]:
+    """Load tool metadata from file."""
+    if not metadata_file.exists():
+        return {}
+
+    try:
+        with open(metadata_file, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except (json.JSONDecodeError, IOError):
+        return {}
+
+
+def save_metadata(metadata: Dict[str, str], metadata_file: Path) -> None:
+    """Save tool metadata to file."""
+    metadata_file.parent.mkdir(parents=True, exist_ok=True)
+    with open(metadata_file, "w", encoding="utf-8") as f:
+        json.dump(metadata, f, indent=2, sort_keys=True)
+
+
+def cleanup_orphaned_files(tools_dir: Path, current_tool_names: Set[str]) -> int:
+    """Remove files for tools that no longer exist."""
+    if not tools_dir.exists():
+        return 0
+
+    cleaned_count = 0
+    keep_files = {"__init__", "_shared_client", "__pycache__"}
+
+    for file_path in tools_dir.iterdir():
+        if (
+            file_path.is_file()
+            and file_path.suffix == ".py"
+            and file_path.stem not in keep_files
+            and file_path.stem not in current_tool_names
+        ):
+            print(f"🗑️  Removing orphaned tool file: {file_path.name}")
+            file_path.unlink()
+            cleaned_count += 1
+
+    return cleaned_count
+
+
+def get_changed_tools(
+    current_tools: Dict[str, Any], metadata_file: Path
+) -> Tuple[list, list, list]:
+    """Get lists of new, changed, and unchanged tools."""
+    old_metadata = load_metadata(metadata_file)
+    new_metadata = {}
+    new_tools = []
+    changed_tools = []
+    unchanged_tools = []
+
+    for tool_name, tool_config in current_tools.items():
+        current_hash = calculate_tool_hash(tool_config)
+        new_metadata[tool_name] = current_hash
+
+        old_hash = old_metadata.get(tool_name)
+        if old_hash is None:
+            new_tools.append(tool_name)
+        elif old_hash != current_hash:
+            changed_tools.append(tool_name)
+        else:
+            unchanged_tools.append(tool_name)
+
+    # Save updated metadata
+    save_metadata(new_metadata, metadata_file)
+
+    return new_tools, changed_tools, unchanged_tools

tooluniverse/cache/__init__.py

@@ -0,0 +1,3 @@
+"""Cache utilities for ToolUniverse."""
+
+from .result_cache_manager import ResultCacheManager  # noqa: F401

tooluniverse/cache/memory_cache.py

@@ -0,0 +1,99 @@
+"""
+In-memory cache utilities for ToolUniverse.
+
+Provides a lightweight, thread-safe LRU cache with optional singleflight
+deduplication for expensive misses.
+"""
+
+from __future__ import annotations
+
+import threading
+import time
+from collections import OrderedDict
+from contextlib import contextmanager
+from typing import Any, Dict, Iterator, Optional, Tuple
+
+
+class LRUCache:
+    """Thread-safe LRU cache with basic telemetry."""
+
+    def __init__(self, max_size: int = 128):
+        self.max_size = max(1, int(max_size))
+        self._data: "OrderedDict[str, Tuple[Any, float]]" = OrderedDict()
+        self._lock = threading.RLock()
+        self.hits = 0
+        self.misses = 0
+
+    def get(self, key: str) -> Optional[Any]:
+        with self._lock:
+            if key not in self._data:
+                self.misses += 1
+                return None
+
+            value, timestamp = self._data.pop(key)
+            self._data[key] = (value, timestamp)
+            self.hits += 1
+            return value
+
+    def set(self, key: str, value: Any):
+        with self._lock:
+            if key in self._data:
+                self._data.pop(key)
+            self._data[key] = (value, time.time())
+            self._evict_if_needed()
+
+    def delete(self, key: str):
+        with self._lock:
+            self._data.pop(key, None)
+
+    def clear(self):
+        with self._lock:
+            self._data.clear()
+            self.hits = 0
+            self.misses = 0
+
+    def _evict_if_needed(self):
+        while len(self._data) > self.max_size:
+            self._data.popitem(last=False)
+
+    def stats(self) -> Dict[str, Any]:
+        with self._lock:
+            return {
+                "max_size": self.max_size,
+                "current_size": len(self._data),
+                "hits": self.hits,
+                "misses": self.misses,
+            }
+
+    def __len__(self) -> int:
+        with self._lock:
+            return len(self._data)
+
+    def items(self) -> Iterator[Tuple[str, Any]]:
+        with self._lock:
+            for key, (value, _) in list(self._data.items()):
+                yield key, value
+
+
+class SingleFlight:
+    """Per-key lock manager to collapse duplicate cache misses."""
+
+    def __init__(self):
+        self._locks: Dict[str, threading.Lock] = {}
+        self._global = threading.Lock()
+
+    @contextmanager
+    def acquire(self, key: str):
+        with self._global:
+            lock = self._locks.get(key)
+            if lock is None:
+                lock = threading.Lock()
+                self._locks[key] = lock
+        lock.acquire()
+        try:
+            yield
+        finally:
+            lock.release()
+            with self._global:
+                if not lock.locked():
+                    self._locks.pop(key, None)