tooluniverse 1.0.10__py3-none-any.whl → 1.0.11.1__py3-none-any.whl

tooluniverse/ols_tool.py

@@ -0,0 +1,435 @@
+"""OLS API tool for ToolUniverse.
+
+This module exposes the Ontology Lookup Service (OLS) endpoints that were
+previously available through the dedicated MCP server. The MCP tooling has been
+adapted into a synchronous local tool that fits the ToolUniverse runtime.
+"""
+
+from __future__ import annotations
+
+import urllib.parse
+from typing import Any, Dict, List, Optional
+
+import requests
+from pydantic import BaseModel, Field, HttpUrl, ValidationError
+
+from .base_tool import BaseTool
+from .tool_registry import register_tool
+
+OLS_BASE_URL = "https://www.ebi.ac.uk/ols4"
+REQUEST_TIMEOUT = 30.0
+
+
+def url_encode_iri(iri: str) -> str:
+    """Double URL encode an IRI as required by the OLS API."""
+
+    return urllib.parse.quote(urllib.parse.quote(iri, safe=""), safe="")
+
+
+class OntologyInfo(BaseModel):
+    """Description of a single ontology entry in OLS."""
+
+    id: str = Field(
+        ..., description="Unique identifier for the ontology", alias="ontologyId"
+    )
+    title: str = Field(..., description="Name of the ontology")
+    version: Optional[str] = Field(None, description="Version of the ontology")
+    description: Optional[str] = Field(None, description="Description of the ontology")
+    domain: Optional[str] = Field(None, description="Domain of the ontology")
+    homepage: Optional[HttpUrl] = Field(None, description="URL for the ontology")
+    preferred_prefix: Optional[str] = Field(
+        None, description="Preferred prefix for the ontology", alias="preferredPrefix"
+    )
+    number_of_terms: Optional[int] = Field(
+        None, description="Number of terms in the ontology"
+    )
+    number_of_classes: Optional[int] = Field(
+        None, description="Number of classes in the ontology", alias="numberOfClasses"
+    )
+    repository: Optional[HttpUrl] = Field(
+        None, description="Repository URL for the ontology"
+    )
+
+
+class PagedResponse(BaseModel):
+    """Base structure for paginated responses returned by OLS."""
+
+    total_elements: int = Field(
+        0, description="Total number of items", alias="totalElements"
+    )
+    page: int = Field(0, description="Current page number")
+    size: int = Field(
+        20, description="Number of items in current page", alias="numElements"
+    )
+    total_pages: int = Field(0, description="Total number of pages", alias="totalPages")
+
+
+class OntologySearchResponse(PagedResponse):
+    """Paginated collection of ontologies returned by the search endpoint."""
+
+    ontologies: List[OntologyInfo] = Field(
+        ..., description="List of ontologies matching the search criteria"
+    )
+
+
+class TermInfo(BaseModel):
+    """Basic term representation returned by OLS."""
+
+    model_config = {"populate_by_name": True}
+
+    iri: HttpUrl = Field(..., description="IRI of the term")
+    ontology_name: str = Field(
+        ...,
+        description="Name of the ontology containing the term",
+        alias="ontologyName",
+    )
+    short_form: str = Field(
+        ..., description="Short form identifier for the term", alias="shortForm"
+    )
+    label: str = Field(..., description="Human-readable label for the term")
+    obo_id: Optional[str] = Field(
+        None, description="OBOLibrary ID for the term", alias="oboId"
+    )
+    is_obsolete: Optional[bool] = Field(
+        False, description="Indicates if the term is obsolete", alias="isObsolete"
+    )
+
+
+class TermSearchResponse(PagedResponse):
+    """Paginated set of OLS terms."""
+
+    num_found: int = Field(
+        0, description="Total number of terms found", alias="numFound"
+    )
+    terms: List[TermInfo] = Field(
+        ..., description="List of terms matching the search criteria"
+    )
+
+
+class DetailedTermInfo(TermInfo):
+    """Extended term details in OLS."""
+
+    description: Optional[List[str]] = Field(None, description="Definition of the term")
+    synonyms: Optional[List[str]] = Field(
+        None, description="List of synonyms for the term"
+    )
+
+
+@register_tool("OLSTool")
+class OLSTool(BaseTool):
+    """Interact with the EMBL-EBI Ontology Lookup Service (OLS) REST API."""
+
+    _OPERATIONS = {
+        "search_terms": "_handle_search_terms",
+        "get_ontology_info": "_handle_get_ontology_info",
+        "search_ontologies": "_handle_search_ontologies",
+        "get_term_info": "_handle_get_term_info",
+        "get_term_children": "_handle_get_term_children",
+        "get_term_ancestors": "_handle_get_term_ancestors",
+        "find_similar_terms": "_handle_find_similar_terms",
+    }
+
+    def __init__(self, tool_config):
+        super().__init__(tool_config)
+        self.base_url = tool_config.get("base_url", OLS_BASE_URL).rstrip("/")
+        self.timeout = tool_config.get("timeout", REQUEST_TIMEOUT)
+        self.session = requests.Session()
+
+    def __del__(self):
+        try:
+            self.session.close()
+        except Exception:
+            pass
+
+    def run(self, arguments=None, **_: Any):
+        """Dispatch the requested OLS operation."""
+
+        arguments = arguments or {}
+        operation = arguments.get("operation")
+        if not operation:
+            return {
+                "error": "`operation` argument is required.",
+                "available_operations": sorted(self._OPERATIONS.keys()),
+            }
+
+        handler_name = self._OPERATIONS.get(operation)
+        if not handler_name:
+            return {
+                "error": f"Unsupported operation '{operation}'.",
+                "available_operations": sorted(self._OPERATIONS.keys()),
+            }
+
+        handler = getattr(self, handler_name)
+        try:
+            return handler(arguments)
+        except requests.RequestException as exc:
+            return {"error": "OLS API request failed.", "details": str(exc)}
+        except ValidationError as exc:
+            return {
+                "error": "Failed to validate OLS response.",
+                "details": exc.errors(),
+            }
+
+    def _handle_search_terms(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        query = arguments.get("query")
+        if not query:
+            return {"error": "`query` parameter is required for `search_terms`."}
+
+        rows = int(arguments.get("rows", 10))
+        ontology = arguments.get("ontology")
+        exact_match = bool(arguments.get("exact_match", False))
+        include_obsolete = bool(arguments.get("include_obsolete", False))
+
+        params = {
+            "q": query,
+            "rows": rows,
+            "start": 0,
+            "exact": exact_match,
+            "obsoletes": include_obsolete,
+        }
+        if ontology:
+            params["ontology"] = ontology
+
+        data = self._get_json("/api/search", params=params)
+        formatted = self._format_term_collection(data, rows)
+        formatted["query"] = query
+        formatted["filters"] = {
+            "ontology": ontology,
+            "exact_match": exact_match,
+            "include_obsolete": include_obsolete,
+        }
+        return formatted
+
+    def _handle_get_ontology_info(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        ontology_id = arguments.get("ontology_id")
+        if not ontology_id:
+            return {
+                "error": "`ontology_id` parameter is required for `get_ontology_info`."
+            }
+
+        data = self._get_json(f"/api/v2/ontologies/{ontology_id}")
+        ontology = OntologyInfo.model_validate(data)
+        return ontology.model_dump(by_alias=True)
+
+    def _handle_search_ontologies(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        search = arguments.get("search")
+        page = int(arguments.get("page", 0))
+        size = int(arguments.get("size", 20))
+
+        params: Dict[str, Any] = {"page": page, "size": size}
+        if search:
+            params["search"] = search
+
+        data = self._get_json("/api/v2/ontologies", params=params)
+        embedded = data.get("_embedded", {})
+        ontologies = embedded.get("ontologies", [])
+
+        validated: List[Dict[str, Any]] = []
+        for item in ontologies:
+            try:
+                validated.append(
+                    OntologyInfo.model_validate(item).model_dump(by_alias=True)
+                )
+            except ValidationError:
+                continue
+
+        page_info = data.get("page", {})
+        return {
+            "results": validated or ontologies,
+            "pagination": {
+                "page": page_info.get("number", page),
+                "size": page_info.get("size", size),
+                "total_pages": page_info.get("totalPages", 0),
+                "total_items": page_info.get("totalElements", len(ontologies)),
+            },
+            "search": search,
+        }
+
+    def _handle_get_term_info(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        identifier = arguments.get("id")
+        if not identifier:
+            return {"error": "`id` parameter is required for `get_term_info`."}
+
+        data = self._get_json("/api/terms", params={"id": identifier})
+        embedded = data.get("_embedded", {})
+        terms = embedded.get("terms") if isinstance(embedded, dict) else None
+        if not terms:
+            return {"error": f"Term with ID '{identifier}' was not found in OLS."}
+
+        # Normalize the term data before validation
+        term_data = terms[0]
+        if "ontologyId" in term_data and "ontologyName" not in term_data:
+            term_data["ontologyName"] = term_data["ontologyId"]
+
+        term = DetailedTermInfo.model_validate(term_data)
+        return term.model_dump(by_alias=True)
+
+    def _handle_get_term_children(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        term_iri = arguments.get("term_iri")
+        ontology = arguments.get("ontology")
+        if not term_iri or not ontology:
+            return {
+                "error": "`term_iri` and `ontology` parameters are required for `get_term_children`."
+            }
+
+        include_obsolete = bool(arguments.get("include_obsolete", False))
+        size = int(arguments.get("size", 20))
+        encoded = url_encode_iri(term_iri)
+
+        params = {
+            "page": 0,
+            "size": size,
+            "includeObsoleteEntities": include_obsolete,
+        }
+
+        data = self._get_json(
+            f"/api/v2/ontologies/{ontology}/classes/{encoded}/children", params=params
+        )
+        formatted = self._format_term_collection(data, size)
+        formatted["term_iri"] = term_iri
+        formatted["ontology"] = ontology
+        formatted["filters"] = {"include_obsolete": include_obsolete}
+        return formatted
+
+    def _handle_get_term_ancestors(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        term_iri = arguments.get("term_iri")
+        ontology = arguments.get("ontology")
+        if not term_iri or not ontology:
+            return {
+                "error": "`term_iri` and `ontology` parameters are required for `get_term_ancestors`."
+            }
+
+        include_obsolete = bool(arguments.get("include_obsolete", False))
+        size = int(arguments.get("size", 20))
+        encoded = url_encode_iri(term_iri)
+
+        params = {
+            "page": 0,
+            "size": size,
+            "includeObsoleteEntities": include_obsolete,
+        }
+
+        data = self._get_json(
+            f"/api/v2/ontologies/{ontology}/classes/{encoded}/ancestors", params=params
+        )
+        formatted = self._format_term_collection(data, size)
+        formatted["term_iri"] = term_iri
+        formatted["ontology"] = ontology
+        formatted["filters"] = {"include_obsolete": include_obsolete}
+        return formatted
+
+    def _handle_find_similar_terms(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        term_iri = arguments.get("term_iri")
+        ontology = arguments.get("ontology")
+        if not term_iri or not ontology:
+            return {
+                "error": "`term_iri` and `ontology` parameters are required for `find_similar_terms`."
+            }
+
+        size = int(arguments.get("size", 10))
+        encoded = url_encode_iri(term_iri)
+
+        params = {"page": 0, "size": size}
+        data = self._get_json(
+            f"/api/v2/ontologies/{ontology}/classes/{encoded}/llm_similar",
+            params=params,
+        )
+        formatted = self._format_term_collection(data, size)
+        formatted["term_iri"] = term_iri
+        formatted["ontology"] = ontology
+        return formatted
+
+    def _get_json(
+        self, path: str, params: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        url = f"{self.base_url}{path}"
+        response = self.session.get(url, params=params, timeout=self.timeout)
+        response.raise_for_status()
+        return response.json()
+
+    def _format_term_collection(
+        self, data: Dict[str, Any], size: int
+    ) -> Dict[str, Any]:
+        elements: Optional[List[Dict[str, Any]]] = None
+
+        if isinstance(data, dict):
+            if "elements" in data and isinstance(data["elements"], list):
+                elements = data["elements"]
+            else:
+                embedded = data.get("_embedded")
+                if isinstance(embedded, dict):
+                    for key in ("terms", "children", "ancestors"):
+                        if key in embedded and isinstance(embedded[key], list):
+                            elements = embedded[key]
+                            break
+                    if elements is None:
+                        candidates = [
+                            value
+                            for value in embedded.values()
+                            if isinstance(value, list)
+                        ]
+                        if candidates:
+                            elements = candidates[0]
+
+        if not elements:
+            return data if isinstance(data, dict) else {"items": data}
+
+        limited = elements[:size]
+        term_models = [self._build_term_model(item) for item in limited]
+        term_models = [model for model in term_models if model is not None]
+
+        total = (
+            data.get("totalElements")
+            or data.get("page", {}).get("totalElements")
+            or len(elements)
+        )
+
+        result: Dict[str, Any] = {
+            "terms": [model.model_dump(by_alias=True) for model in term_models],
+            "total_items": total,
+            "showing": len(term_models),
+        }
+
+        page_info = data.get("page") if isinstance(data, dict) else None
+        if isinstance(page_info, dict):
+            result["pagination"] = {
+                "page": page_info.get("number", 0),
+                "size": page_info.get("size", len(limited)),
+                "total_pages": page_info.get("totalPages", 0),
+                "total_items": page_info.get("totalElements", total),
+            }
+
+        return result
+
+    @staticmethod
+    def _build_term_model(item: Dict[str, Any]) -> Optional[TermInfo]:
+        payload = {
+            "iri": item.get("iri"),
+            "ontology_name": item.get("ontologyName")
+            or item.get("ontology_name")
+            or item.get("ontologyId")
+            or "",
+            "short_form": item.get("shortForm") or item.get("short_form") or "",
+            "label": item.get("label") or "",
+            "oboId": item.get("oboId") or item.get("obo_id"),
+            "isObsolete": item.get("isObsolete") or item.get("is_obsolete", False),
+        }
+
+        if not payload["iri"]:
+            return None
+
+        try:
+            return TermInfo.model_validate(payload)
+        except ValidationError:
+            return None
+
+
+__all__ = [
+    "OLSTool",
+    "OntologyInfo",
+    "OntologySearchResponse",
+    "TermInfo",
+    "TermSearchResponse",
+    "DetailedTermInfo",
+    "url_encode_iri",
+]

tooluniverse/package_discovery_tool.py

@@ -0,0 +1,217 @@
+"""Dynamic package discovery and evaluation"""
+
+import requests
+import time
+from typing import Dict, Any, List
+from .base_tool import BaseTool
+from .tool_registry import register_tool
+
+
+@register_tool("DynamicPackageDiscovery")
+class DynamicPackageDiscovery(BaseTool):
+    """Searches PyPI and evaluates packages dynamically based on requirements"""
+
+    def __init__(self, tool_config: Dict[str, Any]):
+        super().__init__(tool_config)
+        self.pypi_search_url = "https://pypi.org/pypi/{package}/json"
+        self.pypi_search_api = "https://pypi.org/search/"
+        self.session = requests.Session()
+        self.session.headers.update({"User-Agent": "ToolUniverse-PackageDiscovery/1.0"})
+
+        # Initialize WebSearchTool instance
+        from .web_search_tool import WebSearchTool
+
+        self.web_search_tool = WebSearchTool({"name": "WebSearchTool"})
+
+    def _search_pypi_via_web(self, query: str) -> List[Dict[str, Any]]:
+        """Search PyPI using web search tool"""
+        try:
+            # Use pre-initialized WebSearchTool instance
+            result = self.web_search_tool.run(
+                {
+                    "query": f"{query} site:pypi.org",
+                    "max_results": 10,
+                    "search_type": "python_packages",
+                }
+            )
+
+            packages = []
+            if result.get("status") == "success":
+                for item in result.get("results", []):
+                    url = item.get("url", "")
+                    if "pypi.org/project/" in url:
+                        # Extract package name from URL
+                        pkg_name = url.split("/project/")[-1].rstrip("/")
+                        packages.append(
+                            {
+                                "name": pkg_name,
+                                "source": "pypi_web",
+                                "title": item.get("title", ""),
+                                "snippet": item.get("snippet", ""),
+                                "url": url,
+                            }
+                        )
+
+            return packages
+        except Exception as e:
+            print(f"⚠️ Web search for PyPI packages failed: {e}")
+            return []
+
+    def _evaluate_package(self, package_name: str) -> Dict[str, Any]:
+        """Evaluate a package's suitability by fetching PyPI metadata"""
+        try:
+            response = self.session.get(
+                self.pypi_search_url.format(package=package_name), timeout=10
+            )
+
+            if response.status_code == 200:
+                data = response.json()
+                info = data.get("info", {})
+                urls = info.get("project_urls", {})
+
+                # Extract key metrics
+                evaluation = {
+                    "name": package_name,
+                    "version": info.get("version"),
+                    "description": info.get("summary", ""),
+                    "author": info.get("author", ""),
+                    "license": info.get("license", ""),
+                    "home_page": info.get("home_page", ""),
+                    "download_url": info.get("download_url", ""),
+                    "requires_python": info.get("requires_python", ""),
+                    "dependencies": info.get("requires_dist", []),
+                    "classifiers": info.get("classifiers", []),
+                    # Quality indicators
+                    "has_docs": bool(urls.get("Documentation")),
+                    "has_source": bool(urls.get("Source")),
+                    "has_homepage": bool(info.get("home_page")),
+                    "has_bug_tracker": bool(urls.get("Bug Reports")),
+                    "project_urls": urls,
+                    # Popularity indicators
+                    "is_stable": "Development Status :: 5 - Production/Stable"
+                    in info.get("classifiers", []),
+                    "is_mature": "Development Status :: 6 - Mature"
+                    in info.get("classifiers", []),
+                    "has_tests": "Topic :: Software Development :: Testing"
+                    in info.get("classifiers", []),
+                    "is_typed": "Typing :: Typed" in info.get("classifiers", []),
+                }
+
+                # Calculate a basic quality score
+                quality_score = 0
+                if evaluation["has_docs"]:
+                    quality_score += 20
+                if evaluation["has_source"]:
+                    quality_score += 15
+                if evaluation["is_stable"] or evaluation["is_mature"]:
+                    quality_score += 25
+                if evaluation["has_tests"]:
+                    quality_score += 15
+                if evaluation["is_typed"]:
+                    quality_score += 10
+                if evaluation["has_homepage"]:
+                    quality_score += 10
+                if evaluation["has_bug_tracker"]:
+                    quality_score += 5
+
+                evaluation["quality_score"] = min(quality_score, 100)
+
+                return evaluation
+            else:
+                return {
+                    "name": package_name,
+                    "error": f"HTTP {response.status_code}",
+                    "quality_score": 0,
+                }
+
+        except Exception as e:
+            return {"name": package_name, "error": str(e), "quality_score": 0}
+
+    def _rank_packages(
+        self, packages: List[Dict[str, Any]], requirements: str, functionality: str
+    ) -> List[Dict[str, Any]]:
+        """Rank packages by relevance and quality"""
+        if not packages:
+            return []
+
+        # Filter out packages with errors
+        valid_packages = [pkg for pkg in packages if "error" not in pkg]
+
+        # Sort by quality score (descending)
+        ranked = sorted(
+            valid_packages, key=lambda x: x.get("quality_score", 0), reverse=True
+        )
+
+        # Add ranking metadata
+        for i, pkg in enumerate(ranked):
+            pkg["rank"] = i + 1
+            pkg["reasoning"] = f"Quality score: {pkg.get('quality_score', 0)}/100"
+
+        return ranked
+
+    def run(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Dynamically discover and evaluate packages
+
+        Args:
+            requirements: Description of what's needed
+            functionality: Specific functionality required
+            constraints: Any constraints (Python version, license, etc.)
+        """
+        try:
+            requirements = arguments.get("requirements", "")
+            functionality = arguments.get("functionality", "")
+
+            # Search for candidate packages
+            search_query = f"{requirements} {functionality}".strip()
+            print(f"🔍 Searching for packages: {search_query}")
+
+            candidates = self._search_pypi_via_web(search_query)
+
+            if not candidates:
+                return {
+                    "status": "success",
+                    "candidates": [],
+                    "recommendation": None,
+                    "message": "No packages found",
+                }
+
+            print(f"📦 Found {len(candidates)} package candidates")
+
+            # Evaluate each candidate
+            evaluated = []
+            for i, pkg in enumerate(candidates):
+                print(f"  Evaluating {i+1}/{len(candidates)}: {pkg['name']}")
+                evaluation = self._evaluate_package(pkg["name"])
+                # Merge web search info with PyPI evaluation
+                evaluation.update({k: v for k, v in pkg.items() if k not in evaluation})
+                evaluated.append(evaluation)
+
+                # Rate limiting
+                time.sleep(0.2)
+
+            # Rank by suitability
+            ranked = self._rank_packages(evaluated, requirements, functionality)
+
+            top_recommendation = ranked[0] if ranked else None
+
+            if top_recommendation:
+                score = top_recommendation.get("quality_score", 0)
+                print(
+                    f"🏆 Top recommendation: {top_recommendation['name']} (score: {score})"
+                )
+
+            return {
+                "status": "success",
+                "candidates": ranked,
+                "recommendation": top_recommendation,
+                "total_evaluated": len(evaluated),
+            }
+
+        except Exception as e:
+            return {
+                "status": "error",
+                "error": str(e),
+                "candidates": [],
+                "recommendation": None,
+            }

tooluniverse/paleobiology_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("PaleobiologyRESTTool")
+class PaleobiologyRESTTool(BaseTool):
+    def __init__(self, tool_config: Dict):
+        super().__init__(tool_config)
+        self.base_url = "https://paleobiodb.org/data1.2"
+        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"Paleobiology API error: {str(e)}"}