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

tooluniverse/dbsnp_tool.py

@@ -0,0 +1,71 @@
+import requests
+from .base_tool import BaseTool
+from .tool_registry import register_tool
+
+
+@register_tool("DbSnpTool")
+class DbSnpTool(BaseTool):
+    """
+    Local tool wrapper for dbSNP via NCBI Variation Services.
+    Fetches variant by rsID using the refsnp endpoint.
+    """
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+        self.base = "https://api.ncbi.nlm.nih.gov/variation/v0"
+        self.session = requests.Session()
+
+    def run(self, arguments):
+        rsid = arguments.get("rsid")
+        if not rsid:
+            return {"error": "Missing required parameter: rsid"}
+
+        # Clean rsid (remove 'rs' prefix if present)
+        if rsid.startswith("rs"):
+            rsid = rsid[2:]
+
+        url = f"{self.base}/refsnp/{rsid}"
+        resp = self.session.get(url, timeout=20)
+        resp.raise_for_status()
+        data = resp.json()
+
+        # Extract key fields from primary snapshot
+        primary = data.get("primary_snapshot_data", {})
+        placements = primary.get("placements_with_allele", [])
+
+        chrom = ""
+        pos = None
+        alleles = []
+        hgvs = []
+
+        if placements:
+            placement = placements[0]
+            chrom = (
+                placement.get("seq_id", "").replace("NC_0000", "").replace(".11", "")
+            )
+            if chrom.startswith("0"):
+                chrom = chrom[1:]
+            chrom = f"chr{chrom}"
+
+            allele_data = placement.get("alleles", [])
+            for allele in allele_data:
+                spdi = allele.get("allele", {}).get("spdi", {})
+                if spdi:
+                    ref = spdi.get("deleted_sequence", "")
+                    alt = spdi.get("inserted_sequence", "")
+                    if ref and alt:
+                        alleles.append(f"{ref}>{alt}")
+                    elif ref:
+                        alleles.append(ref)
+
+                hgvs_val = allele.get("hgvs", "")
+                if hgvs_val:
+                    hgvs.append(hgvs_val)
+
+        return {
+            "refsnp_id": f"rs{rsid}",
+            "chrom": chrom,
+            "pos": pos,
+            "alleles": alleles,
+            "hgvs": hgvs,
+        }

tooluniverse/default_config.py

@@ -51,6 +51,9 @@ default_tool_files = {
     "fatcat": os.path.join(current_dir, "data", "fatcat_tools.json"),
     "wikidata_sparql": os.path.join(current_dir, "data", "wikidata_sparql_tools.json"),
     "agents": os.path.join(current_dir, "data", "agentic_tools.json"),
+    "drug_discovery_agents": os.path.join(
+        current_dir, "data", "drug_discovery_agents.json"
+    ),
     "dataset": os.path.join(current_dir, "data", "dataset_tools.json"),
     # 'mcp_clients': os.path.join(current_dir, 'data', 'mcp_client_tools_example.json'),
     "mcp_auto_loader_txagent": os.path.join(
@@ -142,6 +145,9 @@ default_tool_files = {
         current_dir, "data", "output_summarization_tools.json"
     ),
     "odphp": os.path.join(current_dir, "data", "odphp_tools.json"),
+    "markitdown": os.path.join(current_dir, "data", "markitdown_tools.json"),
+    # Genomics tools
+    "genomics": os.path.join(current_dir, "data", "genomics_tools.json"),
     # Guideline and health policy tools
     "guidelines": os.path.join(current_dir, "data", "unified_guideline_tools.json"),
 }

tooluniverse/ensembl_tool.py

@@ -0,0 +1,61 @@
+import requests
+from .base_tool import BaseTool
+from .tool_registry import register_tool
+
+
+@register_tool("EnsemblTool")
+class EnsemblTool(BaseTool):
+    """
+    Local tool wrapper for Ensembl REST API lookups.
+    Supports symbol→gene lookup (xrefs/symbol) then lookup/id to
+    fetch metadata.
+    """
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+        self.base = "https://rest.ensembl.org"
+        self.session = requests.Session()
+        self.session.headers.update(
+            {"Accept": "application/json", "Content-Type": "application/json"}
+        )
+
+    def run(self, arguments):
+        species = arguments.get("species", "homo_sapiens")
+        symbol = arguments.get("symbol")
+        if not symbol:
+            return {"error": "Missing required parameter: symbol"}
+
+        # 1) symbol -> xref(s) to get Ensembl gene ID
+        xref_url = f"{self.base}/xrefs/symbol/{species}/{symbol}"
+        xref_resp = self.session.get(xref_url, timeout=20)
+        xref_resp.raise_for_status()
+        xrefs = xref_resp.json() or []
+        gene_id = None
+        for item in xrefs:
+            if item.get("type") == "gene" and item.get("id"):
+                gene_id = item["id"]
+                break
+        if not gene_id and xrefs:
+            gene_id = xrefs[0].get("id")
+        if not gene_id:
+            return {"error": f"No Ensembl gene found for {symbol}"}
+
+        # 2) lookup by Ensembl ID (expand=1 to include transcripts)
+        lookup_url = f"{self.base}/lookup/id/{gene_id}?expand=1"
+        look_resp = self.session.get(lookup_url, timeout=30)
+        look_resp.raise_for_status()
+        data = look_resp.json() or {}
+
+        transcripts = data.get("Transcript") or []
+        return {
+            "id": data.get("id"),
+            "symbol": symbol,
+            "display_name": data.get("display_name"),
+            "species": data.get("species"),
+            "seq_region_name": data.get("seq_region_name"),
+            "start": data.get("start"),
+            "end": data.get("end"),
+            "strand": data.get("strand"),
+            "biotype": data.get("biotype"),
+            "transcript_count": len(transcripts),
+        }

tooluniverse/execute_function.py

@@ -33,6 +33,8 @@ import os
 import time
 import hashlib
 import warnings
+from pathlib import Path
+from contextlib import nullcontext
 from typing import Any, Dict, List, Optional
 from .utils import read_json_list, evaluate_function_call, extract_function_call_json
 from .exceptions import (
@@ -58,6 +60,7 @@ from .logging_config import (
     error,
     set_log_level,
 )
+from .cache.result_cache_manager import ResultCacheManager
 from .output_hook import HookManager
 from .default_config import default_tool_files, get_default_hook_config
 
@@ -260,9 +263,39 @@ class ToolUniverse:
             self.hook_manager = None
             self.logger.debug("Output hooks disabled")
 
-        # Initialize new attributes for enhanced functionality
-        self._cache = {}  # Simple cache for tool results
-        self._cache_size = int(os.getenv("TOOLUNIVERSE_CACHE_SIZE", "100"))
+        # Initialize caching configuration
+        cache_enabled = os.getenv("TOOLUNIVERSE_CACHE_ENABLED", "true").lower() in (
+            "true",
+            "1",
+            "yes",
+        )
+        persistence_enabled = os.getenv(
+            "TOOLUNIVERSE_CACHE_PERSIST", "true"
+        ).lower() in ("true", "1", "yes")
+        memory_size = int(os.getenv("TOOLUNIVERSE_CACHE_MEMORY_SIZE", "256"))
+        default_ttl_env = os.getenv("TOOLUNIVERSE_CACHE_DEFAULT_TTL")
+        default_ttl = int(default_ttl_env) if default_ttl_env else None
+        singleflight_enabled = os.getenv(
+            "TOOLUNIVERSE_CACHE_SINGLEFLIGHT", "true"
+        ).lower() in ("true", "1", "yes")
+
+        cache_path = os.getenv("TOOLUNIVERSE_CACHE_PATH")
+        if not cache_path and persistence_enabled:
+            base_dir = os.getenv("TOOLUNIVERSE_CACHE_DIR")
+            if not base_dir:
+                base_dir = os.path.join(str(Path.home()), ".tooluniverse")
+            os.makedirs(base_dir, exist_ok=True)
+            cache_path = os.path.join(base_dir, "cache.sqlite")
+
+        self.cache_manager = ResultCacheManager(
+            memory_size=memory_size,
+            persistent_path=cache_path if persistence_enabled else None,
+            enabled=cache_enabled,
+            persistence_enabled=persistence_enabled,
+            singleflight=singleflight_enabled,
+            default_ttl=default_ttl,
+        )
+
         self._strict_validation = os.getenv(
             "TOOLUNIVERSE_STRICT_VALIDATION", "false"
         ).lower() in ("true", "1", "yes")
@@ -1041,9 +1074,14 @@ class ToolUniverse:
             - When scan_all=True, all JSON files in data/ and subdirectories are scanned
         """
         if mode not in ["config", "type", "list_name", "list_spec"]:
-            raise ValueError(
-                "Mode must be one of: 'config', 'type', 'list_name', 'list_spec'"
-            )
+            # Handle invalid modes gracefully
+            if mode is None:
+                mode = "config"  # Default to config mode
+            else:
+                # For invalid string modes, return error info instead of raising
+                return {
+                    "error": f"Invalid mode '{mode}'. Must be one of: 'config', 'type', 'list_name', 'list_spec'"
+                }
 
         # For list_name and list_spec modes, we can return early with just the data
         if mode in ["list_name", "list_spec"]:
@@ -1693,84 +1731,139 @@ class ToolUniverse:
         Returns:
             str or dict: Result from the tool execution, or error message if validation fails.
         """
-        function_name = function_call_json["name"]
-        arguments = function_call_json["arguments"]
-
-        # Check cache first if enabled
-        if use_cache:
-            cache_key = self._make_cache_key(function_name, arguments)
-            if cache_key in self._cache:
-                self.logger.debug(f"Cache hit for {function_name}")
-                return self._cache[cache_key]
-
-        # Validate parameters if requested
-        if validate:
-            validation_error = self._validate_parameters(function_name, arguments)
-            if validation_error:
-                return self._create_dual_format_error(validation_error)
-
-        # Check function call format (existing validation)
-        check_status, check_message = self.check_function_call(function_call_json)
-        if check_status is False:
-            error_msg = "Invalid function call: " + check_message
-            return self._create_dual_format_error(
-                ToolValidationError(error_msg, details={"check_message": check_message})
-            )
+        function_name = function_call_json.get("name", "")
+        arguments = function_call_json.get("arguments", {})
+
+        # Handle malformed queries gracefully
+        if not function_name:
+            return {"error": "Missing or empty function name"}
+
+        if not isinstance(arguments, dict):
+            return {
+                "error": f"Arguments must be a dictionary, got {type(arguments).__name__}"
+            }
 
-        # Execute the tool
         tool_instance = None
-        tool_arguments = arguments
-        try:
-            # Get or create tool instance (optimized to avoid duplication)
-            tool_instance = self._get_tool_instance(function_name, cache=True)
+        cache_namespace = None
+        cache_version = None
+        cache_key = None
+        composed_cache_key = None
+        cache_guard = nullcontext()
+
+        cache_enabled = (
+            use_cache and self.cache_manager is not None and self.cache_manager.enabled
+        )
 
-            if tool_instance:
-                result, tool_arguments = self._execute_tool_with_stream(
-                    tool_instance, arguments, stream_callback, use_cache, validate
+        if cache_enabled:
+            tool_instance = self._get_tool_instance(function_name, cache=True)
+            if tool_instance and tool_instance.supports_caching():
+                cache_namespace = tool_instance.get_cache_namespace()
+                cache_version = tool_instance.get_cache_version()
+                cache_key = self._make_cache_key(function_name, arguments)
+                composed_cache_key = self.cache_manager.compose_key(
+                    cache_namespace, cache_version, cache_key
+                )
+                cached_value = self.cache_manager.get(
+                    namespace=cache_namespace,
+                    version=cache_version,
+                    cache_key=cache_key,
                 )
+                if cached_value is not None:
+                    self.logger.debug(f"Cache hit for {function_name}")
+                    return cached_value
+                cache_guard = self.cache_manager.singleflight_guard(composed_cache_key)
             else:
-                error_msg = f"Tool '{function_name}' not found"
+                cache_enabled = False
+
+        with cache_guard:
+            if cache_enabled:
+                cached_value = self.cache_manager.get(
+                    namespace=cache_namespace,
+                    version=cache_version,
+                    cache_key=cache_key,
+                )
+                if cached_value is not None:
+                    self.logger.debug(
+                        f"Cache hit for {function_name} (after singleflight wait)"
+                    )
+                    return cached_value
+
+            # Validate parameters if requested
+            if validate:
+                validation_error = self._validate_parameters(function_name, arguments)
+                if validation_error:
+                    return self._create_dual_format_error(validation_error)
+
+            # Check function call format (existing validation)
+            check_status, check_message = self.check_function_call(function_call_json)
+            if check_status is False:
+                error_msg = "Invalid function call: " + check_message
                 return self._create_dual_format_error(
-                    ToolUnavailableError(
-                        error_msg,
-                        next_steps=[
-                            "Check tool name spelling",
-                            "Run tu.tools.refresh()",
-                        ],
+                    ToolValidationError(
+                        error_msg, details={"check_message": check_message}
                     )
                 )
-        except Exception as e:
-            # Classify and return structured error
-            classified_error = self._classify_exception(e, function_name, arguments)
-            return self._create_dual_format_error(classified_error)
-
-        # Apply output hooks if enabled
-        if self.hook_manager:
-            context = {
-                "tool_name": function_name,
-                "tool_type": (
-                    tool_instance.__class__.__name__
-                    if tool_instance is not None
-                    else "unknown"
-                ),
-                "execution_time": time.time(),
-                "arguments": tool_arguments,
-            }
-            result = self.hook_manager.apply_hooks(
-                result, function_name, tool_arguments, context
-            )
 
-        # Cache result if enabled
-        if use_cache:
-            cache_key = self._make_cache_key(function_name, arguments)
-            self._cache[cache_key] = result
-            # Simple cache size management
-            if len(self._cache) > self._cache_size:
-                # Remove oldest entries (simple FIFO)
-                oldest_key = next(iter(self._cache))
-                del self._cache[oldest_key]
+            # Execute the tool
+            tool_arguments = arguments
+            try:
+                if tool_instance is None:
+                    tool_instance = self._get_tool_instance(function_name, cache=True)
 
-        return result
+                if tool_instance:
+                    result, tool_arguments = self._execute_tool_with_stream(
+                        tool_instance, arguments, stream_callback, use_cache, validate
+                    )
+                else:
+                    error_msg = f"Tool '{function_name}' not found"
+                    return self._create_dual_format_error(
+                        ToolUnavailableError(
+                            error_msg,
+                            next_steps=[
+                                "Check tool name spelling",
+                                "Run tu.tools.refresh()",
+                            ],
+                        )
+                    )
+            except Exception as e:
+                # Classify and return structured error
+                classified_error = self._classify_exception(e, function_name, arguments)
+                return self._create_dual_format_error(classified_error)
+
+            # Apply output hooks if enabled
+            if self.hook_manager:
+                context = {
+                    "tool_name": function_name,
+                    "tool_type": (
+                        tool_instance.__class__.__name__
+                        if tool_instance is not None
+                        else "unknown"
+                    ),
+                    "execution_time": time.time(),
+                    "arguments": tool_arguments,
+                }
+                result = self.hook_manager.apply_hooks(
+                    result, function_name, tool_arguments, context
+                )
+
+            # Cache result if enabled
+            if cache_enabled and tool_instance and tool_instance.supports_caching():
+                if cache_key is None:
+                    cache_key = self._make_cache_key(function_name, arguments)
+                if cache_namespace is None:
+                    cache_namespace = tool_instance.get_cache_namespace()
+                if cache_version is None:
+                    cache_version = tool_instance.get_cache_version()
+                ttl = tool_instance.get_cache_ttl(result)
+                self.cache_manager.set(
+                    namespace=cache_namespace,
+                    version=cache_version,
+                    cache_key=cache_key,
+                    value=result,
+                    ttl=ttl,
+                )
+
+            return result
 
     def _execute_tool_with_stream(
         self, tool_instance, arguments, stream_callback, use_cache=False, validate=True
@@ -2039,9 +2132,33 @@ class ToolUniverse:
 
     def clear_cache(self):
         """Clear the result cache."""
-        self._cache.clear()
+        if self.cache_manager:
+            self.cache_manager.clear()
         self.logger.info("Result cache cleared")
 
+    def get_cache_stats(self) -> Dict[str, Any]:
+        """Return cache statistics."""
+        if not self.cache_manager:
+            return {"enabled": False}
+        return self.cache_manager.stats()
+
+    def dump_cache(self, namespace: Optional[str] = None):
+        """Iterate over cached entries (persistent layer only)."""
+        if not self.cache_manager:
+            return iter([])
+        return self.cache_manager.dump(namespace=namespace)
+
+    def close(self):
+        """Release resources."""
+        if self.cache_manager:
+            self.cache_manager.close()
+
+    def __del__(self):
+        try:
+            self.close()
+        except Exception:
+            pass
+
     def get_tool_health(self, tool_name: str = None) -> dict:
         """Get health status for tool(s)."""
         tool_errors = get_tool_errors()
@@ -2248,6 +2365,10 @@ class ToolUniverse:
             self.logger.warning("No tools loaded. Call load_tools() first.")
             return []
 
+        # Handle None or empty pattern
+        if pattern is None or pattern == "":
+            return self.all_tools
+
         import re
 
         flags = 0 if case_sensitive else re.IGNORECASE