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

tooluniverse/odphp_tool.py

@@ -0,0 +1,226 @@
+import re
+import requests
+from typing import Dict, Any, Optional, List
+from .base_tool import BaseTool
+from .tool_registry import register_tool
+
+# Optional but recommended: text extraction for HTML
+try:
+    from bs4 import BeautifulSoup  # pip install beautifulsoup4
+except ImportError:
+    BeautifulSoup = None  # We’ll guard uses so the tool still loads
+
+ODPHP_BASE_URL = "https://odphp.health.gov/myhealthfinder/api/v4"
+
+
+class ODPHPRESTTool(BaseTool):
+    """Base class for ODPHP (MyHealthfinder) REST API tools."""
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+        self.endpoint = tool_config["fields"]["endpoint"]
+
+    def _make_request(self, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        url = f"{ODPHP_BASE_URL}{self.endpoint}"
+        try:
+            resp = requests.get(url, params=params, timeout=30)
+            resp.raise_for_status()
+            data = resp.json()
+            return {
+                "data": data.get("Result"),
+                "metadata": {
+                    "source": "ODPHP MyHealthfinder",
+                    "endpoint": url,
+                    "query": params,
+                },
+            }
+        except requests.exceptions.RequestException as e:
+            return {"error": f"Request failed: {str(e)}"}
+        except ValueError as e:
+            return {"error": f"Failed to parse JSON: {str(e)}"}
+
+
+def _sections_array(resource: Dict[str, Any]) -> List[Dict[str, Any]]:
+    """
+    Tolerant accessor for the sections array.
+    Data sometimes uses Sections.Section (capital S) and sometimes Sections.section (lowercase).
+    """
+    sect = resource.get("Sections") or {}
+    arr = sect.get("Section")
+    if not isinstance(arr, list):
+        arr = sect.get("section")
+    return arr if isinstance(arr, list) else []
+
+
+def _strip_html_to_text(html: str) -> str:
+    if not html:
+        return ""
+    if BeautifulSoup is None:
+        # fallback: very light tag remover
+        text = re.sub(r"<[^>]+>", " ", html)
+        return re.sub(r"\s+", " ", text).strip()
+    soup = BeautifulSoup(html, "html.parser")
+    # remove scripts/styles
+    for t in soup(["script", "style", "noscript"]):
+        t.decompose()
+    text = soup.get_text("\n", strip=True)
+    text = re.sub(r"\n{2,}", "\n\n", text)
+    return text.strip()
+
+
+@register_tool("ODPHPMyHealthfinder")
+class ODPHPMyHealthfinder(ODPHPRESTTool):
+    """Search for demographic-specific health recommendations (MyHealthfinder)."""
+
+    def run(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        params: Dict[str, Any] = {}
+        if "lang" in arguments:
+            params["lang"] = arguments["lang"]
+        if "age" in arguments:
+            params["age"] = arguments["age"]
+        if "sex" in arguments:
+            params["sex"] = arguments["sex"]
+        if "pregnant" in arguments:
+            params["pregnant"] = arguments["pregnant"]
+
+        res = self._make_request(params)
+
+        # Optional: attach PlainSections if requested
+        if isinstance(res, dict) and not res.get("error") and arguments.get("strip_html"):
+            data = res.get("data") or {}
+            resources = (((data.get("Resources") or {}).get("All") or {}).get("Resource")) or []
+            if isinstance(resources, list):
+                for r in resources:
+                    plain = []
+                    for sec in _sections_array(r):
+                        plain.append({
+                            "Title": sec.get("Title", ""),
+                            "PlainContent": _strip_html_to_text(sec.get("Content", "")),
+                        })
+                    if plain:
+                        r["PlainSections"] = plain
+        return res
+
+
+@register_tool("ODPHPItemList")
+class ODPHPItemList(ODPHPRESTTool):
+    """Retrieve list of topics or categories."""
+
+    def run(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        params: Dict[str, Any] = {}
+        if "lang" in arguments:
+            params["lang"] = arguments["lang"]
+        if "type" in arguments:
+            params["type"] = arguments["type"]
+        return self._make_request(params)
+
+
+@register_tool("ODPHPTopicSearch")
+class ODPHPTopicSearch(ODPHPRESTTool):
+    """Search for health topics by ID, category, or keyword."""
+
+    def run(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        params: Dict[str, Any] = {}
+        if "lang" in arguments:
+            params["lang"] = arguments["lang"]
+        if "topicId" in arguments:
+            params["topicId"] = arguments["topicId"]
+        if "categoryId" in arguments:
+            params["categoryId"] = arguments["categoryId"]
+        if "keyword" in arguments:
+            params["keyword"] = arguments["keyword"]
+
+        res = self._make_request(params)
+
+        # Optional: attach PlainSections if requested
+        if isinstance(res, dict) and not res.get("error") and arguments.get("strip_html"):
+            data = res.get("data") or {}
+            resources = ((data.get("Resources") or {}).get("Resource")) or []
+            if isinstance(resources, list):
+                for r in resources:
+                    plain = []
+                    for sec in _sections_array(r):
+                        plain.append({
+                            "Title": sec.get("Title", ""),
+                            "PlainContent": _strip_html_to_text(sec.get("Content", "")),
+                        })
+                    if plain:
+                        r["PlainSections"] = plain
+        return res
+
+
+@register_tool("ODPHPOutlinkFetch")
+class ODPHPOutlinkFetch(BaseTool):
+    """
+    Fetch article pages referenced by AccessibleVersion / RelatedItems.Url and return readable text.
+    - HTML: extracts main/article/body text; strips nav/aside/footer/script/style.
+    - PDF or non-HTML: returns metadata + URL so the agent can surface it.
+    """
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+        self.timeout = 30
+
+    def _extract_text(self, html: str) -> Dict[str, str]:
+        if BeautifulSoup is None:
+            # fallback: crude extraction
+            title = ""
+            # attempt to find <title>
+            m = re.search(r"<title[^>]*>(.*?)</title>", html, flags=re.I | re.S)
+            if m:
+                title = re.sub(r"\s+", " ", m.group(1)).strip()
+            text = re.sub(r"<[^>]+>", " ", html)
+            text = re.sub(r"\s+", " ", text).strip()
+            return {"title": title, "text": text}
+
+        soup = BeautifulSoup(html, "html.parser")
+        # remove non-content
+        for tag in soup(["script", "style", "noscript", "footer", "nav", "aside"]):
+            tag.decompose()
+
+        candidate = soup.find("main") or soup.find("article") or soup.body or soup
+        title = ""
+        # prefer main/article heading, else <title>
+        h = candidate.find(["h1", "h2"]) if candidate else None
+        if h:
+            title = h.get_text(" ", strip=True)
+        elif soup.title and soup.title.string:
+            title = soup.title.string.strip()
+
+        text = candidate.get_text("\n", strip=True) if candidate else soup.get_text("\n", strip=True)
+        text = re.sub(r"\n{2,}", "\n\n", text)
+        return {"title": title, "text": text}
+
+    def run(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        urls: List[str] = arguments.get("urls", [])
+        max_chars: Optional[int] = arguments.get("max_chars")
+        return_html: bool = bool(arguments.get("return_html", False))
+
+        if not urls or not isinstance(urls, list):
+            return {"error": "Missing required parameter 'urls' (array of 1–3 URLs)."}
+
+        out: List[Dict[str, Any]] = []
+        for u in urls[:3]:
+            try:
+                resp = requests.get(u, timeout=self.timeout, allow_redirects=True)
+                ct = resp.headers.get("Content-Type", "")
+                item: Dict[str, Any] = {"url": u, "status": resp.status_code, "content_type": ct}
+
+                if "text/html" in ct or (not ct and resp.text.startswith("<!")):
+                    ex = self._extract_text(resp.text)
+                    if isinstance(max_chars, int) and max_chars > 0:
+                        ex["text"] = ex["text"][:max_chars]
+                    item.update(ex)
+                    if return_html:
+                        item["html"] = resp.text
+                elif "pdf" in ct or u.lower().endswith(".pdf"):
+                    item["title"] = "(PDF Document)"
+                    item["text"] = f"[PDF file: {u}]"
+                else:
+                    item["title"] = ""
+                    item["text"] = ""
+                out.append(item)
+            except requests.exceptions.RequestException as e:
+                out.append({"url": u, "status": 0, "content_type": "", "title": "", "text": "", "error": str(e)})
+
+        return {"results": out, "metadata": {"source": "ODPHP OutlinkFetch"}}

tooluniverse/openaire_tool.py

@@ -0,0 +1,145 @@
+import requests
+from .base_tool import BaseTool
+from .tool_registry import register_tool
+
+
+@register_tool("OpenAIRETool")
+class OpenAIRETool(BaseTool):
+    """
+    Search OpenAIRE Explore for research products (publications by default).
+
+    Parameters (arguments):
+        query (str): Query string
+        max_results (int): Max number of results (default 10, max 100)
+        type (str): product type filter: publications | datasets | software
+    """
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+        self.base_url = "https://api.openaire.eu/search/publications"
+
+    def run(self, arguments=None):
+        arguments = arguments or {}
+        query = arguments.get("query")
+        max_results = int(arguments.get("max_results", 10))
+        prod_type = arguments.get("type", "publications")
+
+        if not query:
+            return {"error": "`query` parameter is required."}
+
+        endpoint = self._endpoint_for_type(prod_type)
+        if endpoint is None:
+            return {
+                "error": (
+                    "Unsupported type. Use publications/datasets/software."
+                ),
+            }
+
+        params = {
+            "format": "json",
+            "size": max(1, min(max_results, 100)),
+            "query": query,
+        }
+        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 OpenAIRE",
+                "reason": str(e),
+            }
+        except ValueError:
+            return {"error": "Failed to decode OpenAIRE response as JSON"}
+
+        return self._normalize(data, prod_type)
+
+    def _endpoint_for_type(self, prod_type):
+        if prod_type == "publications":
+            return "https://api.openaire.eu/search/publications"
+        if prod_type == "datasets":
+            return "https://api.openaire.eu/search/datasets"
+        if prod_type == "software":
+            return "https://api.openaire.eu/search/software"
+        return None
+
+    def _normalize(self, data, prod_type):
+        results = []
+        # OpenAIRE JSON has a root 'response' with 'results' → 'result' list
+        try:
+            items = (
+                data.get("response", {})
+                .get("results", {})
+                .get("result", [])
+            )
+        except Exception:
+            items = []
+
+        for it in items:
+            # header may contain identifiers, not used presently
+            _ = (
+                it.get("header", {})
+                if isinstance(it.get("header"), dict)
+                else {}
+            )
+            metadata = (
+                it.get("metadata", {})
+                if isinstance(it.get("metadata"), dict)
+                else {}
+            )
+            title = None
+            authors = []
+            year = None
+            doi = None
+            url = None
+
+            # Titles can be nested in 'oaf:result' structure
+            result_obj = metadata.get("oaf:result", {})
+            if isinstance(result_obj, dict):
+                t = result_obj.get("title")
+                if isinstance(t, list) and t:
+                    title = t[0].get("$")
+                elif isinstance(t, dict):
+                    title = t.get("$")
+
+                # Authors
+                creators = result_obj.get("creator", [])
+                if isinstance(creators, list):
+                    for c in creators:
+                        name = c.get("$")
+                        if name:
+                            authors.append(name)
+
+                # Year
+                date_obj = (
+                    result_obj.get("dateofacceptance")
+                    or result_obj.get("date")
+                )
+                if isinstance(date_obj, dict):
+                    year = date_obj.get("year") or date_obj.get("$")
+
+                # DOI and URL
+                pid = result_obj.get("pid", [])
+                if isinstance(pid, list):
+                    for p in pid:
+                        if p.get("@classid") == "doi":
+                            doi = p.get("$")
+                bestaccessright = result_obj.get("bestaccessright", {})
+                if isinstance(bestaccessright, dict):
+                    url_value = bestaccessright.get("$")
+                    if url_value:
+                        url = url_value
+
+            results.append(
+                {
+                    "title": title,
+                    "authors": authors,
+                    "year": year,
+                    "doi": doi,
+                    "url": url,
+                    "type": prod_type,
+                    "source": "OpenAIRE",
+                }
+            )
+
+        return results

tooluniverse/osf_preprints_tool.py

@@ -0,0 +1,67 @@
+import requests
+from .base_tool import BaseTool
+from .tool_registry import register_tool
+
+
+@register_tool("OSFPreprintsTool")
+class OSFPreprintsTool(BaseTool):
+    """
+    Search OSF Preprints via OSF API v2 filters.
+
+    Parameters (arguments):
+        query (str): Query string
+        max_results (int): Max results (default 10, max 100)
+        provider (str): Optional preprint provider (e.g., 'osf', 'psyarxiv')
+    """
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+        self.base_url = "https://api.osf.io/v2/preprints/"
+
+    def run(self, arguments=None):
+        arguments = arguments or {}
+        query = arguments.get("query")
+        max_results = int(arguments.get("max_results", 10))
+        provider = arguments.get("provider")
+
+        if not query:
+            return {"error": "`query` parameter is required."}
+
+        params = {
+            "page[size]": max(1, min(max_results, 100)),
+            "filter[title]": query,
+        }
+        if provider:
+            params["filter[provider]"] = provider
+
+        try:
+            resp = requests.get(self.base_url, params=params, timeout=20)
+            resp.raise_for_status()
+            data = resp.json()
+        except requests.RequestException as e:
+            return {"error": "Network/API error calling OSF", "reason": str(e)}
+        except ValueError:
+            return {"error": "Failed to decode OSF response as JSON"}
+
+        results = []
+        for item in data.get("data", []):
+            attrs = item.get("attributes", {})
+            title = attrs.get("title")
+            date_published = attrs.get("date_published")
+            is_published = attrs.get("is_published")
+            doi = attrs.get("doi")
+            links_obj = item.get("links", {})
+            url = links_obj.get("html") or links_obj.get("self")
+
+            results.append(
+                {
+                    "title": title,
+                    "date_published": date_published,
+                    "published": is_published,
+                    "doi": doi,
+                    "url": url,
+                    "source": "OSF Preprints",
+                }
+            )
+
+        return results

tooluniverse/pmc_tool.py

@@ -0,0 +1,181 @@
+#!/usr/bin/env python3
+"""
+PMC (PubMed Central) Tool for searching full-text biomedical literature.
+
+PMC is the free full-text archive of biomedical and life sciences journal
+literature at the U.S. National Institutes of Health's National Library of
+Medicine. This tool provides access to millions of full-text articles.
+"""
+
+import requests
+from typing import Dict, List, Any, Optional
+from .base_tool import BaseTool
+from .tool_registry import register_tool
+
+
+@register_tool("PMCTool")
+class PMCTool(BaseTool):
+    """Tool for searching PMC full-text biomedical literature."""
+
+    def __init__(self, tool_config=None):
+        super().__init__(tool_config)
+        self.base_url = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils"
+        self.session = requests.Session()
+        self.session.headers.update({
+            'User-Agent': 'ToolUniverse/1.0',
+            'Accept': 'application/json'
+        })
+
+    def _search(self, query: str, limit: int = 10,
+                date_from: Optional[str] = None,
+                date_to: Optional[str] = None,
+                article_type: Optional[str] = None) -> List[Dict[str, Any]]:
+        """
+        Search for papers using PMC API.
+
+        Args:
+            query: Search query
+            limit: Maximum number of results
+            date_from: Start date filter (YYYY/MM/DD)
+            date_to: End date filter (YYYY/MM/DD)
+            article_type: Article type filter (e.g., 'research-article', 'review')
+
+        Returns:
+            List of paper dictionaries
+        """
+        try:
+            # Step 1: Search PMC for article IDs
+            search_params = {
+                'db': 'pmc',
+                'term': query,
+                'retmax': min(limit, 100),  # NCBI API max limit
+                'retmode': 'json',
+                'sort': 'relevance'
+            }
+
+            # Add date filters if provided
+            if date_from or date_to:
+                date_filter = []
+                if date_from:
+                    date_filter.append(
+                        f"({date_from}[PDAT]:{date_to or '3000/12/31'}[PDAT])"
+                    )
+                else:
+                    date_filter.append(f"(:{date_to}[PDAT])")
+                search_params['term'] += f" AND {' '.join(date_filter)}"
+
+            # Add article type filter if provided
+            if article_type:
+                search_params['term'] += f" AND {article_type}[PT]"
+
+            # Make search request
+            search_response = self.session.get(
+                f"{self.base_url}/esearch.fcgi",
+                params=search_params,
+                timeout=30
+            )
+            search_response.raise_for_status()
+
+            search_data = search_response.json()
+            pmc_ids = search_data.get('esearchresult', {}).get('idlist', [])
+
+            if not pmc_ids:
+                return []
+
+            # Step 2: Get detailed information for each article
+            summary_params = {
+                'db': 'pmc',
+                'id': ','.join(pmc_ids),
+                'retmode': 'json'
+            }
+
+            summary_response = self.session.get(
+                f"{self.base_url}/esummary.fcgi",
+                params=summary_params,
+                timeout=30
+            )
+            summary_response.raise_for_status()
+
+            summary_data = summary_response.json()
+            results = []
+
+            # Parse results
+            for pmc_id in pmc_ids:
+                article_data = summary_data.get('result', {}).get(pmc_id, {})
+
+                paper = {
+                    'title': article_data.get('title', 'No title'),
+                    'abstract': article_data.get('abstract', 'No abstract available'),
+                    'authors': self._extract_authors(article_data.get('authors', [])),
+                    'year': self._extract_year(article_data.get('pubdate')),
+                    'pmc_id': pmc_id,
+                    'pmid': article_data.get('pmid'),
+                    'doi': article_data.get('elocationid'),
+                    'url': f"https://www.ncbi.nlm.nih.gov/pmc/articles/{pmc_id}/",
+                    'venue': article_data.get('source'),
+                    'open_access': True,  # PMC only contains open access articles
+                    'source': 'PMC',
+                    'article_type': (article_data.get('pubtype', ['Unknown'])[0]
+                                     if article_data.get('pubtype') else 'Unknown'),
+                    'citations': article_data.get('pmcrefcount', 0)
+                }
+                results.append(paper)
+
+            return results
+
+        except requests.exceptions.RequestException as e:
+            return [{'error': f'PMC API request failed: {str(e)}'}]
+        except Exception as e:
+            return [{'error': f'PMC API error: {str(e)}'}]
+
+    def _extract_authors(self, authors: List[Dict]) -> List[str]:
+        """Extract author names from PMC API response."""
+        if not authors:
+            return []
+
+        author_names = []
+        for author in authors:
+            name = author.get('name', '')
+            if name:
+                author_names.append(name)
+
+        return author_names
+
+    def _extract_year(self, pubdate: str) -> str:
+        """Extract year from publication date."""
+        if not pubdate:
+            return 'Unknown'
+
+        try:
+            # PMC API returns dates in various formats
+            # Extract year from the beginning of the string
+            return pubdate[:4]
+        except Exception:
+            return 'Unknown'
+
+    def run(self, tool_arguments) -> List[Dict[str, Any]]:
+        """
+        Execute the PMC search.
+
+        Args:
+            tool_arguments: Dictionary containing search parameters
+
+        Returns:
+            List of paper dictionaries
+        """
+        query = tool_arguments.get('query', '')
+        if not query:
+            return [{'error': 'Query parameter is required'}]
+
+        limit = tool_arguments.get('limit', 10)
+        date_from = tool_arguments.get('date_from')
+        date_to = tool_arguments.get('date_to')
+        article_type = tool_arguments.get('article_type')
+
+        return self._search(
+            query=query,
+            limit=limit,
+            date_from=date_from,
+            date_to=date_to,
+            article_type=article_type
+        )