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

tooluniverse/tools/ReMap_get_transcription_factor_binding.py

@@ -0,0 +1,59 @@
+"""
+ReMap_get_transcription_factor_binding
+
+Get transcription factor binding sites from ReMap database for specific genes and cell types
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def ReMap_get_transcription_factor_binding(
+    gene_name: str,
+    cell_type: Optional[str] = "HepG2",
+    limit: Optional[int] = 10,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> dict[str, Any]:
+    """
+    Get transcription factor binding sites from ReMap database for specific genes and cell types
+
+    Parameters
+    ----------
+    gene_name : str
+        Gene symbol (e.g., BRCA1, TP53, MYC)
+    cell_type : str
+        Cell type (e.g., HepG2, K562, MCF-7)
+    limit : int
+        Number of results to return
+    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": "ReMap_get_transcription_factor_binding",
+            "arguments": {
+                "gene_name": gene_name,
+                "cell_type": cell_type,
+                "limit": limit,
+            },
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["ReMap_get_transcription_factor_binding"]

tooluniverse/tools/ReferenceInfoAnalyzer.py

@@ -0,0 +1,55 @@
+"""
+ReferenceInfoAnalyzer
+
+Analyzes and curates reference information to provide high-quality context for tool generation
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def ReferenceInfoAnalyzer(
+    tool_description: str,
+    raw_reference_info: str,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> dict[str, Any]:
+    """
+    Analyzes and curates reference information to provide high-quality context for tool generation
+
+    Parameters
+    ----------
+    tool_description : str
+        Description of the tool being generated
+    raw_reference_info : str
+        JSON string containing raw reference information from web search and package ...
+    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": "ReferenceInfoAnalyzer",
+            "arguments": {
+                "tool_description": tool_description,
+                "raw_reference_info": raw_reference_info,
+            },
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["ReferenceInfoAnalyzer"]

tooluniverse/tools/RegulomeDB_query_variant.py

@@ -0,0 +1,46 @@
+"""
+RegulomeDB_query_variant
+
+Query RegulomeDB for regulatory variant annotations using rsID
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def RegulomeDB_query_variant(
+    rsid: str,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> dict[str, Any]:
+    """
+    Query RegulomeDB for regulatory variant annotations using rsID
+
+    Parameters
+    ----------
+    rsid : str
+        dbSNP rsID (e.g., rs123456)
+    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": "RegulomeDB_query_variant", "arguments": {"rsid": rsid}},
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["RegulomeDB_query_variant"]

tooluniverse/tools/SCREEN_get_regulatory_elements.py

@@ -0,0 +1,59 @@
+"""
+SCREEN_get_regulatory_elements
+
+Get candidate cis-regulatory elements (cCREs) from SCREEN database for specific genomic regions
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def SCREEN_get_regulatory_elements(
+    gene_name: str,
+    element_type: Optional[str] = "enhancer",
+    limit: Optional[int] = 10,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> dict[str, Any]:
+    """
+    Get candidate cis-regulatory elements (cCREs) from SCREEN database for specific genomic regions
+
+    Parameters
+    ----------
+    gene_name : str
+        Gene symbol to search for regulatory elements (e.g., BRCA1, TP53)
+    element_type : str
+        Type of regulatory element (promoter, enhancer, insulator)
+    limit : int
+        Number of results to return
+    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": "SCREEN_get_regulatory_elements",
+            "arguments": {
+                "gene_name": gene_name,
+                "element_type": element_type,
+                "limit": limit,
+            },
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["SCREEN_get_regulatory_elements"]

tooluniverse/tools/{ArgumentDescriptionOptimizer.py → TestResultsAnalyzer.py}

@@ -1,30 +1,30 @@
 """
-ArgumentDescriptionOptimizer
+TestResultsAnalyzer
 
-Optimizes the descriptions of tool arguments/parameters based on test case results and actual usa...
+Analyzes test execution results and extracts key issues for targeted optimization
 """
 
 from typing import Any, Optional, Callable
 from ._shared_client import get_shared_client
 
 
-def ArgumentDescriptionOptimizer(
-    parameter_schema: str,
+def TestResultsAnalyzer(
     test_results: str,
+    tool_implementation: str,
     *,
     stream_callback: Optional[Callable[[str], None]] = None,
     use_cache: bool = False,
     validate: bool = True,
-) -> Any:
+) -> dict[str, Any]:
     """
-    Optimizes the descriptions of tool arguments/parameters based on test case results and actual usa...
+    Analyzes test execution results and extracts key issues for targeted optimization
 
     Parameters
     ----------
-    parameter_schema : str
-        JSON string of the original parameter schema with properties and descriptions.
     test_results : str
-        A JSON string containing test case input/output pairs showing parameter usage.
+        JSON string containing test execution results with pass/fail status, error me...
+    tool_implementation : str
+        Current tool implementation code for context
     stream_callback : Callable, optional
         Callback for streaming output
     use_cache : bool, default False
@@ -34,16 +34,16 @@ def ArgumentDescriptionOptimizer(
 
     Returns
     -------
-    Any
+    dict[str, Any]
     """
     # Handle mutable defaults to avoid B006 linting error
 
     return get_shared_client().run_one_function(
         {
-            "name": "ArgumentDescriptionOptimizer",
+            "name": "TestResultsAnalyzer",
             "arguments": {
-                "parameter_schema": parameter_schema,
                 "test_results": test_results,
+                "tool_implementation": tool_implementation,
             },
         },
         stream_callback=stream_callback,
@@ -52,4 +52,4 @@ def ArgumentDescriptionOptimizer(
     )
 
 
-__all__ = ["ArgumentDescriptionOptimizer"]
+__all__ = ["TestResultsAnalyzer"]

tooluniverse/tools/ToolDiscover.py

@@ -1,7 +1,7 @@
 """
 ToolDiscover
 
-Generates new ToolUniverse-compliant tools based on short descriptions through an intelligent dis...
+Generates new ToolUniverse-compliant tools based on short descriptions using XML format for simul...
 """
 
 from typing import Any, Optional, Callable
@@ -10,27 +10,27 @@ from ._shared_client import get_shared_client
 
 def ToolDiscover(
     tool_description: str,
-    max_iterations: int,
-    save_to_file: bool,
-    output_file: str,
+    max_iterations: Optional[int] = 2,
+    save_to_file: Optional[bool] = True,
+    output_file: Optional[str] = None,
     *,
     stream_callback: Optional[Callable[[str], None]] = None,
     use_cache: bool = False,
     validate: bool = True,
-) -> Any:
+) -> dict[str, Any]:
     """
-    Generates new ToolUniverse-compliant tools based on short descriptions through an intelligent dis...
+    Generates new ToolUniverse-compliant tools based on short descriptions using XML format for simul...
 
     Parameters
     ----------
     tool_description : str
-        Short description of the desired tool functionality and purpose. Tool Discove...
+        Short description of the desired tool functionality
     max_iterations : int
-        Maximum number of refinement iterations to perform.
+        Maximum number of optimization iterations
     save_to_file : bool
-        Whether to save the generated tool configuration and report to a file.
+        Whether to save the generated tool files
     output_file : str
-        Optional file path to save the generated tool. If not provided, uses auto-gen...
+        Optional file path to save the generated tool
     stream_callback : Callable, optional
         Callback for streaming output
     use_cache : bool, default False
@@ -40,7 +40,7 @@ def ToolDiscover(
 
     Returns
     -------
-    Any
+    dict[str, Any]
     """
     # Handle mutable defaults to avoid B006 linting error
 

tooluniverse/tools/UniProt_id_mapping.py

@@ -0,0 +1,63 @@
+"""
+UniProt_id_mapping
+
+Map IDs between different databases (e.g., Ensembl to UniProt, Gene Name to UniProt). Supports ba...
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def UniProt_id_mapping(
+    ids: str,
+    from_db: str,
+    to_db: Optional[str] = None,
+    max_wait_time: Optional[int] = None,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Map IDs between different databases (e.g., Ensembl to UniProt, Gene Name to UniProt). Supports ba...
+
+    Parameters
+    ----------
+    ids : str
+        ID(s) to map. Can be single string or array of strings, e.g., 'ENSG0000014151...
+    from_db : str
+        Source database. Examples: 'Ensembl', 'Gene_Name', 'RefSeq_Protein', 'PDB', '...
+    to_db : str
+        Target database (default: 'UniProtKB')
+    max_wait_time : int
+        Maximum time to wait for async task completion in seconds (default: 30)
+    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": "UniProt_id_mapping",
+            "arguments": {
+                "ids": ids,
+                "from_db": from_db,
+                "to_db": to_db,
+                "max_wait_time": max_wait_time,
+            },
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["UniProt_id_mapping"]

tooluniverse/tools/UniProt_search.py

@@ -0,0 +1,63 @@
+"""
+UniProt_search
+
+Search UniProtKB database using flexible query syntax. Supports gene names (e.g., 'gene:TP53'), p...
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def UniProt_search(
+    query: str,
+    organism: Optional[str] = None,
+    limit: Optional[int] = None,
+    fields: Optional[list[Any]] = None,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Search UniProtKB database using flexible query syntax. Supports gene names (e.g., 'gene:TP53'), p...
+
+    Parameters
+    ----------
+    query : str
+        Search query. Can be simple (e.g., 'MEIOB') or advanced ('gene:TP53 AND organ...
+    organism : str
+        Optional organism filter. Can use common name ('human') or taxonomy ID ('9606...
+    limit : int
+        Maximum number of results to return (default: 25, max: 500)
+    fields : list[Any]
+        Optional list of fields to return. Default returns: accession, id, protein_na...
+    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": "UniProt_search",
+            "arguments": {
+                "query": query,
+                "organism": organism,
+                "limit": limit,
+                "fields": fields,
+            },
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["UniProt_search"]

tooluniverse/tools/UnifiedToolGenerator.py

@@ -0,0 +1,59 @@
+"""
+UnifiedToolGenerator
+
+Generates complete ToolUniverse tools using simplified XML format that simultaneously creates bot...
+"""
+
+from typing import Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def UnifiedToolGenerator(
+    tool_description: str,
+    reference_info: str,
+    xml_template: str,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> str:
+    """
+    Generates complete ToolUniverse tools using simplified XML format that simultaneously creates bot...
+
+    Parameters
+    ----------
+    tool_description : str
+        Description of the desired tool functionality
+    reference_info : str
+        JSON string containing curated reference information including API documentat...
+    xml_template : str
+        XML template example showing the expected format with code and spec sections
+    stream_callback : Callable, optional
+        Callback for streaming output
+    use_cache : bool, default False
+        Enable caching
+    validate : bool, default True
+        Validate parameters
+
+    Returns
+    -------
+    str
+    """
+    # Handle mutable defaults to avoid B006 linting error
+
+    return get_shared_client().run_one_function(
+        {
+            "name": "UnifiedToolGenerator",
+            "arguments": {
+                "tool_description": tool_description,
+                "reference_info": reference_info,
+                "xml_template": xml_template,
+            },
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["UnifiedToolGenerator"]

tooluniverse/tools/WoRMS_search_species.py

@@ -0,0 +1,49 @@
+"""
+WoRMS_search_species
+
+Search marine species in World Register of Marine Species
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def WoRMS_search_species(
+    query: str,
+    limit: Optional[int] = 20,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> dict[str, Any]:
+    """
+    Search marine species in World Register of Marine Species
+
+    Parameters
+    ----------
+    query : str
+        Species name or search term
+    limit : int
+        Number of results
+    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": "WoRMS_search_species", "arguments": {"query": query, "limit": limit}},
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["WoRMS_search_species"]

tooluniverse/tools/XMLToolOptimizer.py

@@ -0,0 +1,55 @@
+"""
+XMLToolOptimizer
+
+Optimizes tools defined in XML format based on test results and quality feedback
+"""
+
+from typing import Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def XMLToolOptimizer(
+    xml_tool: str,
+    optimization_context: str,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> str:
+    """
+    Optimizes tools defined in XML format based on test results and quality feedback
+
+    Parameters
+    ----------
+    xml_tool : str
+        Current XML-formatted tool definition with code and spec sections
+    optimization_context : str
+        JSON string containing test results, quality feedback, iteration info, improv...
+    stream_callback : Callable, optional
+        Callback for streaming output
+    use_cache : bool, default False
+        Enable caching
+    validate : bool, default True
+        Validate parameters
+
+    Returns
+    -------
+    str
+    """
+    # Handle mutable defaults to avoid B006 linting error
+
+    return get_shared_client().run_one_function(
+        {
+            "name": "XMLToolOptimizer",
+            "arguments": {
+                "xml_tool": xml_tool,
+                "optimization_context": optimization_context,
+            },
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["XMLToolOptimizer"]