tooluniverse 1.0.9.1__py3-none-any.whl → 1.0.11__py3-none-any.whl

tooluniverse/regulomedb_tool.py

@@ -0,0 +1,30 @@
+import requests
+from typing import Any, Dict
+from .base_tool import BaseTool
+from .tool_registry import register_tool
+
+
+@register_tool("RegulomeDBRESTTool")
+class RegulomeDBRESTTool(BaseTool):
+    def __init__(self, tool_config: Dict):
+        super().__init__(tool_config)
+        self.base_url = "https://regulomedb.org"
+        self.session = requests.Session()
+        self.session.headers.update({"Accept": "application/json"})
+        self.timeout = 30
+
+    def _build_url(self, args: Dict[str, Any]) -> str:
+        url = self.tool_config["fields"]["endpoint"]
+        for k, v in args.items():
+            url = url.replace(f"{{{k}}}", str(v))
+        return url
+
+    def run(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        try:
+            url = self._build_url(arguments)
+            response = self.session.get(url, timeout=self.timeout)
+            response.raise_for_status()
+            data = response.json()
+            return {"status": "success", "data": data, "url": url}
+        except Exception as e:
+            return {"status": "error", "error": f"RegulomeDB API error: {str(e)}"}

tooluniverse/remap_tool.py

@@ -0,0 +1,44 @@
+import requests
+from typing import Any, Dict
+from .base_tool import BaseTool
+from .tool_registry import register_tool
+
+
+@register_tool("ReMapRESTTool")
+class ReMapRESTTool(BaseTool):
+    def __init__(self, tool_config: Dict):
+        super().__init__(tool_config)
+        self.session = requests.Session()
+        self.session.headers.update({"Accept": "application/json"})
+        self.timeout = 30
+
+    def run(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        try:
+            # Use ENCODE as alternative data source for ChIP-seq data
+            chromosome = arguments.get("chromosome", "chr1")
+            start = arguments.get("start", 1000000)
+            end = arguments.get("end", 2000000)
+
+            # Build ENCODE API URL for experiments
+            # Query for general experiments as ReMap alternative
+            url = "https://www.encodeproject.org/search/?type=Experiment&format=json&limit=10"
+
+            response = self.session.get(url, timeout=self.timeout)
+            response.raise_for_status()
+
+            # Parse JSON response
+            data = response.json()
+
+            return {
+                "status": "success",
+                "data": data,
+                "url": url,
+                "query_info": {
+                    "chromosome": chromosome,
+                    "start": start,
+                    "end": end,
+                    "data_source": "ENCODE (ReMap alternative)",
+                },
+            }
+        except Exception as e:
+            return {"status": "error", "error": f"ReMap API error: {str(e)}"}

tooluniverse/remote/boltz/boltz_mcp_server.py

@@ -35,7 +35,7 @@ def run_boltz2(query: dict):
             - without_potentials (bool): Whether to run without potentials (default: False)
             - diffusion_samples (int): Number of diffusion samples to generate (default: 1)
             - Additional constraint keys may be included as needed
-    Returns:
+    Returns
         dict: A dictionary containing the docking results with the following structure:
             - predicted_structure (str): The predicted protein-ligand complex structure in CIF format
             - structure_format (str): Format of the structure file (typically 'cif')

tooluniverse/remote/depmap_24q2/depmap_24q2_mcp_tool.py

@@ -96,7 +96,7 @@ class DepmapCorrelationTool:
             else:
                 # Fallback to text file format
                 gene_names_path = os.path.join(self.data_dir, "gene_names.txt")
-                with open(gene_names_path, "r") as f:
+                with open(gene_names_path, "r", encoding="utf-8") as f:
                     self.gene_names = np.array([line.strip() for line in f])
 
             # Create bidirectional mapping for efficient gene symbol lookups
@@ -163,7 +163,7 @@ class DepmapCorrelationTool:
             gene_a (str): First gene symbol (e.g., 'BRAF', 'TP53'). Must be present in dataset.
             gene_b (str): Second gene symbol (e.g., 'MAPK1', 'MDM2'). Must be present in dataset.
 
-        Returns:
+        Returns
             Dict[str, float]: Dictionary containing correlation analysis results:
                 - 'correlation': Pearson correlation coefficient (-1.0 to 1.0)
                 - 'p_value': Statistical significance of correlation
@@ -272,7 +272,7 @@ async def compute_depmap24q2_gene_correlations(
         gene_b (str): Second gene symbol for correlation analysis (e.g., 'MAPK1', 'MDM2').
                      Must use standard HUGO gene nomenclature.
 
-    Returns:
+    Returns
         dict: Comprehensive correlation analysis results containing:
             - 'correlation_data' (dict): Statistical measures including:
                 * 'correlation': Pearson correlation coefficient (-1.0 to 1.0)

tooluniverse/remote/immune_compass/compass_tool.py

@@ -118,7 +118,7 @@ class CompassTool:
             exclude (List[str]): List of column names to exclude from results.
                                Defaults to ['CANCER', 'Reference'].
 
-        Returns:
+        Returns
             List[List[Tuple[str, float]]]: For each sample, a list of tuples containing
                                          (concept_name, concept_score) sorted by score descending.
         """
@@ -161,7 +161,7 @@ class CompassTool:
             batch_size (int): Batch size for model inference. Larger values may improve speed
                             but require more memory. Defaults to 128.
 
-        Returns:
+        Returns
             Tuple[bool, List[Tuple[str, float]]]: A tuple containing:
                 - bool: True if predicted as responder (probability ≥ threshold), False otherwise
                 - List[Tuple[str, float]]: Top immune cell concepts ranked by importance,
@@ -222,7 +222,7 @@ async def run_compass_prediction(
                          Default 0.5 provides balanced sensitivity/specificity.
                          Consider lower thresholds (~0.3) for higher sensitivity.
 
-    Returns:
+    Returns
         dict: Structured prediction results containing:
             - 'prediction' (dict): Core prediction results with:
                 * 'is_responder' (bool): True if predicted responder (probability ≥ threshold)

tooluniverse/remote/pinnacle/pinnacle_tool.py

@@ -101,7 +101,7 @@ class PinnaclePPITool:
                            The method handles various naming conventions including spaces,
                            hyphens, underscores, and capitalization differences.
 
-        Returns:
+        Returns
             Tuple[Dict[str, torch.Tensor], str]: A tuple containing:
                 - Dict mapping protein/gene names to their embedding tensors (empty if no match)
                 - Status message indicating match quality and selected cell type
@@ -198,7 +198,7 @@ async def run_pinnacle_ppi_retrieval(cell_type: str, embed_path: Optional[str] =
                         - Tissue types: 'liver', 'heart', 'brain', 'immune'
                         The tool performs intelligent matching to find the best available match.
 
-    Returns:
+    Returns
         dict: Comprehensive embedding retrieval results containing:
             - 'embeddings' (dict, optional): Protein-to-embedding mapping where:
                 * Keys: Gene/protein symbols (e.g., 'TP53', 'EGFR', 'BRCA1')

tooluniverse/remote/transcriptformer/transcriptformer_tool.py

@@ -105,7 +105,7 @@ class TranscriptformerEmbeddingTool:
         Args:
             disease (str): Disease identifier (normalized to lowercase with underscores).
 
-        Returns:
+        Returns
             Dict: Cached metadata dictionary containing:
                 - store_path: Path to disease-specific embedding store
                 - ensembl_ids_ordered: Ordered list of Ensembl gene IDs
@@ -213,7 +213,7 @@ class TranscriptformerEmbeddingTool:
             disease (str): Disease context identifier (e.g., 'breast_cancer', 'diabetes').
                          Must match available disease stores.
 
-        Returns:
+        Returns
             Tuple[Optional[Dict[str, np.ndarray]], List[str]]: A tuple containing:
                 - Dictionary mapping gene names to embedding vectors (None if failed)
                 - List of context information and error messages
@@ -416,7 +416,7 @@ async def run_transcriptformer_embedding_retrieval(
                     - 'alzheimer': Alzheimer's disease contexts
                     Must match available disease stores.
 
-    Returns:
+    Returns
         dict: Comprehensive embedding retrieval results containing:
             - 'embeddings' (dict, optional): Gene-to-embedding mapping where:
                 * Keys: Gene identifiers (symbols or Ensembl IDs as provided)

tooluniverse/remote/uspto_downloader/uspto_downloader_mcp_server.py

@@ -29,7 +29,7 @@ def download_abst(query: dict):
     """Retrieve the abstract of a patent application by its application number.
     Args:
         "query" dict: A dictionary containing the application number under the key "applicationNumberText".
-    Returns:
+    Returns
         dict: A dictionary containing the abstract text under the 'result' key or an error message under the 'error' key if the document could not be retrieved.
     """
     return agents["get_abstract_from_patent_app_number"].run(query)
@@ -40,7 +40,7 @@ def download_claims(query: dict):
     """Retrieve the claims of a patent application by its application number.
     Args:
         "query" dict: A dictionary containing the application number under the key "applicationNumberText".
-    Returns:
+    Returns
         dict: A dictionary containing the claims text under the 'result' key or an error message under the 'error' key if the document could not be retrieved.
     """
     return agents["get_claims_from_patent_app_number"].run(query)
@@ -51,7 +51,7 @@ def download_full_text(query: dict):
     """Retrieve the full text of a patent application by its application number.
     Args:
         "query" dict: A dictionary containing the application number under the key "applicationNumberText".
-    Returns:
+    Returns
         dict: A dictionary containing the full text under the 'result' key or an error message under the 'error' key if the document could not be retrieved.
     """
     return agents["get_full_text_from_patent_app_number"].run(query)

tooluniverse/remote_tool.py

@@ -45,7 +45,7 @@ class RemoteTool(BaseTool):
         Args:
             arguments (dict, optional): Tool arguments (ignored)
 
-        Returns:
+        Returns
             dict: Error message indicating the tool is not available locally
         """
         server_type = self.remote_info.get("server_type", "Unknown")
@@ -69,7 +69,7 @@ class RemoteTool(BaseTool):
         """
         Get information about the remote server hosting this tool.
 
-        Returns:
+        Returns
             dict: Remote server information including server type, URL, and original tool type
         """
         return self.remote_info.copy()
@@ -78,7 +78,7 @@ class RemoteTool(BaseTool):
         """
         Check if this tool is available for local execution.
 
-        Returns:
+        Returns
             bool: Always False for RemoteTool instances
         """
         return False
@@ -87,7 +87,7 @@ class RemoteTool(BaseTool):
         """
         Get server connection information for this remote tool.
 
-        Returns:
+        Returns
             dict: Server connection details
         """
         return {

tooluniverse/screen_tool.py

@@ -0,0 +1,44 @@
+import requests
+from typing import Any, Dict
+from .base_tool import BaseTool
+from .tool_registry import register_tool
+
+
+@register_tool("SCREENRESTTool")
+class SCREENRESTTool(BaseTool):
+    def __init__(self, tool_config: Dict):
+        super().__init__(tool_config)
+        self.session = requests.Session()
+        self.session.headers.update({"Accept": "application/json"})
+        self.timeout = 30
+
+    def run(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        try:
+            # Use ENCODE as alternative data source for regulatory elements
+            chromosome = arguments.get("chromosome", "chr1")
+            start = arguments.get("start", 1000000)
+            end = arguments.get("end", 2000000)
+
+            # Build ENCODE API URL for experiments
+            # Query for general experiments as SCREEN alternative
+            url = "https://www.encodeproject.org/search/?type=Experiment&format=json&limit=10"
+
+            response = self.session.get(url, timeout=self.timeout)
+            response.raise_for_status()
+
+            # Parse JSON response
+            data = response.json()
+
+            return {
+                "status": "success",
+                "data": data,
+                "url": url,
+                "query_info": {
+                    "chromosome": chromosome,
+                    "start": start,
+                    "end": end,
+                    "data_source": "ENCODE (SCREEN alternative)",
+                },
+            }
+        except Exception as e:
+            return {"status": "error", "error": f"SCREEN API error: {str(e)}"}

tooluniverse/scripts/filter_tool_files.py

@@ -46,7 +46,7 @@ def filter_tool_relationship_graph(data, valid_tool_names):
         data: The loaded JSON data
         valid_tool_names: Set of valid tool names
 
-    Returns:
+    Returns
         Filtered data
     """
     if not isinstance(data, dict):
@@ -111,7 +111,7 @@ def filter_v4_all_tools(data, valid_tool_names):
         data: The loaded JSON data
         valid_tool_names: Set of valid tool names
 
-    Returns:
+    Returns
         Filtered data
     """
     if not isinstance(data, list):

tooluniverse/smcp.py

@@ -10,8 +10,8 @@ The SMCP module provides a complete solution for exposing scientific computation
 resources through the standardized MCP protocol, making it easy for AI agents to
 discover, understand, and execute scientific tools in a unified manner.
 
-Usage Patterns:
-===============
+Usage Patterns
+--------------
 
 Quick Start:
 
@@ -47,8 +47,8 @@ result = await client.call_tool("UniProt_get_entry_by_accession", {
 })
 ```
 
-Architecture:
-=============
+Architecture
+------------
 
 ┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
 │   MCP Client    │◄──►│      SMCP        │◄──►│  ToolUniverse   │
@@ -69,8 +69,8 @@ The SMCP server acts as an intelligent middleware layer that:
 4. Returns formatted results via MCP protocol
 5. Provides intelligent tool discovery and recommendation
 
-Integration Points:
-==================
+Integration Points
+------------------
 
 MCP Protocol Layer:
     - Standard MCP methods (tools/list, tools/call, etc.)
@@ -219,6 +219,21 @@ class SMCP(FastMCP):
         during tool loading. Useful for excluding entire categories of tools
         (e.g., all ToolFinder types or all OpenTarget tools).
 
+    space : str or list of str, optional
+        Space configuration URI(s) to load. Can be a single URI string or a list
+        of URIs for loading multiple Space configurations. Supported formats:
+        - Local file: "./config.yaml" or "/path/to/config.yaml"
+        - HuggingFace: "hf:username/repo" or "hf:username/repo/file.yaml"
+        - HTTP URL: "https://example.com/config.yaml"
+
+        When provided, Space configurations are loaded after tool initialization,
+        applying LLM settings, hooks, and tool selections from the configuration files.
+        Multiple spaces can be loaded sequentially, with later configurations
+        potentially overriding earlier ones.
+
+        Example: space="./my-workspace.yaml"
+        Example: space=["hf:community/bio-tools", "./custom-tools.yaml"]
+
     auto_expose_tools : bool, default True
         Whether to automatically expose ToolUniverse tools as MCP tools.
         When True, all loaded tools become available via the MCP interface
@@ -281,6 +296,7 @@ class SMCP(FastMCP):
         tool_config_files: Optional[Dict[str, str]] = None,
         include_tool_types: Optional[List[str]] = None,
         exclude_tool_types: Optional[List[str]] = None,
+        space: Optional[Union[str, List[str]]] = None,
         auto_expose_tools: bool = True,
         search_enabled: bool = True,
         max_workers: int = 5,
@@ -325,6 +341,7 @@ class SMCP(FastMCP):
         self.tool_config_files = tool_config_files or {}
         self.include_tool_types = include_tool_types or []
         self.exclude_tool_types = exclude_tool_types or []
+        self.space = space
         self.auto_expose_tools = auto_expose_tools
         self.search_enabled = search_enabled
         self.max_workers = max_workers
@@ -332,18 +349,61 @@ class SMCP(FastMCP):
         self.hook_config = hook_config
         self.hook_type = hook_type
 
+        # Space configuration storage
+        self.space_llm_config = None
+        self.space_metadata = None
+
         # Thread pool for concurrent tool execution
         self.executor = ThreadPoolExecutor(max_workers=max_workers)
 
         # Track exposed tools to avoid duplicates
         self._exposed_tools = set()
 
-        # Initialize SMCP-specific features
+        # Load Space configurations first if provided
+        if space:
+            self._load_space_configs(space)
+
+        # Initialize SMCP-specific features (after Space is loaded)
         self._setup_smcp_tools()
 
         # Register custom MCP methods
         self._register_custom_mcp_methods()
 
+    def _load_space_configs(self, space: Union[str, List[str]]):
+        """
+        Load Space configurations.
+
+        This method loads Space configuration(s) and retrieves the LLM config
+        and metadata from ToolUniverse. It completely reuses ToolUniverse's
+        load_space functionality without reimplementing any logic.
+
+        Args:
+            space: Space URI or list of URIs (e.g., "./config.yaml",
+                      "hf:user/repo", or ["config1.yaml", "config2.yaml"])
+        """
+        space_list = [space] if isinstance(space, str) else space
+
+        for uri in space_list:
+            print(f"📦 Loading Space: {uri}")
+
+            # Directly call ToolUniverse's method (complete reuse)
+            config = self.tooluniverse.load_space(uri)
+
+            # Get configurations from ToolUniverse (complete reuse)
+            self.space_metadata = self.tooluniverse.get_space_metadata()
+            self.space_llm_config = self.tooluniverse.get_space_llm_config()
+
+            print(f"✅ Space loaded: {config.get('name', 'Unknown')}")
+
+    def get_llm_config(self) -> Optional[Dict[str, Any]]:
+        """
+        Get the current Space LLM configuration.
+
+        Returns:
+            LLM configuration dictionary or None if not set
+        """
+        return self.space_llm_config
+
     def _register_custom_mcp_methods(self):
         """
         Register custom MCP protocol methods for enhanced functionality.
@@ -857,9 +917,28 @@ class SMCP(FastMCP):
         - All setup phases include comprehensive error handling
         - Performance scales with the number of tools being loaded and exposed
         """
-        # Always ensure full tool set is loaded (hooks may have preloaded a minimal set)
-        # Deduplication in ToolUniverse.load_tools prevents duplicates, so reloading is safe
-        if self.tool_categories:
+        # Determine if ToolUniverse already has tools loaded (e.g., provided pre-configured instance)
+        preloaded_tools = getattr(self.tooluniverse, "all_tools", [])
+        preloaded_count = (
+            len(preloaded_tools) if isinstance(preloaded_tools, list) else 0
+        )
+
+        if preloaded_count > 0:
+            self.logger.info(
+                f"ToolUniverse already pre-configured with {preloaded_count} tool(s); skipping automatic loading."
+            )
+
+        # Check if Space has already loaded specific tools
+        if (
+            self.space
+            and hasattr(self.tooluniverse, "_current_space_config")
+            and preloaded_count > 0
+        ):
+            # Space has already loaded specific tools, don't reload all tools
+            self.logger.info(
+                f"Space configuration loaded {preloaded_count} tool(s), skipping additional loading"
+            )
+        elif preloaded_count == 0 and self.tool_categories:
             try:
                 # Validate categories first
                 valid_categories = self._get_valid_categories()
@@ -924,8 +1003,10 @@ class SMCP(FastMCP):
                     include_tool_types=self.include_tool_types,
                     exclude_tool_types=self.exclude_tool_types,
                 )
-        elif self.auto_expose_tools:
-            # Load all tools by default
+        elif self.auto_expose_tools and not (
+            self.space and hasattr(self.tooluniverse, "_current_space_config")
+        ):
+            # Load all tools by default (unless Space already handled tool loading)
             self.tooluniverse.load_tools(
                 exclude_tools=self.exclude_tools,
                 exclude_categories=self.exclude_categories,