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

tooluniverse/__init__.py

@@ -174,9 +174,26 @@ MCPAutoLoaderTool: Any
 ADMETAITool: Any
 AlphaFoldRESTTool: Any
 ComposeTool: Any
+PythonCodeExecutor: Any
+PythonScriptRunner: Any
 CellosaurusSearchTool: Any
 CellosaurusQueryConverterTool: Any
 CellosaurusGetCellLineInfoTool: Any
+# New database tools
+InterProRESTTool: Any
+NCBIBlastTool: Any
+CBioPortalRESTTool: Any
+RegulomeDBRESTTool: Any
+JASPARRESTTool: Any
+ReMapRESTTool: Any
+SCREENRESTTool: Any
+PRIDERESTTool: Any
+EMDBRESTTool: Any
+GtoPdbRESTTool: Any
+MPDRESTTool: Any
+WoRMSRESTTool: Any
+PaleobiologyRESTTool: Any
+OLSTool: Any
 if not _LIGHT_IMPORT and not LAZY_LOADING_ENABLED:
     # Import all tool classes immediately (old behavior) with warning suppression  # noqa: E501
     with warnings.catch_warnings():
@@ -185,7 +202,6 @@ if not _LIGHT_IMPORT and not LAZY_LOADING_ENABLED:
         warnings.filterwarnings("ignore", category=UserWarning)
         warnings.filterwarnings("ignore", category=FutureWarning)
         # Suppress specific third-party warnings
-        warnings.filterwarnings("ignore", category=UserWarning, module="hyperopt")
         warnings.filterwarnings(
             "ignore", category=DeprecationWarning, module="pkg_resources"
         )
@@ -213,6 +229,10 @@ if not _LIGHT_IMPORT and not LAZY_LOADING_ENABLED:
         )
         from .chem_tool import ChEMBLTool
         from .compose_tool import ComposeTool
+        from .python_executor_tool import (
+            PythonCodeExecutor,
+            PythonScriptRunner,
+        )
         from .europe_pmc_tool import EuropePMCTool
         from .semantic_scholar_tool import SemanticScholarTool
         from .pubtator_tool import PubTatorTool
@@ -235,6 +255,12 @@ if not _LIGHT_IMPORT and not LAZY_LOADING_ENABLED:
         from .embedding_database import EmbeddingDatabase
         from .embedding_sync import EmbeddingSync
         from .rcsb_pdb_tool import RCSBTool
+        from .web_search_tool import (
+            WebSearchTool,
+            WebAPIDocumentationSearchTool,
+        )
+        from .package_discovery_tool import DynamicPackageDiscovery
+        from .pypi_package_inspector_tool import PyPIPackageInspector
         from .gwas_tool import (
             GWASAssociationSearch,
             GWASStudySearch,
@@ -264,6 +290,14 @@ if not _LIGHT_IMPORT and not LAZY_LOADING_ENABLED:
         CellosaurusQueryConverterTool,
         CellosaurusGetCellLineInfoTool,
     )
+    from .ols_tool import OLSTool
+
+    # New database tools
+    from .clinvar_tool import (
+        ClinVarSearchVariants,
+        ClinVarGetVariantDetails,
+        ClinVarGetClinicalSignificance,
+    )
 
     # Literature search tools
     from .arxiv_tool import ArXivTool
@@ -310,6 +344,8 @@ else:
     )
     ChEMBLTool = _LazyImportProxy("chem_tool", "ChEMBLTool")
     ComposeTool = _LazyImportProxy("compose_tool", "ComposeTool")
+    PythonCodeExecutor = _LazyImportProxy("python_executor_tool", "PythonCodeExecutor")
+    PythonScriptRunner = _LazyImportProxy("python_executor_tool", "PythonScriptRunner")
     EuropePMCTool = _LazyImportProxy("europe_pmc_tool", "EuropePMCTool")
     SemanticScholarTool = _LazyImportProxy(
         "semantic_scholar_tool", "SemanticScholarTool"
@@ -368,6 +404,7 @@ else:
     CellosaurusGetCellLineInfoTool = _LazyImportProxy(
         "cellosaurus_tool", "CellosaurusGetCellLineInfoTool"
     )
+    OLSTool = _LazyImportProxy("ols_tool", "OLSTool")
     # Literature search tools
     ArXivTool = _LazyImportProxy("arxiv_tool", "ArXivTool")
     CrossrefTool = _LazyImportProxy("crossref_tool", "CrossrefTool")
@@ -381,6 +418,16 @@ else:
     CoreTool = _LazyImportProxy("core_tool", "CoreTool")
     PMCTool = _LazyImportProxy("pmc_tool", "PMCTool")
     ZenodoTool = _LazyImportProxy("zenodo_tool", "ZenodoTool")
+    WebSearchTool = _LazyImportProxy("web_search_tool", "WebSearchTool")
+    WebAPIDocumentationSearchTool = _LazyImportProxy(
+        "web_search_tool", "WebAPIDocumentationSearchTool"
+    )
+    DynamicPackageDiscovery = _LazyImportProxy(
+        "package_discovery_tool", "DynamicPackageDiscovery"
+    )
+    PyPIPackageInspector = _LazyImportProxy(
+        "pypi_package_inspector_tool", "PyPIPackageInspector"
+    )
 
 __all__ = [
     "__version__",
@@ -456,6 +503,7 @@ __all__ = [
     "CellosaurusSearchTool",
     "CellosaurusQueryConverterTool",
     "CellosaurusGetCellLineInfoTool",
+    "OLSTool",
     # Literature search tools
     "ArXivTool",
     "CrossrefTool",
@@ -469,4 +517,12 @@ __all__ = [
     "CoreTool",
     "PMCTool",
     "ZenodoTool",
+    "WebSearchTool",
+    "WebAPIDocumentationSearchTool",
+    "DynamicPackageDiscovery",
+    "PyPIPackageInspector",
+    # ClinVar tools
+    "ClinVarSearchVariants",
+    "ClinVarGetVariantDetails",
+    "ClinVarGetClinicalSignificance",
 ]

tooluniverse/blast_tool.py

@@ -0,0 +1,132 @@
+from typing import Any, Dict
+from Bio.Blast import NCBIWWW, NCBIXML
+from Bio.Seq import Seq
+from .base_tool import BaseTool
+from .tool_registry import register_tool
+
+
+@register_tool("NCBIBlastTool")
+class NCBIBlastTool(BaseTool):
+    def __init__(self, tool_config: Dict):
+        super().__init__(tool_config)
+        self.timeout = 300  # BLAST can take a long time
+        self.max_wait_time = 600  # Maximum wait time for results
+
+    def _parse_blast_results(self, blast_xml: str) -> Dict[str, Any]:
+        """Parse BLAST XML results into structured data"""
+        try:
+            from io import StringIO
+
+            blast_record = NCBIXML.read(StringIO(blast_xml))
+
+            results = {
+                "query_id": blast_record.query_id,
+                "query_length": blast_record.query_length,
+                "database": blast_record.database,
+                "algorithm": blast_record.application,
+                "alignments": [],
+            }
+
+            for alignment in blast_record.alignments:
+                alignment_data = {
+                    "hit_id": getattr(alignment, "hit_id", "unknown"),
+                    "hit_def": getattr(alignment, "hit_def", "unknown"),
+                    "hit_length": getattr(alignment, "hit_length", 0),
+                    "hsps": [],
+                }
+
+                for hsp in alignment.hsps:
+                    hsp_data = {
+                        "score": getattr(hsp, "score", 0),
+                        "bits": getattr(hsp, "bits", 0),
+                        "expect": getattr(hsp, "expect", 0),
+                        "identities": getattr(hsp, "identities", 0),
+                        "positives": getattr(hsp, "positives", 0),
+                        "gaps": getattr(hsp, "gaps", 0),
+                        "align_length": getattr(hsp, "align_length", 0),
+                        "query_start": getattr(hsp, "query_start", 0),
+                        "query_end": getattr(hsp, "query_end", 0),
+                        "hit_start": getattr(hsp, "hit_start", 0),
+                        "hit_end": getattr(hsp, "hit_end", 0),
+                        "query": getattr(hsp, "query", ""),
+                        "match": getattr(hsp, "match", ""),
+                        "sbjct": getattr(hsp, "sbjct", ""),
+                    }
+                    alignment_data["hsps"].append(hsp_data)
+
+                results["alignments"].append(alignment_data)
+
+            return results
+
+        except Exception as e:
+            return {
+                "error": f"Failed to parse BLAST results: {str(e)}",
+                "raw_xml": (
+                    blast_xml[:1000] + "..." if len(blast_xml) > 1000 else blast_xml
+                ),
+            }
+
+    def run(self, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Execute BLAST search using NCBI Web service"""
+        try:
+            sequence = arguments.get("sequence", "")
+            blast_type = arguments.get("blast_type", "blastn")
+            database = arguments.get("database", "nt")
+            expect = arguments.get("expect", 10.0)
+            hitlist_size = arguments.get("hitlist_size", 50)
+
+            if not sequence:
+                return {
+                    "status": "error",
+                    "error": "Missing required parameter: sequence",
+                }
+
+            # Validate sequence
+            try:
+                seq_obj = Seq(sequence)
+                if len(seq_obj) < 10:
+                    return {
+                        "status": "error",
+                        "error": "Sequence too short (minimum 10 nucleotides)",
+                    }
+            except Exception as e:
+                return {
+                    "status": "error",
+                    "error": f"Invalid sequence format: {str(e)}",
+                }
+
+            # Perform BLAST search
+            result_handle = NCBIWWW.qblast(
+                blast_type,
+                database,
+                sequence,
+                expect=expect,
+                hitlist_size=hitlist_size,
+                format_type="XML",
+            )
+
+            # Read results
+            blast_xml = result_handle.read()
+            result_handle.close()
+
+            # Parse results
+            parsed_results = self._parse_blast_results(blast_xml)
+
+            if "error" in parsed_results:
+                return {
+                    "status": "error",
+                    "error": parsed_results["error"],
+                    "raw_data": parsed_results.get("raw_xml", ""),
+                }
+
+            return {
+                "status": "success",
+                "data": parsed_results,
+                "query_sequence": sequence,
+                "blast_type": blast_type,
+                "database": database,
+                "hit_count": len(parsed_results["alignments"]),
+            }
+
+        except Exception as e:
+            return {"status": "error", "error": f"BLAST search failed: {str(e)}"}

tooluniverse/boltz_tool.py

@@ -170,7 +170,7 @@ class Boltz2DockingTool(BaseTool):
                     prediction_folder, f"{input_filename}_model_0.cif"
                 )
                 if os.path.exists(structure_file):
-                    with open(structure_file, "r") as f:
+                    with open(structure_file, "r", encoding="utf-8") as f:
                         results["predicted_structure"] = f.read()
                     results["structure_format"] = "cif"
                 else:
@@ -183,7 +183,7 @@ class Boltz2DockingTool(BaseTool):
                 prediction_folder, f"affinity_{input_filename}.json"
             )
             if os.path.exists(affinity_file):
-                with open(affinity_file, "r") as f:
+                with open(affinity_file, "r", encoding="utf-8") as f:
                     results["affinity_prediction"] = json.load(f)
             else:
                 results["affinity_error"] = f"Missing {os.path.basename(affinity_file)}"

tooluniverse/cbioportal_tool.py

@@ -0,0 +1,42 @@
+import requests
+from typing import Any, Dict
+from .base_tool import BaseTool
+from .tool_registry import register_tool
+
+
+@register_tool("CBioPortalRESTTool")
+class CBioPortalRESTTool(BaseTool):
+    def __init__(self, tool_config: Dict):
+        super().__init__(tool_config)
+        self.base_url = "https://www.cbioportal.org/api"
+        self.session = requests.Session()
+        self.session.headers.update(
+            {"Accept": "application/json", "User-Agent": "ToolUniverse/1.0"}
+        )
+        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,
+                "count": len(data) if isinstance(data, list) else 1,
+            }
+        except Exception as e:
+            return {
+                "status": "error",
+                "error": f"cBioPortal API error: {str(e)}",
+                "url": url,
+            }