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

tooluniverse/tools/ols_get_term_children.py

@@ -0,0 +1,67 @@
+"""
+ols_get_term_children
+
+Get child terms of a specific term in an ontology
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def ols_get_term_children(
+    operation: str,
+    term_iri: str,
+    ontology: str,
+    include_obsolete: Optional[bool] = False,
+    size: Optional[int] = 20,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Get child terms of a specific term in an ontology
+
+    Parameters
+    ----------
+    operation : str
+        The operation to perform (get_term_children)
+    term_iri : str
+        The IRI of the term to retrieve children for
+    ontology : str
+        The ontology ID
+    include_obsolete : bool
+        Include obsolete terms (default: false)
+    size : int
+        Number of results to return (default: 20)
+    stream_callback : Callable, optional
+        Callback for streaming output
+    use_cache : bool, default False
+        Enable caching
+    validate : bool, default True
+        Validate parameters
+
+    Returns
+    -------
+    Any
+    """
+    # Handle mutable defaults to avoid B006 linting error
+
+    return get_shared_client().run_one_function(
+        {
+            "name": "ols_get_term_children",
+            "arguments": {
+                "operation": operation,
+                "term_iri": term_iri,
+                "ontology": ontology,
+                "include_obsolete": include_obsolete,
+                "size": size,
+            },
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["ols_get_term_children"]

tooluniverse/tools/{TestCaseGenerator.py → ols_get_term_info.py}

@@ -1,27 +1,30 @@
 """
-TestCaseGenerator
+ols_get_term_info
 
-Generates diverse and representative ToolUniverse tool call dictionaries for a given tool based o...
+Get detailed information about a specific term in OLS
 """
 
 from typing import Any, Optional, Callable
 from ._shared_client import get_shared_client
 
 
-def TestCaseGenerator(
-    tool_config: dict[str, Any],
+def ols_get_term_info(
+    operation: str,
+    id: str,
     *,
     stream_callback: Optional[Callable[[str], None]] = None,
     use_cache: bool = False,
     validate: bool = True,
 ) -> Any:
     """
-    Generates diverse and representative ToolUniverse tool call dictionaries for a given tool based o...
+    Get detailed information about a specific term in OLS
 
     Parameters
     ----------
-    tool_config : dict[str, Any]
-        The full configuration of the tool to generate test cases for. May include '_...
+    operation : str
+        The operation to perform (get_term_info)
+    id : str
+        The ID or IRI of the term to retrieve
     stream_callback : Callable, optional
         Callback for streaming output
     use_cache : bool, default False
@@ -36,11 +39,11 @@ def TestCaseGenerator(
     # Handle mutable defaults to avoid B006 linting error
 
     return get_shared_client().run_one_function(
-        {"name": "TestCaseGenerator", "arguments": {"tool_config": tool_config}},
+        {"name": "ols_get_term_info", "arguments": {"operation": operation, "id": id}},
         stream_callback=stream_callback,
         use_cache=use_cache,
         validate=validate,
     )
 
 
-__all__ = ["TestCaseGenerator"]
+__all__ = ["ols_get_term_info"]

tooluniverse/tools/{CodeOptimizer.py → ols_search_ontologies.py}

@@ -1,30 +1,36 @@
 """
-CodeOptimizer
+ols_search_ontologies
 
-Optimizes code implementation for tools based on quality evaluation. Takes tool configuration and...
+Search for ontologies in OLS
 """
 
 from typing import Any, Optional, Callable
 from ._shared_client import get_shared_client
 
 
-def CodeOptimizer(
-    tool_config: str,
-    quality_evaluation: str,
+def ols_search_ontologies(
+    operation: str,
+    search: Optional[str] = None,
+    page: Optional[int] = 0,
+    size: Optional[int] = 20,
     *,
     stream_callback: Optional[Callable[[str], None]] = None,
     use_cache: bool = False,
     validate: bool = True,
 ) -> Any:
     """
-    Optimizes code implementation for tools based on quality evaluation. Takes tool configuration and...
+    Search for ontologies in OLS
 
     Parameters
     ----------
-    tool_config : str
-        JSON string containing the complete tool configuration including current impl...
-    quality_evaluation : str
-        JSON string containing quality evaluation results and feedback
+    operation : str
+        The operation to perform (search_ontologies)
+    search : str
+        Search query for ontologies (optional)
+    page : int
+        Page number (default: 0)
+    size : int
+        Number of results per page (default: 20)
     stream_callback : Callable, optional
         Callback for streaming output
     use_cache : bool, default False
@@ -40,10 +46,12 @@ def CodeOptimizer(
 
     return get_shared_client().run_one_function(
         {
-            "name": "CodeOptimizer",
+            "name": "ols_search_ontologies",
             "arguments": {
-                "tool_config": tool_config,
-                "quality_evaluation": quality_evaluation,
+                "operation": operation,
+                "search": search,
+                "page": page,
+                "size": size,
             },
         },
         stream_callback=stream_callback,
@@ -52,4 +60,4 @@ def CodeOptimizer(
     )
 
 
-__all__ = ["CodeOptimizer"]
+__all__ = ["ols_search_ontologies"]

tooluniverse/tools/ols_search_terms.py

@@ -0,0 +1,71 @@
+"""
+ols_search_terms
+
+Search for terms in OLS (Ontology Lookup Service)
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def ols_search_terms(
+    operation: str,
+    query: str,
+    rows: Optional[int] = 10,
+    ontology: Optional[str] = None,
+    exact_match: Optional[bool] = False,
+    include_obsolete: Optional[bool] = False,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Search for terms in OLS (Ontology Lookup Service)
+
+    Parameters
+    ----------
+    operation : str
+        The operation to perform (search_terms)
+    query : str
+        The search query for terms
+    rows : int
+        Number of results to return (default: 10)
+    ontology : str
+        Filter by specific ontology (optional)
+    exact_match : bool
+        Search for exact matches only (default: false)
+    include_obsolete : bool
+        Include obsolete terms (default: false)
+    stream_callback : Callable, optional
+        Callback for streaming output
+    use_cache : bool, default False
+        Enable caching
+    validate : bool, default True
+        Validate parameters
+
+    Returns
+    -------
+    Any
+    """
+    # Handle mutable defaults to avoid B006 linting error
+
+    return get_shared_client().run_one_function(
+        {
+            "name": "ols_search_terms",
+            "arguments": {
+                "operation": operation,
+                "query": query,
+                "rows": rows,
+                "ontology": ontology,
+                "exact_match": exact_match,
+                "include_obsolete": include_obsolete,
+            },
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["ols_search_terms"]

tooluniverse/tools/python_code_executor.py

@@ -0,0 +1,79 @@
+"""
+python_code_executor
+
+Execute Python code snippets safely in sandboxed environment with timeout and resource limits. Su...
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def python_code_executor(
+    code: str,
+    arguments: Optional[dict[str, Any]] = None,
+    timeout: Optional[int] = 30,
+    return_variable: Optional[str] = "result",
+    allowed_imports: Optional[list[Any]] = None,
+    dependencies: Optional[list[Any]] = None,
+    auto_install_dependencies: Optional[bool] = False,
+    require_confirmation: Optional[bool] = True,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> dict[str, Any]:
+    """
+    Execute Python code snippets safely in sandboxed environment with timeout and resource limits. Su...
+
+    Parameters
+    ----------
+    code : str
+        Python code to execute. Can use variables from 'arguments' parameter. Use 're...
+    arguments : dict[str, Any]
+        Variables to pass into execution environment as dictionary. Keys become varia...
+    timeout : int
+        Execution timeout in seconds
+    return_variable : str
+        Variable name to extract as result from the executed code
+    allowed_imports : list[Any]
+        Additional allowed modules beyond the default safe set (math, json, datetime,...
+    dependencies : list[Any]
+        List of Python packages that the code depends on. Will be checked and optiona...
+    auto_install_dependencies : bool
+        Whether to automatically install missing dependencies without user confirmation
+    require_confirmation : bool
+        Whether to require user confirmation before installing packages
+    stream_callback : Callable, optional
+        Callback for streaming output
+    use_cache : bool, default False
+        Enable caching
+    validate : bool, default True
+        Validate parameters
+
+    Returns
+    -------
+    dict[str, Any]
+    """
+    # Handle mutable defaults to avoid B006 linting error
+
+    return get_shared_client().run_one_function(
+        {
+            "name": "python_code_executor",
+            "arguments": {
+                "code": code,
+                "arguments": arguments,
+                "timeout": timeout,
+                "return_variable": return_variable,
+                "allowed_imports": allowed_imports,
+                "dependencies": dependencies,
+                "auto_install_dependencies": auto_install_dependencies,
+                "require_confirmation": require_confirmation,
+            },
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["python_code_executor"]

tooluniverse/tools/python_script_runner.py

@@ -0,0 +1,79 @@
+"""
+python_script_runner
+
+Run Python script files in isolated subprocess with resource limits and timeout. Supports command...
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def python_script_runner(
+    script_path: str,
+    script_args: Optional[list[Any]] = None,
+    timeout: Optional[int] = 60,
+    working_directory: Optional[str] = None,
+    env_vars: Optional[dict[str, Any]] = None,
+    dependencies: Optional[list[Any]] = None,
+    auto_install_dependencies: Optional[bool] = False,
+    require_confirmation: Optional[bool] = True,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> dict[str, Any]:
+    """
+    Run Python script files in isolated subprocess with resource limits and timeout. Supports command...
+
+    Parameters
+    ----------
+    script_path : str
+        Path to Python script file (.py) to execute
+    script_args : list[Any]
+        Command-line arguments to pass to the script
+    timeout : int
+        Execution timeout in seconds
+    working_directory : str
+        Working directory for script execution (defaults to script directory)
+    env_vars : dict[str, Any]
+        Environment variables to set for script execution
+    dependencies : list[Any]
+        List of Python packages that the script depends on. Will be checked and optio...
+    auto_install_dependencies : bool
+        Whether to automatically install missing dependencies without user confirmation
+    require_confirmation : bool
+        Whether to require user confirmation before installing packages
+    stream_callback : Callable, optional
+        Callback for streaming output
+    use_cache : bool, default False
+        Enable caching
+    validate : bool, default True
+        Validate parameters
+
+    Returns
+    -------
+    dict[str, Any]
+    """
+    # Handle mutable defaults to avoid B006 linting error
+
+    return get_shared_client().run_one_function(
+        {
+            "name": "python_script_runner",
+            "arguments": {
+                "script_path": script_path,
+                "script_args": script_args,
+                "timeout": timeout,
+                "working_directory": working_directory,
+                "env_vars": env_vars,
+                "dependencies": dependencies,
+                "auto_install_dependencies": auto_install_dependencies,
+                "require_confirmation": require_confirmation,
+            },
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["python_script_runner"]

tooluniverse/tools/web_api_documentation_search.py

@@ -0,0 +1,63 @@
+"""
+web_api_documentation_search
+
+Specialized web search for API documentation, Python packages, and technical resources using DDGS...
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def web_api_documentation_search(
+    query: str,
+    max_results: Optional[int] = 10,
+    focus: Optional[str] = "api_docs",
+    backend: Optional[str] = "auto",
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> dict[str, Any]:
+    """
+    Specialized web search for API documentation, Python packages, and technical resources using DDGS...
+
+    Parameters
+    ----------
+    query : str
+        Search query string (e.g., tool name, library name, API name)
+    max_results : int
+        Maximum number of results to return
+    focus : str
+        Focus area for the search
+    backend : str
+        Search engine backend to use
+    stream_callback : Callable, optional
+        Callback for streaming output
+    use_cache : bool, default False
+        Enable caching
+    validate : bool, default True
+        Validate parameters
+
+    Returns
+    -------
+    dict[str, Any]
+    """
+    # Handle mutable defaults to avoid B006 linting error
+
+    return get_shared_client().run_one_function(
+        {
+            "name": "web_api_documentation_search",
+            "arguments": {
+                "query": query,
+                "max_results": max_results,
+                "focus": focus,
+                "backend": backend,
+            },
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["web_api_documentation_search"]

tooluniverse/tools/web_search.py

@@ -0,0 +1,71 @@
+"""
+web_search
+
+General web search using DDGS (Dux Distributed Global Search) supporting multiple search engines ...
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def web_search(
+    query: str,
+    max_results: Optional[int] = 10,
+    search_type: Optional[str] = "general",
+    backend: Optional[str] = "auto",
+    region: Optional[str] = "us-en",
+    safesearch: Optional[str] = "moderate",
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> dict[str, Any]:
+    """
+    General web search using DDGS (Dux Distributed Global Search) supporting multiple search engines ...
+
+    Parameters
+    ----------
+    query : str
+        Search query string
+    max_results : int
+        Maximum number of results to return
+    search_type : str
+        Type of search to perform
+    backend : str
+        Search engine backend to use
+    region : str
+        Search region/locale
+    safesearch : str
+        Safe search level
+    stream_callback : Callable, optional
+        Callback for streaming output
+    use_cache : bool, default False
+        Enable caching
+    validate : bool, default True
+        Validate parameters
+
+    Returns
+    -------
+    dict[str, Any]
+    """
+    # Handle mutable defaults to avoid B006 linting error
+
+    return get_shared_client().run_one_function(
+        {
+            "name": "web_search",
+            "arguments": {
+                "query": query,
+                "max_results": max_results,
+                "search_type": search_type,
+                "backend": backend,
+                "region": region,
+                "safesearch": safesearch,
+            },
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["web_search"]