tooluniverse 1.0.5__py3-none-any.whl → 1.0.7__py3-none-any.whl

tooluniverse/data/zenodo_tools.json

@@ -0,0 +1,90 @@
+[
+  {
+    "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",
+        "max_results",
+        "community"
+      ]
+    },
+    "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",
+            "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
+      },
+      {
+        "query": "climate change",
+        "max_results": 3,
+        "community": "zenodo"
+      }
+    ]
+  }
+]

tooluniverse/dblp_tool.py

@@ -0,0 +1,132 @@
+import requests
+from .base_tool import BaseTool
+from .tool_registry import register_tool
+
+
+@register_tool("DBLPTool")
+class DBLPTool(BaseTool):
+    """
+    Search DBLP Computer Science Bibliography for publications.
+    """
+
+    def __init__(
+        self,
+        tool_config,
+        base_url="https://dblp.org/search/publ/api",
+    ):
+        super().__init__(tool_config)
+        self.base_url = base_url
+
+    def run(self, arguments):
+        query = arguments.get("query")
+        limit = int(arguments.get("limit", 10))
+        if not query:
+            return {"error": "`query` parameter is required."}
+        return self._search(query, limit)
+
+    def _search(self, query, limit):
+        params = {
+            "q": query,
+            "h": max(1, min(limit, 100)),
+            "format": "json",
+        }
+        try:
+            response = requests.get(self.base_url, params=params, timeout=20)
+        except requests.RequestException as e:
+            return {
+                "error": "Network error calling DBLP API",
+                "reason": str(e),
+            }
+
+        if response.status_code != 200:
+            return {
+                "error": f"DBLP API error {response.status_code}",
+                "reason": response.reason,
+            }
+
+        hits = response.json().get("result", {}).get("hits", {}).get("hit", [])
+        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": 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),
+                    },
+                }
+            )
+
+        return results

tooluniverse/default_config.py

@@ -33,6 +33,23 @@ default_tool_files = {
     "Enrichr": os.path.join(current_dir, "data", "enrichr_tools.json"),
     "HumanBase": os.path.join(current_dir, "data", "humanbase_tools.json"),
     "OpenAlex": os.path.join(current_dir, "data", "openalex_tools.json"),
+    # Literature search tools
+    "arxiv": os.path.join(current_dir, "data", "arxiv_tools.json"),
+    "crossref": os.path.join(current_dir, "data", "crossref_tools.json"),
+    "dblp": os.path.join(current_dir, "data", "dblp_tools.json"),
+    "pubmed": os.path.join(current_dir, "data", "pubmed_tools.json"),
+    "doaj": os.path.join(current_dir, "data", "doaj_tools.json"),
+    "unpaywall": os.path.join(current_dir, "data", "unpaywall_tools.json"),
+    "biorxiv": os.path.join(current_dir, "data", "biorxiv_tools.json"),
+    "medrxiv": os.path.join(current_dir, "data", "medrxiv_tools.json"),
+    "hal": os.path.join(current_dir, "data", "hal_tools.json"),
+    "core": os.path.join(current_dir, "data", "core_tools.json"),
+    "pmc": os.path.join(current_dir, "data", "pmc_tools.json"),
+    "zenodo": os.path.join(current_dir, "data", "zenodo_tools.json"),
+    "openaire": os.path.join(current_dir, "data", "openaire_tools.json"),
+    "osf_preprints": os.path.join(current_dir, "data", "osf_preprints_tools.json"),
+    "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"),
     "dataset": os.path.join(current_dir, "data", "dataset_tools.json"),
     # 'mcp_clients': os.path.join(current_dir, 'data', 'mcp_client_tools_example.json'),
@@ -49,6 +66,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(
@@ -72,6 +90,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"
     ),
@@ -114,6 +142,8 @@ default_tool_files = {
         current_dir, "data", "output_summarization_tools.json"
     ),
     "odphp": os.path.join(current_dir, "data", "odphp_tools.json"),
+    # Guideline and health policy tools
+    "guidelines": os.path.join(current_dir, "data", "unified_guideline_tools.json"),
 }
 
 

tooluniverse/doaj_tool.py

@@ -0,0 +1,183 @@
+import requests
+from .base_tool import BaseTool
+from .tool_registry import register_tool
+
+
+@register_tool("DOAJTool")
+class DOAJTool(BaseTool):
+    """
+    Search DOAJ (Directory of Open Access Journals) articles and journals.
+
+    Parameters (arguments):
+        query (str): Query string (Lucene syntax supported by DOAJ)
+        max_results (int): Max number of results (default 10, max 100)
+        type (str): "articles" or "journals" (default: "articles")
+    """
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+        self.base_url = "https://doaj.org/api/search"
+
+    def run(self, arguments=None):
+        arguments = arguments or {}
+        query = arguments.get("query")
+        search_type = arguments.get("type", "articles")
+        max_results = int(arguments.get("max_results", 10))
+
+        if not query:
+            return {"error": "`query` parameter is required."}
+
+        if search_type not in ["articles", "journals"]:
+            return {"error": "`type` must be 'articles' or 'journals'."}
+
+        endpoint = f"{self.base_url}/{search_type}/{query}"
+        params = {
+            "pageSize": max(1, min(max_results, 100)),
+        }
+        try:
+            resp = requests.get(endpoint, params=params, timeout=20)
+            resp.raise_for_status()
+            data = resp.json()
+        except requests.RequestException as e:
+            return {
+                "error": "Network/API error calling DOAJ",
+                "reason": str(e),
+            }
+        except ValueError:
+            return {"error": "Failed to decode DOAJ response as JSON"}
+
+        results = data.get("results", [])
+        items = []
+        if search_type == "articles":
+            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")
+
+                # 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"):
+                        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 or "Title not available",
+                        "abstract": abstract,
+                        "authors": (
+                            authors if authors else "Author information not available"
+                        ),
+                        "year": year,
+                        "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:
+            for r in results:
+                b = r.get("bibjson", {})
+                title = b.get("title")
+                publisher = b.get("publisher")
+                eissn = None
+                pissn = None
+                for i in b.get("identifier", []):
+                    if i.get("type") == "eissn":
+                        eissn = i.get("id")
+                    if i.get("type") == "pissn":
+                        pissn = i.get("id")
+                homepage_url = None
+                for link_item in b.get("link", []):
+                    if link_item.get("url"):
+                        homepage_url = link_item.get("url")
+                        break
+                subjects = [
+                    s.get("term") for s in b.get("subject", []) if s.get("term")
+                ]
+                items.append(
+                    {
+                        "title": title,
+                        "publisher": publisher,
+                        "eissn": eissn,
+                        "pissn": pissn,
+                        "subjects": subjects,
+                        "url": homepage_url,
+                        "source": "DOAJ",
+                    }
+                )
+
+        return items

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

@@ -25,28 +25,143 @@ class EuropePMCTool(BaseTool):
         return self._search(query, limit)
 
     def _search(self, query, limit):
-        params = {
+        # First try core mode to get abstracts
+        core_params = {
             "query": query,
-            "resultType": "core",  # 'core' includes abstractText
+            "resultType": "core",
             "pageSize": limit,
             "format": "json",
         }
-        response = requests.get(self.base_url, params=params, timeout=20)
-        if response.status_code != 200:
+        core_response = requests.get(self.base_url, params=core_params, timeout=20)
+
+        # Then try lite mode to get journal information
+        lite_params = {
+            "query": query,
+            "resultType": "lite",
+            "pageSize": limit,
+            "format": "json",
+        }
+        lite_response = requests.get(self.base_url, params=lite_params, timeout=20)
+
+        if core_response.status_code != 200:
             return {
-                "error": f"Europe PMC API error {response.status_code}",
-                "reason": response.reason,
+                "error": f"Europe PMC API error {core_response.status_code}",
+                "reason": core_response.reason,
             }
 
-        results = response.json().get("resultList", {}).get("result", [])
-        articles = [
-            {
-                "title": rec.get("title"),
-                "abstract": rec.get("abstractText"),
-                "journal": rec.get("journalTitle"),
-                "year": rec.get("pubYear"),
-                "url": f"https://europepmc.org/article/{rec.get('source')}/{rec.get('id')}",
-            }
-            for rec in results
-        ]
+        # Get core mode results
+        core_results = core_response.json().get("resultList", {}).get("result", [])
+        lite_results = []
+
+        # If lite mode also succeeds, get journal information
+        if lite_response.status_code == 200:
+            lite_results = lite_response.json().get("resultList", {}).get("result", [])
+
+        # Create ID to record mapping
+        lite_map = {rec.get("id"): rec for rec in lite_results}
+
+        articles = []
+        for rec in core_results:
+            # Extract basic information
+            title = rec.get("title")
+            abstract = rec.get("abstractText")
+            year = rec.get("pubYear")
+
+            # Extract author information
+            authors = []
+            author_list = rec.get("authorList", {}).get("author", [])
+            if isinstance(author_list, list):
+                for author in author_list:
+                    if isinstance(author, dict):
+                        full_name = author.get("fullName", "")
+                        if full_name:
+                            authors.append(full_name)
+            elif isinstance(author_list, dict):
+                full_name = author_list.get("fullName", "")
+                if full_name:
+                    authors.append(full_name)
+
+            # Get journal information from lite mode
+            journal = None
+            if rec.get("id") in lite_map:
+                lite_rec = lite_map[rec["id"]]
+                journal = lite_rec.get("journalTitle")
+
+            # If still no journal information, use source field
+            if not journal:
+                journal = rec.get("source")
+
+            # Extract DOI
+            doi = rec.get("doi", "")
+
+            # Extract citation count
+            citations = rec.get("citedByCount", 0)
+            if citations:
+                try:
+                    citations = int(citations)
+                except (ValueError, TypeError):
+                    citations = 0
+
+            # Extract open access status
+            open_access = rec.get("isOpenAccess", False)
+
+            # Extract keywords
+            keywords = []
+            text_mined_terms = rec.get("hasTextMinedTerms", {})
+            if text_mined_terms and isinstance(text_mined_terms, dict):
+                # Try to extract keywords
+                for _key, value in text_mined_terms.items():
+                    if isinstance(value, list):
+                        keywords.extend(value)
+                    elif isinstance(value, str):
+                        keywords.append(value)
+
+            # Handle missing abstract
+            if not abstract:
+                abstract = "Abstract not available"
+
+            # Handle missing journal information
+            if not journal:
+                journal = "Journal information not available"
+
+            # Build URL
+            source = rec.get("source", "")
+            article_id = rec.get("id", "")
+            url = (
+                f"https://europepmc.org/article/{source}/{article_id}"
+                if source and article_id
+                else "URL not available"
+            )
+
+            articles.append(
+                {
+                    "title": title or "Title not available",
+                    "abstract": abstract,
+                    "authors": (
+                        authors if authors else "Author information not available"
+                    ),
+                    "journal": journal,
+                    "year": year,
+                    "doi": doi or "DOI not available",
+                    "url": url,
+                    "citations": citations,
+                    "open_access": open_access,
+                    "keywords": keywords if keywords else "Keywords not available",
+                    "source": "Europe PMC",
+                    "data_quality": {
+                        "has_abstract": bool(
+                            abstract and abstract != "Abstract not available"
+                        ),
+                        "has_authors": bool(authors),
+                        "has_journal": bool(
+                            journal and journal != "Journal information not available"
+                        ),
+                        "has_year": bool(year),
+                        "has_doi": bool(doi),
+                        "has_citations": bool(citations and citations > 0),
+                        "has_keywords": bool(keywords),
+                        "has_url": bool(url and url != "URL not available"),
+                    },
+                }
+            )
         return articles