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

tooluniverse/default_config.py

@@ -51,6 +51,16 @@ 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"),
+    "tool_discovery_agents": os.path.join(
+        current_dir, "data", "tool_discovery_agents.json"
+    ),
+    "web_search_tools": os.path.join(current_dir, "data", "web_search_tools.json"),
+    "package_discovery_tools": os.path.join(
+        current_dir, "data", "package_discovery_tools.json"
+    ),
+    "pypi_package_inspector_tools": os.path.join(
+        current_dir, "data", "pypi_package_inspector_tools.json"
+    ),
     "drug_discovery_agents": os.path.join(
         current_dir, "data", "drug_discovery_agents.json"
     ),
@@ -100,6 +110,20 @@ default_tool_files = {
     "visualization_molecule_2d": os.path.join(
         current_dir, "data", "molecule_2d_tools.json"
     ),
+    # New database tools
+    "interpro": os.path.join(current_dir, "data", "interpro_tools.json"),
+    "blast": os.path.join(current_dir, "data", "blast_tools.json"),
+    "cbioportal": os.path.join(current_dir, "data", "cbioportal_tools.json"),
+    "regulomedb": os.path.join(current_dir, "data", "regulomedb_tools.json"),
+    "jaspar": os.path.join(current_dir, "data", "jaspar_tools.json"),
+    "remap": os.path.join(current_dir, "data", "remap_tools.json"),
+    "screen": os.path.join(current_dir, "data", "screen_tools.json"),
+    "pride": os.path.join(current_dir, "data", "pride_tools.json"),
+    "emdb": os.path.join(current_dir, "data", "emdb_tools.json"),
+    "gtopdb": os.path.join(current_dir, "data", "gtopdb_tools.json"),
+    "mpd": os.path.join(current_dir, "data", "mpd_tools.json"),
+    "worms": os.path.join(current_dir, "data", "worms_tools.json"),
+    "paleobiology": os.path.join(current_dir, "data", "paleobiology_tools.json"),
     "visualization_molecule_3d": os.path.join(
         current_dir, "data", "molecule_3d_tools.json"
     ),
@@ -120,6 +144,7 @@ default_tool_files = {
     ),
     "go": os.path.join(current_dir, "data", "gene_ontology_tools.json"),
     "compose": os.path.join(current_dir, "data", "compose_tools.json"),
+    "python_executor": os.path.join(current_dir, "data", "python_executor_tools.json"),
     "idmap": os.path.join(current_dir, "data", "idmap_tools.json"),
     "disease_target_score": os.path.join(
         current_dir, "data", "disease_target_score_tools.json"
@@ -131,6 +156,7 @@ default_tool_files = {
     "xml": os.path.join(current_dir, "data", "xml_tools.json"),
     "mcp_auto_loader_boltz": os.path.join(current_dir, "data", "boltz_tools.json"),
     "url": os.path.join(current_dir, "data", "url_fetch_tools.json"),
+    "file_download": os.path.join(current_dir, "data", "file_download_tools.json"),
     # 'langchain': os.path.join(current_dir, 'data', 'langchain_tools.json'),
     "rcsb_pdb": os.path.join(current_dir, "data", "rcsb_pdb_tools.json"),
     "tool_composition": os.path.join(
@@ -146,10 +172,17 @@ default_tool_files = {
     ),
     "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"),
+    # Database tools
+    "kegg": os.path.join(current_dir, "data", "kegg_tools.json"),
+    "ensembl": os.path.join(current_dir, "data", "ensembl_tools.json"),
+    "clinvar": os.path.join(current_dir, "data", "clinvar_tools.json"),
+    "geo": os.path.join(current_dir, "data", "geo_tools.json"),
+    "dbsnp": os.path.join(current_dir, "data", "dbsnp_tools.json"),
+    "gnomad": os.path.join(current_dir, "data", "gnomad_tools.json"),
+    # Ontology tools
+    "ols": os.path.join(current_dir, "data", "ols_tools.json"),
 }
 
 

tooluniverse/emdb_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("EMDBRESTTool")
+class EMDBRESTTool(BaseTool):
+    def __init__(self, tool_config: Dict):
+        super().__init__(tool_config)
+        self.base_url = "https://www.ebi.ac.uk/emdb/api"
+        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"EMDB API error: {str(e)}"}

tooluniverse/ensembl_tool.py

@@ -1,61 +1,154 @@
+"""
+Ensembl REST API Tool
+
+This tool provides access to the Ensembl genome browser database for gene
+lookup, sequence retrieval, variant information, and homology data.
+"""
+
 import requests
+from typing import Dict, Any, Optional
 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.
-    """
+class EnsemblRESTTool(BaseTool):
+    """Base class for Ensembl REST API tools."""
 
     def __init__(self, tool_config):
         super().__init__(tool_config)
-        self.base = "https://rest.ensembl.org"
+        self.base_url = "https://rest.ensembl.org"
         self.session = requests.Session()
         self.session.headers.update(
-            {"Accept": "application/json", "Content-Type": "application/json"}
+            {
+                "Accept": "application/json",
+                "Content-Type": "application/json",
+                "User-Agent": "ToolUniverse/1.0",
+            }
         )
+        self.timeout = 30
+
+    def _make_request(
+        self, endpoint: str, params: Optional[Dict] = None
+    ) -> Dict[str, Any]:
+        """Make a request to the Ensembl API."""
+        url = f"{self.base_url}{endpoint}"
+        try:
+            response = self.session.get(url, params=params, timeout=self.timeout)
+            response.raise_for_status()
+
+            data = response.json()
+            return {
+                "status": "success",
+                "data": data,
+                "url": url,
+                "content_type": response.headers.get(
+                    "content-type", "application/json"
+                ),
+            }
+
+        except requests.exceptions.RequestException as e:
+            return {
+                "status": "error",
+                "error": f"Ensembl API request failed: {str(e)}",
+                "url": url,
+            }
 
-    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")
+    def run(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Execute the tool with given arguments."""
+        return self._make_request(self.endpoint, arguments)
+
+
+@register_tool("EnsemblLookupGene")
+class EnsemblLookupGene(EnsemblRESTTool):
+    """Lookup gene information by ID or symbol."""
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+        self.endpoint = "/lookup/id"
+
+    def run(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Lookup gene by ID or symbol."""
+        gene_id = arguments.get("gene_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),
+            return {"status": "error", "error": "gene_id is required"}
+
+        # Ensembl API requires the ID in the URL path
+        endpoint = f"{self.endpoint}/{gene_id}"
+        params = {"expand": 1}
+
+        # Add species if specified
+        if "species" in arguments:
+            params["species"] = arguments["species"]
+
+        result = self._make_request(endpoint, params)
+
+        # Add gene_id to result for reference
+        if result.get("status") == "success":
+            result["gene_id"] = gene_id
+
+        return result
+
+
+@register_tool("EnsemblGetSequence")
+class EnsemblGetSequence(EnsemblRESTTool):
+    """Get DNA or protein sequences by region or gene ID."""
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+        self.endpoint = "/sequence/id"
+
+    def run(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Get sequence by gene ID or region."""
+        sequence_id = arguments.get("sequence_id", "")
+        if not sequence_id:
+            return {"status": "error", "error": "sequence_id is required"}
+
+        # Ensembl API requires the ID in the URL path
+        endpoint = f"{self.endpoint}/{sequence_id}"
+        params = {
+            "type": arguments.get("type", "genomic"),  # genomic, cds, protein
+            "multiple_sequences": "true",
         }
+
+        # Add species if specified
+        if "species" in arguments:
+            params["species"] = arguments["species"]
+
+        result = self._make_request(endpoint, params)
+
+        # Add sequence_id to result for reference
+        if result.get("status") == "success":
+            result["sequence_id"] = sequence_id
+
+        return result
+
+
+@register_tool("EnsemblGetVariants")
+class EnsemblGetVariants(EnsemblRESTTool):
+    """Get variant information for a genomic region."""
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+        self.endpoint = "/overlap/id"
+
+    def run(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Get variants for a region."""
+        region = arguments.get("region", "")
+        if not region:
+            return {
+                "status": "error",
+                "error": "region is required (e.g., '1:1000000..2000000')",
+            }
+
+        # Ensembl API requires the region in the URL path with species
+        species = arguments.get("species", "human")
+        endpoint = f"/overlap/region/{species}/{region}"
+        params = {"feature": "variation", "content-type": "application/json"}
+
+        result = self._make_request(endpoint, params)
+
+        # Add region to result for reference
+        if result.get("status") == "success":
+            result["region"] = region
+
+        return result

tooluniverse/execute_function.py

@@ -563,8 +563,9 @@ class ToolUniverse:
             for key in sorted(all_missing_keys):
                 f.write(f"{key}=your_api_key_here\n\n")
 
-        self.logger.info(f"Generated API key template: {output_file}")
-        self.logger.info("Copy this file to .env and fill in your API keys")
+        self.logger.info(
+            f"Generated API key template: {output_file}. Copy this file to .env and fill in your API keys"
+        )
 
     def _create_hook_config_from_type(self, hook_type):
         """
@@ -966,8 +967,10 @@ class ToolUniverse:
 
         # Generate template for missing API keys
         if len(all_missing_keys) > 0:
-            warning(f"\nMissing API keys: {', '.join(all_missing_keys)}")
-            info("Generating .env.template file with missing API keys...")
+            warning(
+                f"Some tools will not be loaded due to missing API keys: {', '.join(all_missing_keys)}"
+            )
+            # info("Generating .env.template file with missing API keys...")
             self.generate_env_template(all_missing_keys)
 
     def _load_auto_discovered_configs(self):
@@ -2137,16 +2140,42 @@ class ToolUniverse:
                         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()",
-                            ],
+                    # Try to auto-load tools if dictionary is empty
+                    if not self._auto_load_tools_if_empty(function_name):
+                        error_msg = "Failed to auto-load tools"
+                        return self._create_dual_format_error(
+                            ToolUnavailableError(
+                                error_msg,
+                                next_steps=[
+                                    "Manually run tu.load_tools()",
+                                    "Check tool configuration",
+                                ],
+                            )
+                        )
+
+                    # Try to get the tool instance again after loading
+                    tool_instance = self._get_tool_instance(function_name, cache=True)
+                    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 even after loading tools"
+                        )
+                        return self._create_dual_format_error(
+                            ToolUnavailableError(
+                                error_msg,
+                                next_steps=[
+                                    "Check tool name spelling",
+                                    "Verify tool is available in loaded categories",
+                                ],
+                            )
                         )
-                    )
             except Exception as e:
                 # Classify and return structured error
                 classified_error = self._classify_exception(e, function_name, arguments)
@@ -2356,6 +2385,29 @@ class ToolUniverse:
 
         return None
 
+    def _auto_load_tools_if_empty(self, function_name: str = None) -> bool:
+        """
+        Automatically load tools if the tools dictionary is empty.
+
+        Args:
+            function_name: Optional tool name to check after loading
+
+        Returns:
+            bool: True if tools were loaded successfully, False otherwise
+        """
+        if not self.all_tool_dict:
+            print(
+                "⚠️  Warning: No tools loaded. Automatically running tu.load_tools()..."
+            )
+            try:
+                self.load_tools()
+                print("✅ Tools loaded successfully.")
+                return True
+            except Exception as load_error:
+                print(f"❌ Failed to auto-load tools: {load_error}")
+                return False
+        return True
+
     def _make_cache_key(self, function_name: str, arguments: dict) -> str:
         """Generate cache key by delegating to BaseTool."""
         tool_instance = self._get_tool_instance(function_name, cache=False)
@@ -2374,7 +2426,15 @@ class ToolUniverse:
     ) -> Optional[ToolError]:
         """Validate parameters by delegating to BaseTool."""
         if function_name not in self.all_tool_dict:
-            return ToolUnavailableError(f"Tool '{function_name}' not found")
+            # Try to auto-load tools if dictionary is empty
+            if not self._auto_load_tools_if_empty(function_name):
+                return ToolUnavailableError("Failed to auto-load tools")
+
+            # Check again after loading
+            if function_name not in self.all_tool_dict:
+                return ToolUnavailableError(
+                    f"Tool '{function_name}' not found even after loading tools"
+                )
 
         tool_instance = self._get_tool_instance(function_name, cache=False)
         if not tool_instance: