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

tooluniverse/smcp_server.py

@@ -299,8 +299,8 @@ Examples:
             tu = ToolUniverse()
             tool_types = tu.get_tool_types()
 
-            print("Available tool categories:")
-            print("=" * 50)
+            print("Available tool categories:", file=sys.stderr)
+            print("=" * 50, file=sys.stderr)
 
             # Group categories for better readability
             scientific_db = []
@@ -350,46 +350,57 @@ Examples:
                     other.append(category)
 
             if scientific_db:
-                print("\n🔬 Scientific Databases:")
+                print("\n🔬 Scientific Databases:", file=sys.stderr)
                 for cat in scientific_db:
-                    print(f"  {cat}")
+                    print(f"  {cat}", file=sys.stderr)
 
             if literature:
-                print("\n📚 Literature & Knowledge:")
+                print("\n📚 Literature & Knowledge:", file=sys.stderr)
                 for cat in literature:
-                    print(f"  {cat}")
+                    print(f"  {cat}", file=sys.stderr)
 
             if clinical:
-                print("\n🏥 Clinical & Drug Information:")
+                print("\n🏥 Clinical & Drug Information:", file=sys.stderr)
                 for cat in clinical:
-                    print(f"  {cat}")
+                    print(f"  {cat}", file=sys.stderr)
 
             if software:
-                print("\n💻 Software Tools:")
+                print("\n💻 Software Tools:", file=sys.stderr)
                 for cat in software[:5]:  # Show first 5
-                    print(f"  {cat}")
+                    print(f"  {cat}", file=sys.stderr)
                 if len(software) > 5:
-                    print(f"  ... and {len(software) - 5} more software categories")
+                    print(
+                        f"  ... and {len(software, file=sys.stderr) - 5} more software categories"
+                    )
 
             if special:
-                print("\n🛠 Special & Meta Tools:")
+                print("\n🛠 Special & Meta Tools:", file=sys.stderr)
                 for cat in special:
-                    print(f"  {cat}")
+                    print(f"  {cat}", file=sys.stderr)
 
             if other:
-                print("\n📂 Other Categories:")
+                print("\n📂 Other Categories:", file=sys.stderr)
                 for cat in other:
-                    print(f"  {cat}")
-
-            print(f"\nTotal: {len(tool_types)} categories available")
-            print("\nCommon combinations:")
-            print("  Scientific research: uniprot ChEMBL opentarget pubchem hpa")
-            print("  Drug discovery: ChEMBL fda_drug_label clinical_trials pubchem")
-            print("  Literature analysis: EuropePMC semantic_scholar pubtator")
-            print("  Minimal setup: special_tools tool_finder")
+                    print(f"  {cat}", file=sys.stderr)
+
+            print(f"\nTotal: {len(tool_types, file=sys.stderr)} categories available")
+            print("\nCommon combinations:", file=sys.stderr)
+            print(
+                "  Scientific research: uniprot ChEMBL opentarget pubchem hpa",
+                file=sys.stderr,
+            )
+            print(
+                "  Drug discovery: ChEMBL fda_drug_label clinical_trials pubchem",
+                file=sys.stderr,
+            )
+            print(
+                "  Literature analysis: EuropePMC semantic_scholar pubtator",
+                file=sys.stderr,
+            )
+            print("  Minimal setup: special_tools tool_finder", file=sys.stderr)
 
         except Exception as e:
-            print(f"❌ Error listing categories: {e}")
+            print(f"❌ Error listing categories: {e}", file=sys.stderr)
             sys.exit(1)
         return
 
@@ -401,8 +412,8 @@ Examples:
             tu = ToolUniverse()
             tu.load_tools()  # Load all tools to list them
 
-            print("Available tools:")
-            print("=" * 50)
+            print("Available tools:", file=sys.stderr)
+            print("=" * 50, file=sys.stderr)
 
             # Group tools by category
             tools_by_category = {}
@@ -415,36 +426,44 @@ Examples:
             total_tools = 0
             for category in sorted(tools_by_category.keys()):
                 tools = sorted(tools_by_category[category])
-                print(f"\n📁 {category} ({len(tools)} tools):")
+                print(f"\n📁 {category} ({len(tools, file=sys.stderr)} tools):")
                 for tool in tools[:10]:  # Show first 10 tools per category
-                    print(f"  {tool}")
+                    print(f"  {tool}", file=sys.stderr)
                 if len(tools) > 10:
-                    print(f"  ... and {len(tools) - 10} more tools")
+                    print(f"  ... and {len(tools, file=sys.stderr) - 10} more tools")
                 total_tools += len(tools)
 
-            print(f"\nTotal: {total_tools} tools available")
-            print("\nNote: Use --exclude-tools to exclude specific tools by name")
-            print("      Use --exclude-categories to exclude entire categories")
+            print(f"\nTotal: {total_tools} tools available", file=sys.stderr)
+            print(
+                "\nNote: Use --exclude-tools to exclude specific tools by name",
+                file=sys.stderr,
+            )
+            print(
+                "      Use --exclude-categories to exclude entire categories",
+                file=sys.stderr,
+            )
 
         except Exception as e:
-            print(f"❌ Error listing tools: {e}")
+            print(f"❌ Error listing tools: {e}", file=sys.stderr)
             sys.exit(1)
         return
 
     try:
-        print(f"🚀 Starting {args.name}...")
-        print("📡 Transport: stdio (for Claude Desktop)")
-        print(f"🔍 Search enabled: {not args.no_search}")
+        print(f"🚀 Starting {args.name}...", file=sys.stderr)
+        print("📡 Transport: stdio (for Claude Desktop)", file=sys.stderr)
+        print(f"🔍 Search enabled: {not args.no_search}", file=sys.stderr)
 
         if args.categories is not None:
             if len(args.categories) == 0:
-                print("📂 No categories specified, loading all tools")
+                print("📂 No categories specified, loading all tools", file=sys.stderr)
                 tool_categories = None
             else:
-                print(f"📂 Tool categories: {', '.join(args.categories)}")
+                print(
+                    f"📂 Tool categories: {', '.join(args.categories)}", file=sys.stderr
+                )
                 tool_categories = args.categories
         else:
-            print("📂 Loading all tool categories")
+            print("📂 Loading all tool categories", file=sys.stderr)
             tool_categories = None
 
         # Handle exclusions and inclusions
@@ -463,24 +482,45 @@ Examples:
                     category, path = config_spec.split(":", 1)
                     tool_config_files[category] = path
                 else:
-                    print(f"❌ Invalid tool config file format: {config_spec}")
-                    print("   Expected format: 'category:/path/to/config.json'")
+                    print(
+                        f"❌ Invalid tool config file format: {config_spec}",
+                        file=sys.stderr,
+                    )
+                    print(
+                        "   Expected format: 'category:/path/to/config.json'",
+                        file=sys.stderr,
+                    )
                     sys.exit(1)
 
         if exclude_tools:
-            print(f"🚫 Excluding tools: {', '.join(exclude_tools)}")
+            print(f"🚫 Excluding tools: {', '.join(exclude_tools)}", file=sys.stderr)
         if exclude_categories:
-            print(f"🚫 Excluding categories: {', '.join(exclude_categories)}")
+            print(
+                f"🚫 Excluding categories: {', '.join(exclude_categories)}",
+                file=sys.stderr,
+            )
         if include_tools:
-            print(f"✅ Including only specific tools: {len(include_tools)} tools")
+            print(
+                f"✅ Including only specific tools: {len(include_tools)} tools",
+                file=sys.stderr,
+            )
         if tools_file:
-            print(f"📄 Loading tools from file: {tools_file}")
+            print(f"📄 Loading tools from file: {tools_file}", file=sys.stderr)
         if tool_config_files:
-            print(f"📦 Additional config files: {', '.join(tool_config_files.keys())}")
+            print(
+                f"📦 Additional config files: {', '.join(tool_config_files.keys())}",
+                file=sys.stderr,
+            )
         if include_tool_types:
-            print(f"🎯 Including tool types: {', '.join(include_tool_types)}")
+            print(
+                f"🎯 Including tool types: {', '.join(include_tool_types)}",
+                file=sys.stderr,
+            )
         if exclude_tool_types:
-            print(f"🚫 Excluding tool types: {', '.join(exclude_tool_types)}")
+            print(
+                f"🚫 Excluding tool types: {', '.join(exclude_tool_types)}",
+                file=sys.stderr,
+            )
 
         # Load hook configuration if specified
         hook_config = None
@@ -489,7 +529,9 @@ Examples:
 
             with open(args.hook_config_file, "r") as f:
                 hook_config = json.load(f)
-            print(f"🔗 Hook config loaded from: {args.hook_config_file}")
+            print(
+                f"🔗 Hook config loaded from: {args.hook_config_file}", file=sys.stderr
+            )
 
         # Determine hook settings (default disabled for stdio)
         hooks_enabled = (
@@ -502,16 +544,16 @@ Examples:
             hook_type = "SummarizationHook"
         if hooks_enabled:
             if hook_type:
-                print(f"🔗 Hooks enabled: {hook_type}")
+                print(f"🔗 Hooks enabled: {hook_type}", file=sys.stderr)
             elif hook_config:
                 hook_count = len(hook_config.get("hooks", []))
-                print(f"🔗 Hooks enabled: {hook_count} custom hooks")
+                print(f"🔗 Hooks enabled: {hook_count} custom hooks", file=sys.stderr)
             else:
-                print("🔗 Hooks enabled: default configuration")
+                print("🔗 Hooks enabled: default configuration", file=sys.stderr)
         else:
-            print("🔗 Hooks disabled")
+            print("🔗 Hooks disabled", file=sys.stderr)
 
-        print(f"⚡ Max workers: {args.max_workers}")
+        print(f"⚡ Max workers: {args.max_workers}", file=sys.stderr)
         print()
 
         # Create SMCP server with hook support
@@ -536,10 +578,10 @@ Examples:
         server.run_simple(transport="stdio")
 
     except KeyboardInterrupt:
-        print("\n🛑 Server stopped by user")
+        print("\n🛑 Server stopped by user", file=sys.stderr)
         sys.exit(0)
     except Exception as e:
-        print(f"❌ Error starting server: {e}")
+        print(f"❌ Error starting server: {e}", file=sys.stderr)
         if args.verbose:
             import traceback
 

tooluniverse/string_tool.py

@@ -0,0 +1,112 @@
+"""
+STRING Database REST API Tool
+
+This tool provides access to protein-protein interaction data from the STRING
+database. STRING is a database of known and predicted protein-protein
+interactions.
+"""
+
+import requests
+from typing import Dict, Any, List
+from .base_tool import BaseTool
+from .tool_registry import register_tool
+
+STRING_BASE_URL = "https://string-db.org/api"
+
+
+@register_tool("STRINGRESTTool")
+class STRINGRESTTool(BaseTool):
+    """
+    STRING Database REST API tool.
+    Generic wrapper for STRING 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", "/tsv/network")
+        self.required: List[str] = parameter.get("required", [])
+        self.output_format: str = fields.get("return_format", "TSV")
+
+    def _build_url(self, arguments: Dict[str, Any]) -> str | Dict[str, Any]:
+        """Build URL for STRING API request."""
+        url_path = self.endpoint_template
+        return STRING_BASE_URL + url_path
+
+    def _build_params(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Build parameters for STRING API request."""
+        params = {}
+
+        # Map protein IDs to STRING format
+        if "protein_ids" in arguments:
+            protein_ids = arguments["protein_ids"]
+            if isinstance(protein_ids, list):
+                params["identifiers"] = "\r".join(protein_ids)
+            else:
+                params["identifiers"] = str(protein_ids)
+
+        # Add other parameters
+        if "species" in arguments:
+            params["species"] = arguments["species"]
+        if "confidence_score" in arguments:
+            params["required_score"] = int(arguments["confidence_score"] * 1000)
+        if "limit" in arguments:
+            params["limit"] = arguments["limit"]
+        if "network_type" in arguments:
+            params["network_type"] = arguments["network_type"]
+
+        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 == "TSV":
+                return self._parse_tsv_response(response.text)
+            else:
+                return response.json()
+
+        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 _parse_tsv_response(self, text: str) -> Dict[str, Any]:
+        """Parse TSV response from STRING API."""
+        lines = text.strip().split("\n")
+        if len(lines) < 2:
+            return {"data": [], "error": "No data returned"}
+
+        # Parse header
+        header = lines[0].split("\t")
+
+        # Parse data rows
+        data = []
+        for line in lines[1:]:
+            if line.strip():
+                values = line.split("\t")
+                row = {}
+                for i, value in enumerate(values):
+                    if i < len(header):
+                        row[header[i]] = value
+                data.append(row)
+
+        return {"data": data, "header": header}
+
+    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/tool_registry.py

@@ -6,7 +6,8 @@ import os
 import json
 import glob
 import logging
-from typing import Dict
+import re
+from typing import Dict, Optional
 
 # Initialize logger for this module
 logger = logging.getLogger("ToolRegistry")
@@ -18,6 +19,32 @@ _lazy_registry: Dict[str, str] = {}  # Maps tool names to module names
 _discovery_completed = False
 _lazy_cache = {}
 
+# Global error tracking
+_TOOL_ERRORS = {}
+
+
+def _extract_missing_package(error_msg: str) -> Optional[str]:
+    """Extract package name from ImportError."""
+    match = re.search(r"No module named ['\"]([^'\"]+)['\"]", error_msg)
+    if match:
+        return match.group(1).split(".")[0]
+    return None
+
+
+def mark_tool_unavailable(tool_name: str, error: Exception, module: str = None):
+    """Record tool failure."""
+    _TOOL_ERRORS[tool_name] = {
+        "error": str(error),
+        "error_type": type(error).__name__,
+        "module": module,
+        "missing_package": _extract_missing_package(str(error)),
+    }
+
+
+def get_tool_errors() -> dict:
+    """Get all tool errors."""
+    return _TOOL_ERRORS.copy()
+
 
 def register_tool(tool_type_name=None, config=None):
     """
@@ -71,7 +98,7 @@ def lazy_import_tool(tool_name):
     Lazily import a tool by name without importing all tool modules.
     Only imports the specific module containing the requested tool.
     """
-    global _tool_registry, _lazy_registry, _lazy_cache
+    global _tool_registry, _lazy_registry, _lazy_cache  # noqa: F824
 
     # If tool is already in registry, return it
     if tool_name in _tool_registry:
@@ -108,8 +135,13 @@ def lazy_import_tool(tool_name):
 
             except ImportError as e:
                 logger.warning(f"Failed to lazy import {full_module_name}: {e}")
+                mark_tool_unavailable(tool_name, e, full_module_name)
                 # Remove this bad mapping so we don't try again
                 del _lazy_registry[tool_name]
+            except Exception as e:
+                logger.warning(f"Failed to load {full_module_name}: {e}")
+                mark_tool_unavailable(tool_name, e, full_module_name)
+                del _lazy_registry[tool_name]
         else:
             # Module was already imported, check if tool is now available
             if tool_name in _tool_registry:
@@ -130,7 +162,7 @@ def build_lazy_registry(package_name=None):
     Build a mapping of tool names to module names using config files and naming patterns.
     This is truly lazy - it doesn't import any modules, just creates the mapping.
     """
-    global _lazy_registry
+    global _lazy_registry  # noqa: F824
 
     if package_name is None:
         package_name = "tooluniverse"

tooluniverse/tools/ADMETAI_predict_BBB_penetrance.py

@@ -0,0 +1,46 @@
+"""
+ADMETAI_predict_BBB_penetrance
+
+Predicts blood-brain barrier (BBB) penetrance for a given list of molecules in SMILES format.
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def ADMETAI_predict_BBB_penetrance(
+    smiles: list[Any],
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Predicts blood-brain barrier (BBB) penetrance for a given list of molecules in SMILES format.
+
+    Parameters
+    ----------
+    smiles : list[Any]
+        The list of SMILES strings.
+    stream_callback : Callable, optional
+        Callback for streaming output
+    use_cache : bool, default False
+        Enable caching
+    validate : bool, default True
+        Validate parameters
+
+    Returns
+    -------
+    Any
+    """
+    # Handle mutable defaults to avoid B006 linting error
+
+    return get_shared_client().run_one_function(
+        {"name": "ADMETAI_predict_BBB_penetrance", "arguments": {"smiles": smiles}},
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["ADMETAI_predict_BBB_penetrance"]

tooluniverse/tools/ADMETAI_predict_CYP_interactions.py

@@ -0,0 +1,46 @@
+"""
+ADMETAI_predict_CYP_interactions
+
+Predicts CYP enzyme interactions for a given list of molecules in SMILES format.
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def ADMETAI_predict_CYP_interactions(
+    smiles: list[Any],
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Predicts CYP enzyme interactions for a given list of molecules in SMILES format.
+
+    Parameters
+    ----------
+    smiles : list[Any]
+        The list of SMILES strings.
+    stream_callback : Callable, optional
+        Callback for streaming output
+    use_cache : bool, default False
+        Enable caching
+    validate : bool, default True
+        Validate parameters
+
+    Returns
+    -------
+    Any
+    """
+    # Handle mutable defaults to avoid B006 linting error
+
+    return get_shared_client().run_one_function(
+        {"name": "ADMETAI_predict_CYP_interactions", "arguments": {"smiles": smiles}},
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["ADMETAI_predict_CYP_interactions"]

tooluniverse/tools/ADMETAI_predict_bioavailability.py

@@ -0,0 +1,46 @@
+"""
+ADMETAI_predict_bioavailability
+
+Predicts bioavailability endpoints (Bioavailability_Ma, HIA_Hou, PAMPA_NCATS, Caco2_Wang, Pgp_Bro...
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def ADMETAI_predict_bioavailability(
+    smiles: list[Any],
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Predicts bioavailability endpoints (Bioavailability_Ma, HIA_Hou, PAMPA_NCATS, Caco2_Wang, Pgp_Bro...
+
+    Parameters
+    ----------
+    smiles : list[Any]
+        The list of SMILES strings.
+    stream_callback : Callable, optional
+        Callback for streaming output
+    use_cache : bool, default False
+        Enable caching
+    validate : bool, default True
+        Validate parameters
+
+    Returns
+    -------
+    Any
+    """
+    # Handle mutable defaults to avoid B006 linting error
+
+    return get_shared_client().run_one_function(
+        {"name": "ADMETAI_predict_bioavailability", "arguments": {"smiles": smiles}},
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["ADMETAI_predict_bioavailability"]

tooluniverse/tools/ADMETAI_predict_clearance_distribution.py

@@ -0,0 +1,49 @@
+"""
+ADMETAI_predict_clearance_distribution
+
+Predicts clearance and distribution endpoints (Clearance_Hepatocyte_AZ, Clearance_Microsome_AZ, H...
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def ADMETAI_predict_clearance_distribution(
+    smiles: list[Any],
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Predicts clearance and distribution endpoints (Clearance_Hepatocyte_AZ, Clearance_Microsome_AZ, H...
+
+    Parameters
+    ----------
+    smiles : list[Any]
+        The list of SMILES strings.
+    stream_callback : Callable, optional
+        Callback for streaming output
+    use_cache : bool, default False
+        Enable caching
+    validate : bool, default True
+        Validate parameters
+
+    Returns
+    -------
+    Any
+    """
+    # Handle mutable defaults to avoid B006 linting error
+
+    return get_shared_client().run_one_function(
+        {
+            "name": "ADMETAI_predict_clearance_distribution",
+            "arguments": {"smiles": smiles},
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["ADMETAI_predict_clearance_distribution"]

tooluniverse/tools/ADMETAI_predict_nuclear_receptor_activity.py

@@ -0,0 +1,49 @@
+"""
+ADMETAI_predict_nuclear_receptor_activity
+
+Predicts nuclear receptor activity endpoints (NR-AR-LBD, NR-AR, NR-AhR, NR-Aromatase, NR-ER-LBD, ...
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def ADMETAI_predict_nuclear_receptor_activity(
+    smiles: list[Any],
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Predicts nuclear receptor activity endpoints (NR-AR-LBD, NR-AR, NR-AhR, NR-Aromatase, NR-ER-LBD, ...
+
+    Parameters
+    ----------
+    smiles : list[Any]
+        The list of SMILES strings.
+    stream_callback : Callable, optional
+        Callback for streaming output
+    use_cache : bool, default False
+        Enable caching
+    validate : bool, default True
+        Validate parameters
+
+    Returns
+    -------
+    Any
+    """
+    # Handle mutable defaults to avoid B006 linting error
+
+    return get_shared_client().run_one_function(
+        {
+            "name": "ADMETAI_predict_nuclear_receptor_activity",
+            "arguments": {"smiles": smiles},
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["ADMETAI_predict_nuclear_receptor_activity"]