tooluniverse 1.0.11.2__py3-none-any.whl → 1.0.12__py3-none-any.whl

tooluniverse/gtex_tool.py

@@ -0,0 +1,168 @@
+import json
+from typing import Any, Dict
+from urllib.parse import urlencode
+from urllib.request import Request, urlopen
+
+from tooluniverse.tool_registry import register_tool
+
+
+def _http_get(
+    url: str,
+    headers: Dict[str, str] | None = None,
+    timeout: int = 30,
+) -> Dict[str, Any]:
+    req = Request(url, headers=headers or {})
+    with urlopen(req, timeout=timeout) as resp:
+        data = resp.read()
+        try:
+            return json.loads(data.decode("utf-8", errors="ignore"))
+        except Exception:
+            return {"raw": data.decode("utf-8", errors="ignore")}
+
+
+@register_tool(
+    "GTExExpressionTool",
+    config={
+        "name": "GTEx_get_expression_summary",
+        "type": "GTExExpressionTool",
+        "description": "Get GTEx expression summary for a gene via /expression/geneExpression",
+        "parameter": {
+            "type": "object",
+            "properties": {
+                "ensembl_gene_id": {
+                    "type": "string",
+                    "description": "Ensembl gene ID, e.g., ENSG00000141510",
+                }
+            },
+            "required": ["ensembl_gene_id"],
+        },
+        "settings": {"base_url": "https://gtexportal.org/api/v2", "timeout": 30},
+    },
+)
+class GTExExpressionTool:
+    def __init__(self, tool_config=None):
+        self.tool_config = tool_config or {}
+
+    def run(self, arguments: Dict[str, Any]):
+        base = self.tool_config.get("settings", {}).get(
+            "base_url", "https://gtexportal.org/api/v2"
+        )
+        timeout = int(self.tool_config.get("settings", {}).get("timeout", 30))
+
+        query = {"gencodeId": arguments.get("ensembl_gene_id")}
+        url = f"{base}/expression/geneExpression?{urlencode(query)}"
+        try:
+            api_response = _http_get(
+                url, headers={"Accept": "application/json"}, timeout=timeout
+            )
+            # Wrap API response to match schema: data.geneExpression should be array
+            # API returns {"data": [...], "paging_info": {...}}
+            # Schema expects {"data": {"geneExpression": [...]}}
+            if isinstance(api_response, dict) and "data" in api_response:
+                wrapped_data = {"geneExpression": api_response.get("data", [])}
+            else:
+                # Fallback if response format is unexpected
+                wrapped_data = {
+                    "geneExpression": (
+                        api_response if isinstance(api_response, list) else []
+                    )
+                }
+
+            return {
+                "source": "GTEx",
+                "endpoint": "expression/geneExpression",
+                "query": query,
+                "data": wrapped_data,
+                "success": True,
+            }
+        except Exception as e:
+            return {
+                "error": str(e),
+                "source": "GTEx",
+                "endpoint": "expression/geneExpression",
+                "success": False,
+            }
+
+
+@register_tool(
+    "GTExEQTLTool",
+    config={
+        "name": "GTEx_query_eqtl",
+        "type": "GTExEQTLTool",
+        "description": "Query GTEx single-tissue eQTL via /association/singleTissueEqtl",
+        "parameter": {
+            "type": "object",
+            "properties": {
+                "ensembl_gene_id": {
+                    "type": "string",
+                    "description": "Ensembl gene ID, e.g., ENSG00000141510",
+                },
+                "page": {
+                    "type": "integer",
+                    "default": 1,
+                    "minimum": 1,
+                    "description": "Page number (1-based)",
+                },
+                "size": {
+                    "type": "integer",
+                    "default": 10,
+                    "minimum": 1,
+                    "maximum": 100,
+                    "description": "Page size (1–100)",
+                },
+            },
+            "required": ["ensembl_gene_id"],
+        },
+        "settings": {"base_url": "https://gtexportal.org/api/v2", "timeout": 30},
+    },
+)
+class GTExEQTLTool:
+    def __init__(self, tool_config=None):
+        self.tool_config = tool_config or {}
+
+    def run(self, arguments: Dict[str, Any]):
+        base = self.tool_config.get("settings", {}).get(
+            "base_url", "https://gtexportal.org/api/v2"
+        )
+        timeout = int(self.tool_config.get("settings", {}).get("timeout", 30))
+
+        query: Dict[str, Any] = {
+            "gencodeId": arguments.get("ensembl_gene_id"),
+        }
+        if "page" in arguments:
+            query["page"] = int(arguments["page"])
+        if "size" in arguments:
+            query["pageSize"] = int(arguments["size"])
+
+        url = f"{base}/association/singleTissueEqtl?{urlencode(query)}"
+        try:
+            api_response = _http_get(
+                url, headers={"Accept": "application/json"}, timeout=timeout
+            )
+            # Wrap API response to match schema: data.singleTissueEqtl should be array
+            # API returns {"data": [...], "paging_info": {...}}
+            # Schema expects {"data": {"singleTissueEqtl": [...]}}
+            if isinstance(api_response, dict) and "data" in api_response:
+                wrapped_data = {"singleTissueEqtl": api_response.get("data", [])}
+            else:
+                # Fallback if response format is unexpected
+                wrapped_data = {
+                    "singleTissueEqtl": (
+                        api_response if isinstance(api_response, list) else []
+                    )
+                }
+
+            return {
+                "source": "GTEx",
+                "endpoint": "association/singleTissueEqtl",
+                "query": query,
+                "data": wrapped_data,
+                "success": True,
+            }
+        except Exception as e:
+            return {
+                "error": str(e),
+                "source": "GTEx",
+                "endpoint": "association/singleTissueEqtl",
+                "success": False,
+            }

tooluniverse/mgnify_tool.py

@@ -0,0 +1,181 @@
+import json
+from typing import Any, Dict
+from urllib.parse import urlencode
+from urllib.request import Request, urlopen
+
+from tooluniverse.tool_registry import register_tool
+
+
+def _http_get(
+    url: str,
+    headers: Dict[str, str] | None = None,
+    timeout: int = 30,
+) -> Dict[str, Any]:
+    req = Request(url, headers=headers or {})
+    with urlopen(req, timeout=timeout) as resp:
+        data = resp.read()
+        try:
+            return json.loads(data.decode("utf-8", errors="ignore"))
+        except Exception:
+            return {"raw": data.decode("utf-8", errors="ignore")}
+
+
+@register_tool(
+    "MGnifyStudiesTool",
+    config={
+        "name": "MGnify_search_studies",
+        "type": "MGnifyStudiesTool",
+        "description": "Search MGnify studies via /studies with optional biome/search filters",
+        "parameter": {
+            "type": "object",
+            "properties": {
+                "biome": {
+                    "type": "string",
+                    "description": "Biome identifier, e.g., 'root:Host-associated'",
+                },
+                "search": {
+                    "type": "string",
+                    "description": "Keyword to search in study title/description",
+                },
+                "size": {
+                    "type": "integer",
+                    "default": 10,
+                    "minimum": 1,
+                    "maximum": 100,
+                },
+            },
+        },
+        "settings": {
+            "base_url": "https://www.ebi.ac.uk/metagenomics/api/latest",
+            "timeout": 30,
+        },
+    },
+)
+class MGnifyStudiesTool:
+    def __init__(self, tool_config=None):
+        self.tool_config = tool_config or {}
+
+    def run(self, arguments: Dict[str, Any]):
+        base = self.tool_config.get("settings", {}).get(
+            "base_url", "https://www.ebi.ac.uk/metagenomics/api/latest"
+        )
+        timeout = int(self.tool_config.get("settings", {}).get("timeout", 30))
+
+        query: Dict[str, Any] = {}
+        if arguments.get("biome"):
+            query["biome"] = arguments["biome"]
+        if arguments.get("search"):
+            query["search"] = arguments["search"]
+        if arguments.get("size") is not None:
+            query["size"] = int(arguments["size"])
+        else:
+            query["size"] = 10
+
+        url = f"{base}/studies?{urlencode(query)}"
+        try:
+            api_response = _http_get(
+                url, headers={"Accept": "application/json"}, timeout=timeout
+            )
+            # Wrap API response to match schema: data.data should be array
+            # API returns {"data": [...], "links": {...}, "meta": {...}}
+            # Schema expects {"data": {"data": [...]}}
+            if isinstance(api_response, dict) and "data" in api_response:
+                wrapped_data = {"data": api_response.get("data", [])}
+            else:
+                # Fallback if response format is unexpected
+                wrapped_data = {
+                    "data": api_response if isinstance(api_response, list) else []
+                }
+
+            return {
+                "source": "MGnify",
+                "endpoint": "studies",
+                "query": query,
+                "data": wrapped_data,
+                "success": True,
+            }
+        except Exception as e:
+            return {
+                "error": str(e),
+                "source": "MGnify",
+                "endpoint": "studies",
+                "success": False,
+            }
+
+
+@register_tool(
+    "MGnifyAnalysesTool",
+    config={
+        "name": "MGnify_list_analyses",
+        "type": "MGnifyAnalysesTool",
+        "description": "List MGnify analyses via /analyses for a given study_accession",
+        "parameter": {
+            "type": "object",
+            "properties": {
+                "study_accession": {
+                    "type": "string",
+                    "description": "MGnify study accession, e.g., 'MGYS00000001'",
+                },
+                "size": {
+                    "type": "integer",
+                    "default": 10,
+                    "minimum": 1,
+                    "maximum": 100,
+                },
+            },
+            "required": ["study_accession"],
+        },
+        "settings": {
+            "base_url": "https://www.ebi.ac.uk/metagenomics/api/latest",
+            "timeout": 30,
+        },
+    },
+)
+class MGnifyAnalysesTool:
+    def __init__(self, tool_config=None):
+        self.tool_config = tool_config or {}
+
+    def run(self, arguments: Dict[str, Any]):
+        base = self.tool_config.get("settings", {}).get(
+            "base_url", "https://www.ebi.ac.uk/metagenomics/api/latest"
+        )
+        timeout = int(self.tool_config.get("settings", {}).get("timeout", 30))
+
+        query: Dict[str, Any] = {
+            "study_accession": arguments.get("study_accession"),
+        }
+        if arguments.get("size") is not None:
+            query["size"] = int(arguments["size"])
+        else:
+            query["size"] = 10
+
+        url = f"{base}/analyses?{urlencode(query)}"
+        try:
+            api_response = _http_get(
+                url, headers={"Accept": "application/json"}, timeout=timeout
+            )
+            # Wrap API response to match schema: data.data should be array
+            # API returns {"data": [...], "links": {...}, "meta": {...}}
+            # Schema expects {"data": {"data": [...]}}
+            if isinstance(api_response, dict) and "data" in api_response:
+                wrapped_data = {"data": api_response.get("data", [])}
+            else:
+                # Fallback if response format is unexpected
+                wrapped_data = {
+                    "data": api_response if isinstance(api_response, list) else []
+                }
+
+            return {
+                "source": "MGnify",
+                "endpoint": "analyses",
+                "query": query,
+                "data": wrapped_data,
+                "success": True,
+            }
+        except Exception as e:
+            return {
+                "error": str(e),
+                "source": "MGnify",
+                "endpoint": "analyses",
+                "success": False,
+            }

tooluniverse/obis_tool.py

@@ -0,0 +1,185 @@
+import json
+from typing import Any, Dict
+from urllib.parse import urlencode
+from urllib.request import Request, urlopen
+
+from tooluniverse.tool_registry import register_tool
+
+
+def _http_get(
+    url: str,
+    headers: Dict[str, str] | None = None,
+    timeout: int = 30,
+) -> Dict[str, Any]:
+    req = Request(url, headers=headers or {})
+    with urlopen(req, timeout=timeout) as resp:
+        data = resp.read()
+        try:
+            return json.loads(data.decode("utf-8", errors="ignore"))
+        except Exception:
+            return {"raw": data.decode("utf-8", errors="ignore")}
+
+
+@register_tool(
+    "OBISTaxaTool",
+    config={
+        "name": "OBIS_search_taxa",
+        "type": "OBISTaxaTool",
+        "description": "Resolve marine taxa by scientific name via OBIS /v3/taxon",
+        "parameter": {
+            "type": "object",
+            "properties": {
+                "scientificname": {
+                    "type": "string",
+                    "description": "Scientific name to search, e.g., 'Gadus'",
+                },
+                "size": {
+                    "type": "integer",
+                    "default": 10,
+                    "minimum": 1,
+                    "maximum": 100,
+                },
+            },
+            "required": ["scientificname"],
+        },
+        "settings": {"base_url": "https://api.obis.org/v3", "timeout": 30},
+    },
+)
+class OBISTaxaTool:
+    def __init__(self, tool_config=None):
+        self.tool_config = tool_config or {}
+
+    def run(self, arguments: Dict[str, Any]):
+        base = self.tool_config.get("settings", {}).get(
+            "base_url", "https://api.obis.org/v3"
+        )
+        timeout = int(self.tool_config.get("settings", {}).get("timeout", 30))
+
+        scientificname = arguments.get("scientificname")
+        size = int(arguments.get("size", 10))
+
+        # Note: OBIS v3 API does not have /taxon endpoint
+        # Use occurrence search with scientificname filter instead
+        # This returns occurrences which can be used to identify taxa
+        query = {
+            "scientificname": scientificname,
+            "size": size,
+        }
+        url = f"{base}/occurrence?{urlencode(query)}"
+        try:
+            data = _http_get(
+                url, headers={"Accept": "application/json"}, timeout=timeout
+            )
+            # Extract unique taxa from occurrences
+            if isinstance(data, dict) and "results" in data:
+                results = data.get("results", [])
+                # Extract unique scientific names and taxonomic info
+                taxa_list = []
+                seen_names = set()
+                for occ in results:
+                    sci_name = occ.get("scientificName")
+                    if sci_name and sci_name not in seen_names:
+                        seen_names.add(sci_name)
+                        taxa_list.append(
+                            {
+                                "scientificName": sci_name,
+                                "aphiaID": occ.get("aphiaID"),
+                                "rank": occ.get("taxonRank"),
+                                "kingdom": occ.get("kingdom"),
+                                "phylum": occ.get("phylum"),
+                                "class": occ.get("class_"),
+                                "order": occ.get("order"),
+                                "family": occ.get("family"),
+                                "genus": occ.get("genus"),
+                            }
+                        )
+                        if len(taxa_list) >= size:
+                            break
+                # Return in expected schema format
+                wrapped_data = {
+                    "results": taxa_list,
+                    "total": len(taxa_list),
+                }
+            else:
+                wrapped_data = {"results": [], "total": 0}
+
+            return {
+                "source": "OBIS",
+                "endpoint": "occurrence",  # Note: taxon endpoint not available, using occurrence
+                "query": query,
+                "data": wrapped_data,
+                "success": True,
+            }
+        except Exception as e:
+            return {
+                "error": str(e),
+                "source": "OBIS",
+                "endpoint": "occurrence",
+                "success": False,
+            }
+
+
+@register_tool(
+    "OBISOccurrenceTool",
+    config={
+        "name": "OBIS_search_occurrences",
+        "type": "OBISOccurrenceTool",
+        "description": "Search OBIS occurrences via /v3/occurrence",
+        "parameter": {
+            "type": "object",
+            "properties": {
+                "scientificname": {
+                    "type": "string",
+                    "description": "Scientific name filter (optional)",
+                },
+                "areaid": {
+                    "type": "string",
+                    "description": "Area identifier filter (optional)",
+                },
+                "size": {
+                    "type": "integer",
+                    "default": 10,
+                    "minimum": 1,
+                    "maximum": 100,
+                },
+            },
+        },
+        "settings": {"base_url": "https://api.obis.org/v3", "timeout": 30},
+    },
+)
+class OBISOccurrenceTool:
+    def __init__(self, tool_config=None):
+        self.tool_config = tool_config or {}
+
+    def run(self, arguments: Dict[str, Any]):
+        base = self.tool_config.get("settings", {}).get(
+            "base_url", "https://api.obis.org/v3"
+        )
+        timeout = int(self.tool_config.get("settings", {}).get("timeout", 30))
+
+        query: Dict[str, Any] = {}
+        for key in ("scientificname", "areaid", "size"):
+            if key in arguments and arguments[key] is not None:
+                query[key] = arguments[key]
+        if "size" not in query:
+            query["size"] = 10
+
+        url = f"{base}/occurrence?{urlencode(query)}"
+        try:
+            data = _http_get(
+                url, headers={"Accept": "application/json"}, timeout=timeout
+            )
+            return {
+                "source": "OBIS",
+                "endpoint": "occurrence",
+                "query": query,
+                "data": data,
+                "success": True,
+            }
+        except Exception as e:
+            return {
+                "error": str(e),
+                "source": "OBIS",
+                "endpoint": "occurrence",
+                "success": False,
+            }

tooluniverse/pypi_package_inspector_tool.py

@@ -5,6 +5,7 @@ import time
 from datetime import datetime, timedelta
 from typing import Dict, Any
 from .tool_registry import register_tool
+from .base_tool import BaseTool
 
 
 @register_tool(
@@ -39,7 +40,7 @@ from .tool_registry import register_tool
         },
     },
 )
-class PyPIPackageInspector:
+class PyPIPackageInspector(BaseTool):
     """
     Extracts comprehensive package information from PyPI and GitHub.
     Provides detailed metrics on popularity, maintenance, security,
@@ -47,7 +48,7 @@ class PyPIPackageInspector:
     """
 
     def __init__(self, tool_config: Dict[str, Any] = None):
-        self.tool_config = tool_config or {}
+        BaseTool.__init__(self, tool_config or {})
         self.pypi_api_url = "https://pypi.org/pypi/{package}/json"
         self.pypistats_api_url = "https://pypistats.org/api/packages/{package}/recent"
         self.github_api_url = "https://api.github.com/repos/{owner}/{repo}"

tooluniverse/rnacentral_tool.py

@@ -0,0 +1,124 @@
+import json
+from typing import Any, Dict
+from urllib.parse import urlencode
+from urllib.request import Request, urlopen
+
+from tooluniverse.tool_registry import register_tool
+
+
+def _http_get(
+    url: str, headers: Dict[str, str] | None = None, timeout: int = 30
+) -> Dict[str, Any]:
+    req = Request(url, headers=headers or {})
+    with urlopen(req, timeout=timeout) as resp:
+        data = resp.read()
+        try:
+            return json.loads(data.decode("utf-8", errors="ignore"))
+        except Exception:
+            return {"raw": data.decode("utf-8", errors="ignore")}
+
+
+@register_tool(
+    "RNAcentralSearchTool",
+    config={
+        "name": "RNAcentral_search",
+        "type": "RNAcentralSearchTool",
+        "description": "Search RNA records via RNAcentral API",
+        "parameter": {
+            "type": "object",
+            "properties": {
+                "query": {"type": "string", "description": "Keyword or accession"},
+                "page_size": {
+                    "type": "integer",
+                    "default": 10,
+                    "minimum": 1,
+                    "maximum": 100,
+                },
+            },
+            "required": ["query"],
+        },
+        "settings": {"base_url": "https://rnacentral.org/api/v1", "timeout": 30},
+    },
+)
+class RNAcentralSearchTool:
+    def __init__(self, tool_config=None):
+        self.tool_config = tool_config or {}
+
+    def run(self, arguments: Dict[str, Any]):
+        base = self.tool_config.get("settings", {}).get(
+            "base_url", "https://rnacentral.org/api/v1"
+        )
+        timeout = int(self.tool_config.get("settings", {}).get("timeout", 30))
+
+        query = {
+            "query": arguments.get("query"),
+            "page_size": int(arguments.get("page_size", 10)),
+        }
+        url = f"{base}/rna/?{urlencode(query)}"
+        try:
+            data = _http_get(
+                url, headers={"Accept": "application/json"}, timeout=timeout
+            )
+            return {
+                "source": "RNAcentral",
+                "endpoint": "rna",
+                "query": query,
+                "data": data,
+                "success": True,
+            }
+        except Exception as e:
+            return {
+                "error": str(e),
+                "source": "RNAcentral",
+                "endpoint": "rna",
+                "success": False,
+            }
+
+
+@register_tool(
+    "RNAcentralGetTool",
+    config={
+        "name": "RNAcentral_get_by_accession",
+        "type": "RNAcentralGetTool",
+        "description": "Get RNAcentral entry by accession",
+        "parameter": {
+            "type": "object",
+            "properties": {
+                "accession": {"type": "string", "description": "RNAcentral accession"}
+            },
+            "required": ["accession"],
+        },
+        "settings": {"base_url": "https://rnacentral.org/api/v1", "timeout": 30},
+    },
+)
+class RNAcentralGetTool:
+    def __init__(self, tool_config=None):
+        self.tool_config = tool_config or {}
+
+    def run(self, arguments: Dict[str, Any]):
+        base = self.tool_config.get("settings", {}).get(
+            "base_url", "https://rnacentral.org/api/v1"
+        )
+        timeout = int(self.tool_config.get("settings", {}).get("timeout", 30))
+
+        acc = arguments.get("accession")
+        url = f"{base}/rna/{acc}"
+        try:
+            data = _http_get(
+                url, headers={"Accept": "application/json"}, timeout=timeout
+            )
+            return {
+                "source": "RNAcentral",
+                "endpoint": "rna/{accession}",
+                "accession": acc,
+                "data": data,
+                "success": True,
+            }
+        except Exception as e:
+            return {
+                "error": str(e),
+                "source": "RNAcentral",
+                "endpoint": "rna/{accession}",
+                "accession": acc,
+                "success": False,
+            }