tooluniverse 1.0.9.1__py3-none-any.whl → 1.0.11__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/admetai_tool.py

@@ -55,7 +55,7 @@ class ADMETAITool(BaseTool):
         Args:
             smiles: The SMILES string(s) of the molecule(s).
 
-        Returns:
+        Returns
             A dictionary mapping each SMILES string to a subdictionary of
             selected ADMET properties and their predicted values.
         """

tooluniverse/agentic_tool.py

@@ -38,7 +38,7 @@ class AgenticTool(BaseTool):
         """
         Check if any API keys are available across all supported API types.
 
-        Returns:
+        Returns
             bool: True if at least one API type has all required keys, False otherwise
         """
         for _api_type, required_vars in API_KEY_ENV_VARS.items():
@@ -74,16 +74,44 @@ class AgenticTool(BaseTool):
         # Get configuration from nested 'configs' dict or fallback to top-level
         configs = tool_config.get("configs", {})
 
-        # Helper function to get config values with fallback
+        # Helper function to get config values with Space support
         def get_config(key: str, default: Any) -> Any:
-            return configs.get(key, tool_config.get(key, default))
+            tool_value = configs.get(key, tool_config.get(key))
+
+            # Get environment value directly (avoid calling self method during init)
+            env_value = None
+            if key == "api_type":
+                # Direct use of AgenticTool api_type values from Space
+                env_value = os.getenv("TOOLUNIVERSE_LLM_DEFAULT_PROVIDER")
+            elif key == "model_id":
+                task = tool_config.get("llm_task", "default").upper()
+                env_value = os.getenv(f"TOOLUNIVERSE_LLM_MODEL_{task}") or os.getenv(
+                    "TOOLUNIVERSE_LLM_MODEL_DEFAULT"
+                )
+            elif key == "temperature":
+                temp_str = os.getenv("TOOLUNIVERSE_LLM_TEMPERATURE")
+                env_value = float(temp_str) if temp_str else None
+
+            mode = os.getenv("TOOLUNIVERSE_LLM_CONFIG_MODE", "default")
+
+            if mode == "default":
+                # Space as default: tool config > env > built-in default
+                if tool_value is not None:
+                    return tool_value
+                if env_value is not None:
+                    return env_value
+                return default
+            else:  # mode == "fallback"
+                # Space as fallback: tool config > built-in default (env as fallback later)
+                if tool_value is not None:
+                    return tool_value
+                return default
 
         # LLM configuration
         self._api_type: str = get_config("api_type", "CHATGPT")
         self._model_id: str = get_config("model_id", "o1-mini")
         self._temperature: Optional[float] = get_config("temperature", 0.1)
-        # Ignore configured max_new_tokens; client will resolve per model/env
-        self._max_new_tokens: Optional[int] = None
+        # max_new_tokens is handled by LLM client automatically
         self._return_json: bool = get_config("return_json", False)
         self._max_retries: int = get_config("max_retries", 5)
         self._retry_delay: int = get_config("retry_delay", 5)
@@ -96,9 +124,8 @@ class AgenticTool(BaseTool):
 
         # Global fallback configuration
         self._use_global_fallback: bool = get_config("use_global_fallback", True)
-        self._global_fallback_chain: List[Dict[str, str]] = (
-            self._get_global_fallback_chain()
-        )
+        # Initialize fallback chain later after environment config is set
+        self._global_fallback_chain: List[Dict[str, str]] = []
 
         # Gemini model configuration (optional; env override)
         self._gemini_model_id: str = get_config(
@@ -133,11 +160,40 @@ class AgenticTool(BaseTool):
         self._current_api_type = None
         self._current_model_id = None
 
+        # Store environment config for fallback mode
+        # Direct use of AgenticTool api_type values from Space
+        self._env_api_type = os.getenv("TOOLUNIVERSE_LLM_DEFAULT_PROVIDER")
+
+        task = tool_config.get("llm_task", "default").upper()
+        self._env_model_id = os.getenv(f"TOOLUNIVERSE_LLM_MODEL_{task}") or os.getenv(
+            "TOOLUNIVERSE_LLM_MODEL_DEFAULT"
+        )
+
+        # Initialize global fallback chain now that environment config is set
+        self._global_fallback_chain = self._get_global_fallback_chain()
+
         # Try primary API first, then fallback if configured
         self._try_initialize_api()
 
     def _get_global_fallback_chain(self) -> List[Dict[str, str]]:
         """Get the global fallback chain from environment or use default."""
+        mode = os.getenv("TOOLUNIVERSE_LLM_CONFIG_MODE", "default")
+
+        # In fallback mode, prepend environment config to fallback chain
+        if mode == "fallback" and self._env_api_type and self._env_model_id:
+            env_fallback = {
+                "api_type": self._env_api_type,
+                "model_id": self._env_model_id,
+            }
+
+            # Check if env fallback is different from primary config
+            if (
+                env_fallback["api_type"] != self._api_type
+                or env_fallback["model_id"] != self._model_id
+            ):
+                # Add environment config as first fallback
+                return [env_fallback] + DEFAULT_FALLBACK_CHAIN.copy()
+
         # Check environment variable for custom fallback chain
         env_chain = os.getenv("AGENTIC_TOOL_FALLBACK_CHAIN")
         if env_chain:
@@ -257,8 +313,6 @@ class AgenticTool(BaseTool):
             raise ValueError(
                 f"Unsupported API type: {self._api_type}. Supported types: {supported_api_types}"
             )
-        if self._max_new_tokens is not None and self._max_new_tokens <= 0:
-            raise ValueError("max_new_tokens must be positive or None")
 
     # ------------------------------------------------------------------ public API --------------
     def run(
@@ -386,7 +440,6 @@ class AgenticTool(BaseTool):
                             "api_type": self._api_type,
                             "model_id": self._model_id,
                             "temperature": self._temperature,
-                            "max_new_tokens": self._max_new_tokens,
                         },
                         "execution_time_seconds": execution_time,
                         "timestamp": start_time.isoformat(),
@@ -417,7 +470,6 @@ class AgenticTool(BaseTool):
                             "api_type": self._api_type,
                             "model_id": self._model_id,
                             "temperature": self._temperature,
-                            "max_new_tokens": self._max_new_tokens,
                         },
                         "execution_time_seconds": execution_time,
                         "timestamp": start_time.isoformat(),
@@ -442,7 +494,6 @@ class AgenticTool(BaseTool):
                             "api_type": self._api_type,
                             "model_id": self._model_id,
                             "temperature": self._temperature,
-                            "max_new_tokens": self._max_new_tokens,
                         },
                         "execution_time_seconds": execution_time,
                     },
@@ -511,7 +562,6 @@ class AgenticTool(BaseTool):
             "api_type": self._api_type,
             "model_id": self._model_id,
             "temperature": self._temperature,
-            "max_new_tokens": self._max_new_tokens,
             "return_json": self._return_json,
             "max_retries": self._max_retries,
             "retry_delay": self._retry_delay,
@@ -595,9 +645,7 @@ class AgenticTool(BaseTool):
     def estimate_token_usage(self, arguments: Dict[str, Any]) -> Dict[str, int]:
         prompt = self._format_prompt(arguments)
         estimated_input_tokens = len(prompt) // 4
-        estimated_max_output_tokens = (
-            self._max_new_tokens if self._max_new_tokens is not None else 2048
-        )
+        estimated_max_output_tokens = 2048  # Default estimation
         estimated_total_tokens = estimated_input_tokens + estimated_max_output_tokens
         return {
             "estimated_input_tokens": estimated_input_tokens,

tooluniverse/base_tool.py

@@ -38,7 +38,7 @@ class BaseTool:
 
         Override this method in subclasses to specify a custom defaults file.
 
-        Returns:
+        Returns
             Path or resource object pointing to the defaults file
         """
         tool_type = cls.__name__
@@ -154,7 +154,7 @@ class BaseTool:
     def get_required_parameters(self):
         """
         Retrieve required parameters from the endpoint definition.
-        Returns:
+        Returns
         list: List of required parameters for the given endpoint.
         """
         schema = self.tool_config.get("parameter", {})
@@ -172,7 +172,7 @@ class BaseTool:
         Args:
             arguments: Dictionary of arguments to validate
 
-        Returns:
+        Returns
             ToolError if validation fails, None if validation passes
         """
         schema = self.tool_config.get("parameter", {})
@@ -207,7 +207,7 @@ class BaseTool:
         Args:
             exception: The raw exception to classify
 
-        Returns:
+        Returns
             Structured ToolError instance
         """
         error_str = str(exception).lower()
@@ -261,7 +261,7 @@ class BaseTool:
         Args:
             arguments: Dictionary of arguments for the tool call
 
-        Returns:
+        Returns
             String cache key
         """
         # Include tool name and arguments in cache key
@@ -276,7 +276,7 @@ class BaseTool:
         """
         Check if this tool supports streaming responses.
 
-        Returns:
+        Returns
             True if tool supports streaming, False otherwise
         """
         return self.tool_config.get("supports_streaming", False)
@@ -285,11 +285,22 @@ class BaseTool:
         """
         Check if this tool's results can be cached.
 
-        Returns:
+        Returns
             True if tool results can be cached, False otherwise
         """
         return self.tool_config.get("cacheable", True)
 
+    def get_batch_concurrency_limit(self) -> int:
+        """Return maximum concurrent executions allowed during batch runs (0 = unlimited)."""
+        limit = self.tool_config.get("batch_max_concurrency")
+        if limit is None:
+            return 0
+        try:
+            parsed = int(limit)
+        except (TypeError, ValueError):
+            return 0
+        return max(0, parsed)
+
     def get_cache_namespace(self) -> str:
         """Return cache namespace identifier for this tool."""
         return self.tool_config.get("name", self.__class__.__name__)
@@ -326,7 +337,7 @@ class BaseTool:
         """
         Get comprehensive information about this tool.
 
-        Returns:
+        Returns
             Dictionary containing tool metadata
         """
         return {

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

@@ -91,7 +91,7 @@ class Boltz2DockingTool(BaseTool):
                 - other optional boltz CLI flags (e.g., 'recycling_steps').
             timeout (int): The maximum time in seconds to wait for the Boltz command to complete.
 
-        Returns:
+        Returns
             dict: A dictionary containing the path to the predicted structure and affinity data, or an error.
         """
         arguments = arguments or {}
@@ -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)}"