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

tooluniverse/dbsnp_tool.py

@@ -1,71 +1,209 @@
-import requests
-from .base_tool import BaseTool
+"""
+dbSNP REST API Tool
+
+This tool provides access to the dbSNP (Single Nucleotide Polymorphism) database
+for variant information, allele frequencies, and genomic coordinates.
+"""
+
+from typing import Dict, Any
+from .ncbi_eutils_tool import NCBIEUtilsTool
 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.
-    """
+class dbSNPRESTTool(NCBIEUtilsTool):
+    """Base class for dbSNP REST API tools with rate limiting."""
+
+
+@register_tool("dbSNPGetVariantByRsID")
+class dbSNPGetVariantByRsID(dbSNPRESTTool):
+    """Get variant information by rsID."""
 
     def __init__(self, tool_config):
         super().__init__(tool_config)
-        self.base = "https://api.ncbi.nlm.nih.gov/variation/v0"
-        self.session = requests.Session()
+        self.endpoint = "/esummary.fcgi"
 
-    def run(self, arguments):
-        rsid = arguments.get("rsid")
+    def run(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Get variant by rsID using E-utilities."""
+        rsid = arguments.get("rsid", "")
         if not rsid:
-            return {"error": "Missing required parameter: rsid"}
+            return {"status": "error", "error": "rsid is required"}
 
-        # Clean rsid (remove 'rs' prefix if present)
+        # 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,
+        params = {"db": "snp", "id": rsid, "retmode": "json"}
+
+        result = self._make_request(self.endpoint, params)
+
+        # Parse and extract useful data from NCBI response
+        if result.get("status") == "success":
+            data = result.get("data", {})
+            if isinstance(data, dict) and "result" in data:
+                result_data = data["result"]
+                if rsid in result_data:
+                    variant_data = result_data[rsid]
+
+                    # Extract key information
+                    parsed_data = {
+                        "refsnp_id": f"rs{rsid}",
+                        "snp_id": variant_data.get("snp_id"),
+                        "chromosome": variant_data.get("chr"),
+                        "position": variant_data.get("chrpos"),
+                        "allele": variant_data.get("allele"),
+                        "snp_class": variant_data.get("snp_class"),
+                        "clinical_significance": variant_data.get(
+                            "clinical_significance", ""
+                        ).split(","),
+                        "genes": [
+                            gene.get("name") for gene in variant_data.get("genes", [])
+                        ],
+                        "allele_frequencies": variant_data.get("global_mafs", []),
+                        "hgvs_notation": variant_data.get("docsum", ""),
+                        "spdi_notation": variant_data.get("spdi", ""),
+                        "function_class": variant_data.get("fxn_class", "").split(","),
+                        "validated": variant_data.get("validated", "").split(","),
+                        "created_date": variant_data.get("createdate"),
+                        "updated_date": variant_data.get("updatedate"),
+                    }
+
+                    result["data"] = parsed_data
+                    result["rsid"] = f"rs{rsid}"
+                else:
+                    result["status"] = "error"
+                    result["error"] = f"Variant rs{rsid} not found in dbSNP"
+            else:
+                result["status"] = "error"
+                result["error"] = "Invalid response format from NCBI E-utilities"
+
+        return result
+
+
+@register_tool("dbSNPSearchByGene")
+class dbSNPSearchByGene(dbSNPRESTTool):
+    """Search variants by gene symbol."""
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+        self.endpoint = "/esearch.fcgi"
+
+    def run(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Search variants by gene using E-utilities."""
+        gene_symbol = arguments.get("gene_symbol", "")
+        if not gene_symbol:
+            return {"status": "error", "error": "gene_symbol is required"}
+
+        params = {
+            "db": "snp",
+            "term": f"{gene_symbol}[gene]",
+            "retmode": "json",
+            "retmax": arguments.get("limit", 20),
         }
+
+        result = self._make_request(self.endpoint, params)
+
+        # Parse and extract useful data from NCBI response
+        if result.get("status") == "success":
+            data = result.get("data", {})
+            if isinstance(data, dict) and "esearchresult" in data:
+                esearch_data = data["esearchresult"]
+
+                # Extract variant IDs
+                variant_ids = esearch_data.get("idlist", [])
+                count = int(esearch_data.get("count", 0))
+
+                # Create variant list with basic info
+                variants = []
+                for variant_id in variant_ids:
+                    variants.append(
+                        {"refsnp_id": f"rs{variant_id}", "snp_id": int(variant_id)}
+                    )
+
+                parsed_data = {
+                    "variants": variants,
+                    "total_count": count,
+                    "returned_count": len(variants),
+                }
+
+                result["data"] = parsed_data
+                result["gene_symbol"] = gene_symbol
+            else:
+                result["status"] = "error"
+                result["error"] = "Invalid response format from NCBI E-utilities"
+
+        return result
+
+
+@register_tool("dbSNPGetFrequencies")
+class dbSNPGetFrequencies(dbSNPRESTTool):
+    """Get allele frequencies for a variant."""
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+        self.endpoint = "/esummary.fcgi"
+
+    def run(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Get allele frequencies by rsID using E-utilities."""
+        rsid = arguments.get("rsid", "")
+        if not rsid:
+            return {"status": "error", "error": "rsid is required"}
+
+        # Remove 'rs' prefix if present
+        if rsid.startswith("rs"):
+            rsid = rsid[2:]
+
+        params = {"db": "snp", "id": rsid, "retmode": "json"}
+
+        result = self._make_request(self.endpoint, params)
+
+        # Parse and extract frequency data from NCBI response
+        if result.get("status") == "success":
+            data = result.get("data", {})
+            if isinstance(data, dict) and "result" in data:
+                result_data = data["result"]
+                if rsid in result_data:
+                    variant_data = result_data[rsid]
+
+                    # Extract allele frequency data
+                    frequencies = []
+                    global_mafs = variant_data.get("global_mafs", [])
+
+                    for maf in global_mafs:
+                        study = maf.get("study", "Unknown")
+                        freq_str = maf.get("freq", "")
+
+                        # Parse frequency string (e.g., "C=0.1505591/754")
+                        if "=" in freq_str and "/" in freq_str:
+                            try:
+                                allele_part, count_part = freq_str.split("/")
+                                allele = allele_part.split("=")[0]
+                                frequency = float(allele_part.split("=")[1])
+                                sample_count = int(count_part)
+
+                                frequencies.append(
+                                    {
+                                        "study": study,
+                                        "allele": allele,
+                                        "frequency": frequency,
+                                        "sample_count": sample_count,
+                                    }
+                                )
+                            except (ValueError, IndexError):
+                                # Skip malformed frequency entries
+                                continue
+
+                    parsed_data = {
+                        "frequencies": frequencies,
+                        "total_studies": len(frequencies),
+                    }
+
+                    result["data"] = parsed_data
+                    result["rsid"] = f"rs{rsid}"
+                else:
+                    result["status"] = "error"
+                    result["error"] = f"Variant rs{rsid} not found in dbSNP"
+            else:
+                result["status"] = "error"
+                result["error"] = "Invalid response format from NCBI E-utilities"
+
+        return result

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"),
 }
 
 
@@ -157,7 +190,7 @@ def get_default_hook_config():
     """
     Get default hook configuration.
 
-    Returns:
+    Returns
         dict: Default hook configuration with basic settings
     """
     return {

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/enrichr_tool.py

@@ -37,10 +37,10 @@ class EnrichrTool(BaseTool):
         """
         Retrieve the official gene symbol for a given gene name or synonym using the MyGene.info API.
 
-        Parameters:
+        Parameters
             gene_name (str): The gene name or synonym to query.
 
-        Returns:
+        Returns
             str: The official gene symbol if found; otherwise, raises an Exception.
         """
         # URL-encode the gene_name to handle special characters
@@ -89,10 +89,10 @@ class EnrichrTool(BaseTool):
         """
         Submit the gene list to Enrichr and return the user list ID.
 
-        Parameters:
+        Parameters
             gene_list (str): Newline-separated string of gene names.
 
-        Returns:
+        Returns
             str: The user list ID from Enrichr.
         """
         payload = {
@@ -110,11 +110,11 @@ class EnrichrTool(BaseTool):
         """
         Fetch enrichment results for a specific library.
 
-        Parameters:
+        Parameters
             user_list_id (str): The user list ID from Enrichr.
             library (str): The name of the enrichment library.
 
-        Returns:
+        Returns
             dict: The enrichment results.
         """
         query_string = f"?userListId={user_list_id}&backgroundType={library}"
@@ -129,11 +129,11 @@ class EnrichrTool(BaseTool):
         """
         Initialize and build the graph with gene nodes and enriched terms.
 
-        Parameters:
+        Parameters
             genes (list): List of gene names.
             enrichment_results (dict): Dictionary of enrichment results by library.
 
-        Returns:
+        Returns
             networkx.Graph: The constructed graph.
         """
         G = nx.Graph()
@@ -159,12 +159,12 @@ class EnrichrTool(BaseTool):
         """
         Find and rank paths between source and target based on total edge weight.
 
-        Parameters:
+        Parameters
             G (networkx.Graph): The graph to search.
             source (str): The source node.
             target (str): The target node.
 
-        Returns:
+        Returns
             list: List of tuples (path, weight) sorted by weight descending.
         """
         all_paths = list(nx.all_simple_paths(G, source=source, target=target))
@@ -182,12 +182,12 @@ class EnrichrTool(BaseTool):
         """
         Find and rank paths from each gene to a specified term based on total edge weight.
 
-        Parameters:
+        Parameters
             G (networkx.Graph): The graph to search.
             gene (str): The source gene.
             term (str): The target term.
 
-        Returns:
+        Returns
             list or None: List of tuples (path, weight) sorted by weight descending, or None if no paths.
         """
         all_paths = list(nx.all_simple_paths(G, source=gene, target=term))
@@ -207,11 +207,11 @@ class EnrichrTool(BaseTool):
         """
         Main API function to perform gene enrichment analysis.
 
-        Parameters:
+        Parameters
             genes (list): List of gene names.
             libs (list): List of enrichment libraries to use.
 
-        Returns:
+        Returns
             tuple: (connected_path, connections) dictionaries.
         """
         # Convert each gene to its official name and log the result