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

tooluniverse/data/zenodo_tools.json

@@ -1,82 +1,89 @@
 [
-    {
-        "type": "ZenodoTool",
-        "name": "Zenodo_search_records",
-        "description": "Search Zenodo for research data, publications, and datasets. Zenodo is an open-access repository that hosts research outputs from all fields of science, including papers, datasets, software, and more.",
-        "parameter": {
-            "type": "object",
-            "properties": {
-                "query": {
-                    "type": "string",
-                    "description": "Free text search query for Zenodo records. Use keywords to search across titles, descriptions, authors, and other metadata."
-                },
-                "max_results": {
-                    "type": "integer",
-                    "description": "Maximum number of results to return. Must be between 1 and 200.",
-                    "default": 10,
-                    "minimum": 1,
-                    "maximum": 200
-                },
-                "community": {
-                    "type": "string",
-                    "description": "Optional community slug to filter results by specific research community (e.g., 'zenodo', 'ecfunded')."
-                }
-            },
-            "required": ["query"]
+  {
+    "type": "ZenodoTool",
+    "name": "Zenodo_search_records",
+    "description": "Search Zenodo for research data, publications, and datasets. Zenodo is an open-access repository that hosts research outputs from all fields of science, including papers, datasets, software, and more.",
+    "parameter": {
+      "type": "object",
+      "properties": {
+        "query": {
+          "type": "string",
+          "description": "Free text search query for Zenodo records. Use keywords to search across titles, descriptions, authors, and other metadata."
+        },
+        "max_results": {
+          "type": "integer",
+          "description": "Maximum number of results to return. Must be between 1 and 200.",
+          "default": 10,
+          "minimum": 1,
+          "maximum": 200
         },
-        "return_schema": {
+        "community": {
+          "type": "string",
+          "description": "Optional community slug to filter results by specific research community (e.g., 'zenodo', 'ecfunded')."
+        }
+      },
+      "required": [
+        "query",
+        "max_results"
+      ]
+    },
+    "return_schema": {
+      "type": "array",
+      "description": "List of Zenodo records matching the search query",
+      "items": {
+        "type": "object",
+        "properties": {
+          "title": {
+            "type": "string",
+            "description": "Title of the record"
+          },
+          "authors": {
             "type": "array",
-            "description": "List of Zenodo records matching the search query",
             "items": {
-                "type": "object",
-                "properties": {
-                    "title": {
-                        "type": "string",
-                        "description": "Title of the record"
-                    },
-                    "authors": {
-                        "type": "array",
-                        "items": {"type": "string"},
-                        "description": "List of author/creator names"
-                    },
-                    "date": {
-                        "type": "string",
-                        "description": "Publication date"
-                    },
-                    "doi": {
-                        "type": "string",
-                        "description": "Digital Object Identifier (DOI)"
-                    },
-                    "url": {
-                        "type": "string",
-                        "description": "URL to the record on Zenodo"
-                    },
-                    "files": {
-                        "type": ["array", "string"],
-                        "description": "List of files or link to files associated with the record"
-                    },
-                    "source": {
-                        "type": "string",
-                        "description": "Source identifier (always 'Zenodo')"
-                    }
-                }
-            }
-        },
-        "test_examples": [
-            {
-                "query": "machine learning",
-                "max_results": 2
-            },
-            {
-                "query": "COVID-19",
-                "max_results": 1
+              "type": "string"
             },
-            {
-                "query": "climate change",
-                "max_results": 3,
-                "community": "zenodo"
-            }
-        ]
-    }
+            "description": "List of author/creator names"
+          },
+          "date": {
+            "type": "string",
+            "description": "Publication date"
+          },
+          "doi": {
+            "type": "string",
+            "description": "Digital Object Identifier (DOI)"
+          },
+          "url": {
+            "type": "string",
+            "description": "URL to the record on Zenodo"
+          },
+          "files": {
+            "type": [
+              "array",
+              "string"
+            ],
+            "description": "List of files or link to files associated with the record"
+          },
+          "source": {
+            "type": "string",
+            "description": "Source identifier (always 'Zenodo')"
+          }
+        }
+      }
+    },
+    "test_examples": [
+      {
+        "query": "machine learning",
+        "max_results": 2
+      },
+      {
+        "query": "COVID-19",
+        "max_results": 1
+      },
+      {
+        "query": "climate change",
+        "max_results": 3,
+        "community": "zenodo"
+      }
+    ]
+  }
 ]
-

tooluniverse/dblp_tool.py

@@ -48,14 +48,84 @@ class DBLPTool(BaseTool):
         results = []
         for hit in hits:
             info = hit.get("info", {})
+
+            # Extract title
+            title = info.get("title")
+
+            # Extract author information
+            authors = info.get("authors", {}).get("author", [])
+            if isinstance(authors, dict):
+                authors = [authors]
+
+            # Extract year
+            year = info.get("year")
+            if year and isinstance(year, str) and year.isdigit():
+                year = int(year)
+
+            # Extract journal/conference information
+            venue = info.get("venue")
+            if isinstance(venue, list):
+                venue = venue[0] if venue else None
+
+            # Extract URL
+            url = info.get("url")
+
+            # Extract electronic edition link
+            ee = info.get("ee")
+
+            # Extract DOI (from ee field)
+            doi = None
+            if ee and isinstance(ee, str) and "doi.org" in ee:
+                doi = ee
+
+            # Extract citation count (DBLP usually doesn't provide this)
+            citations = 0
+
+            # Open access status (DBLP usually doesn't provide this)
+            open_access = False
+
+            # Extract keywords (DBLP usually doesn't provide this)
+            keywords = []
+
+            # Extract article type
+            article_type = "conference-paper"  # DBLP is mainly conference papers
+
+            # Extract publisher
+            publisher = "Unknown"
+
+            # Handle missing abstract
+            abstract = (
+                "Abstract not available"  # DBLP usually doesn't provide abstracts
+            )
+
             results.append(
                 {
-                    "title": info.get("title"),
-                    "authors": info.get("authors", {}).get("author"),
-                    "year": info.get("year"),
-                    "venue": info.get("venue"),
-                    "url": info.get("url"),
-                    "ee": info.get("ee"),
+                    "title": title or "Title not available",
+                    "abstract": abstract,
+                    "authors": (
+                        authors if authors else "Author information not available"
+                    ),
+                    "year": year,
+                    "venue": venue or "Journal information not available",
+                    "url": url or "URL not available",
+                    "ee": ee or "Electronic edition not available",
+                    "doi": doi or "DOI not available",
+                    "citations": citations,
+                    "open_access": open_access,
+                    "keywords": keywords if keywords else "Keywords not available",
+                    "article_type": article_type,
+                    "publisher": publisher,
+                    "source": "DBLP",
+                    "data_quality": {
+                        "has_abstract": False,  # DBLP usually doesn't provide abstracts
+                        "has_authors": bool(authors),
+                        "has_journal": bool(venue),
+                        "has_year": bool(year),
+                        "has_doi": bool(doi),
+                        "has_citations": False,  # DBLP usually doesn't provide citation count
+                        "has_keywords": False,  # DBLP usually doesn't provide keywords
+                        "has_url": bool(url),
+                    },
                 }
             )
 

tooluniverse/dbsnp_tool.py

@@ -0,0 +1,71 @@
+import requests
+from .base_tool import BaseTool
+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.
+    """
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+        self.base = "https://api.ncbi.nlm.nih.gov/variation/v0"
+        self.session = requests.Session()
+
+    def run(self, arguments):
+        rsid = arguments.get("rsid")
+        if not rsid:
+            return {"error": "Missing required parameter: rsid"}
+
+        # Clean rsid (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,
+        }

tooluniverse/default_config.py

@@ -51,6 +51,9 @@ 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"),
+    "drug_discovery_agents": os.path.join(
+        current_dir, "data", "drug_discovery_agents.json"
+    ),
     "dataset": os.path.join(current_dir, "data", "dataset_tools.json"),
     # 'mcp_clients': os.path.join(current_dir, 'data', 'mcp_client_tools_example.json'),
     "mcp_auto_loader_txagent": os.path.join(
@@ -66,6 +69,7 @@ default_tool_files = {
     "pubchem": os.path.join(current_dir, "data", "pubchem_tools.json"),
     "medlineplus": os.path.join(current_dir, "data", "medlineplus_tools.json"),
     "uniprot": os.path.join(current_dir, "data", "uniprot_tools.json"),
+    "cellosaurus": os.path.join(current_dir, "data", "cellosaurus_tools.json"),
     # 'software': os.path.join(current_dir, 'data', 'software_tools.json'),
     # Package tools - categorized software tools
     "software_bioinformatics": os.path.join(
@@ -89,6 +93,16 @@ default_tool_files = {
     "software_visualization": os.path.join(
         current_dir, "data", "packages", "visualization_tools.json"
     ),
+    # Scientific visualization tools
+    "visualization_protein_3d": os.path.join(
+        current_dir, "data", "protein_structure_3d_tools.json"
+    ),
+    "visualization_molecule_2d": os.path.join(
+        current_dir, "data", "molecule_2d_tools.json"
+    ),
+    "visualization_molecule_3d": os.path.join(
+        current_dir, "data", "molecule_3d_tools.json"
+    ),
     "software_scientific_computing": os.path.join(
         current_dir, "data", "packages", "scientific_computing_tools.json"
     ),
@@ -131,6 +145,11 @@ default_tool_files = {
         current_dir, "data", "output_summarization_tools.json"
     ),
     "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"),
 }
 
 

tooluniverse/doaj_tool.py

@@ -52,39 +52,100 @@ class DOAJTool(BaseTool):
             for r in results:
                 b = r.get("bibjson", {})
                 title = b.get("title")
+
+                # Extract year
                 year = None
                 try:
                     year = int((b.get("year") or 0))
                 except Exception:
                     year = b.get("year")
-                authors = [
-                    a.get("name")
-                    for a in b.get("author", [])
-                    if a.get("name")
-                ]
+
+                # Extract author information
+                authors = [a.get("name") for a in b.get("author", []) if a.get("name")]
+
+                # Extract DOI
                 doi = None
                 for i in b.get("identifier", []):
                     if i.get("type") == "doi":
                         doi = i.get("id")
                         break
+
+                # Extract URL
                 url = None
                 for link_item in b.get("link", []):
-                    if (
-                        link_item.get("type") == "fulltext"
-                        or link_item.get("url")
-                    ):
+                    if link_item.get("type") == "fulltext" or link_item.get("url"):
                         url = link_item.get("url")
                         break
+
+                # Extract journal information
                 journal = (b.get("journal") or {}).get("title")
+
+                # Extract abstract
+                abstract = b.get("abstract")
+                if abstract and isinstance(abstract, str):
+                    # Clean HTML tags
+                    import re
+
+                    abstract = re.sub(r"<[^>]+>", "", abstract)
+                    abstract = abstract.strip()
+
+                # Extract keywords
+                keywords = []
+                subject_list = b.get("subject", [])
+                if isinstance(subject_list, list):
+                    for subject in subject_list:
+                        if isinstance(subject, dict):
+                            term = subject.get("term", "")
+                            if term:
+                                keywords.append(term)
+                        elif isinstance(subject, str):
+                            keywords.append(subject)
+
+                # Extract citation count (DOAJ usually doesn't provide this)
+                citations = 0
+
+                # Open access status (DOAJ is all open access)
+                open_access = True
+
+                # Extract article type
+                article_type = b.get("type", "journal-article")
+
+                # Extract publisher
+                publisher = (b.get("journal") or {}).get("publisher")
+
+                # Handle missing abstract
+                if not abstract:
+                    abstract = "Abstract not available"
+
                 items.append(
                     {
-                        "title": title,
-                        "authors": authors,
+                        "title": title or "Title not available",
+                        "abstract": abstract,
+                        "authors": (
+                            authors if authors else "Author information not available"
+                        ),
                         "year": year,
-                        "doi": doi,
-                        "venue": journal,
-                        "url": url,
+                        "doi": doi or "DOI not available",
+                        "venue": journal or "Journal information not available",
+                        "url": url or "URL not available",
+                        "citations": citations,
+                        "open_access": open_access,
+                        "keywords": keywords if keywords else "Keywords not available",
+                        "article_type": article_type,
+                        "publisher": publisher or "Publisher information not available",
                         "source": "DOAJ",
+                        "data_quality": {
+                            "has_abstract": bool(
+                                abstract and abstract != "Abstract not available"
+                            ),
+                            "has_authors": bool(authors),
+                            "has_journal": bool(journal),
+                            "has_year": bool(year),
+                            "has_doi": bool(doi),
+                            "has_citations": False,  # DOAJ usually doesn't provide citation count
+                            "has_keywords": bool(keywords),
+                            "has_url": bool(url),
+                        },
                     }
                 )
         else:
@@ -105,9 +166,7 @@ class DOAJTool(BaseTool):
                         homepage_url = link_item.get("url")
                         break
                 subjects = [
-                    s.get("term")
-                    for s in b.get("subject", [])
-                    if s.get("term")
+                    s.get("term") for s in b.get("subject", []) if s.get("term")
                 ]
                 items.append(
                     {

tooluniverse/doctor.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python3
+"""ToolUniverse health checker."""
+
+
+def main():
+    print("🔍 Checking ToolUniverse health...\n")
+
+    try:
+        from tooluniverse import ToolUniverse
+
+        tu = ToolUniverse()
+        # Load tools to get actual tool counts
+        tu.load_tools()
+        health = tu.get_tool_health()
+    except Exception as e:
+        print(f"❌ Failed to initialize ToolUniverse: {e}")
+        return 1
+
+    print(f"📊 Total tools: {health['total']}")
+    print(f"✅ Available: {health['available']}")
+    print(f"❌ Unavailable: {health['unavailable']}\n")
+
+    if health["unavailable"] == 0:
+        print("🎉 All tools loaded successfully!")
+        return 0
+
+    print("⚠️  Unavailable tools:\n")
+
+    packages = set()
+    for tool_name in health["unavailable_list"]:
+        details = health["details"].get(tool_name, {})
+        print(f"  ❌ {tool_name}")
+        print(f"     Error: {details.get('error', 'Unknown')[:80]}")
+        if details.get("missing_package"):
+            pkg = details["missing_package"]
+            print(f"     Fix: pip install {pkg}")
+            packages.add(pkg)
+        print()
+
+    if packages:
+        print("💡 Bulk fix command:")
+        print(f"   pip install {' '.join(sorted(packages))}")
+
+    return 0
+
+
+if __name__ == "__main__":
+    exit(main())

tooluniverse/ensembl_tool.py

@@ -0,0 +1,61 @@
+import requests
+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.
+    """
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+        self.base = "https://rest.ensembl.org"
+        self.session = requests.Session()
+        self.session.headers.update(
+            {"Accept": "application/json", "Content-Type": "application/json"}
+        )
+
+    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")
+        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),
+        }