tooluniverse 1.0.6__py3-none-any.whl → 1.0.8__py3-none-any.whl

tooluniverse/tools/drugbank_links_search.py

@@ -0,0 +1,67 @@
+"""
+drugbank_links_search
+
+Search the cross-reference table linking DrugBank IDs to external identifiers (CAS, KEGG, PubChem...
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def drugbank_links_search(
+    query: str,
+    search_fields: list[Any],
+    case_sensitive: bool,
+    exact_match: bool,
+    limit: int,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> dict[str, Any]:
+    """
+    Search the cross-reference table linking DrugBank IDs to external identifiers (CAS, KEGG, PubChem...
+
+    Parameters
+    ----------
+    query : str
+        Free-text query (e.g. 'DB00002', 'Cetuximab').
+    search_fields : list[Any]
+        Columns to search. Choose from: 'DrugBank ID', 'Name', 'CAS Number', 'Drug Ty...
+    case_sensitive : bool
+        Match text with exact case if true.
+    exact_match : bool
+        Field value must equal query exactly if true; otherwise substring match.
+    limit : int
+        Maximum number of rows 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": "drugbank_links_search",
+            "arguments": {
+                "query": query,
+                "search_fields": search_fields,
+                "case_sensitive": case_sensitive,
+                "exact_match": exact_match,
+                "limit": limit,
+            },
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["drugbank_links_search"]

tooluniverse/tools/drugbank_vocab_filter.py

@@ -0,0 +1,63 @@
+"""
+drugbank_vocab_filter
+
+Filter the DrugBank vocabulary dataset based on specific field criteria. Use simple field-value p...
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def drugbank_vocab_filter(
+    field: str,
+    condition: str,
+    limit: int,
+    value: Optional[str] = None,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> dict[str, Any]:
+    """
+    Filter the DrugBank vocabulary dataset based on specific field criteria. Use simple field-value p...
+
+    Parameters
+    ----------
+    field : str
+        The field to filter on
+    condition : str
+        The type of filtering condition to apply. Filter is case-insensitive.
+    value : str
+        The value to filter by. Not required when condition is 'not_empty'. Examples:...
+    limit : int
+        Maximum 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": "drugbank_vocab_filter",
+            "arguments": {
+                "field": field,
+                "condition": condition,
+                "value": value,
+                "limit": limit,
+            },
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["drugbank_vocab_filter"]

tooluniverse/tools/drugbank_vocab_search.py

@@ -0,0 +1,67 @@
+"""
+drugbank_vocab_search
+
+Search the DrugBank vocabulary dataset for drugs by name, ID, synonyms, or other fields using tex...
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def drugbank_vocab_search(
+    query: str,
+    search_fields: list[Any],
+    case_sensitive: bool,
+    exact_match: bool,
+    limit: int,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> dict[str, Any]:
+    """
+    Search the DrugBank vocabulary dataset for drugs by name, ID, synonyms, or other fields using tex...
+
+    Parameters
+    ----------
+    query : str
+        Search query string. Can be drug name, synonym, DrugBank ID, or any text to s...
+    search_fields : list[Any]
+        Fields to search in. Available fields: 'DrugBank ID', 'Accession Numbers', 'C...
+    case_sensitive : bool
+        Whether the search should be case sensitive.
+    exact_match : bool
+        Whether to perform exact matching instead of substring matching.
+    limit : int
+        Maximum 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": "drugbank_vocab_search",
+            "arguments": {
+                "query": query,
+                "search_fields": search_fields,
+                "case_sensitive": case_sensitive,
+                "exact_match": exact_match,
+                "limit": limit,
+            },
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["drugbank_vocab_search"]

tooluniverse/tools/embedding_database_add.py

@@ -0,0 +1,63 @@
+"""
+embedding_database_add
+
+Add new documents to an existing embedding database. Generates embeddings for new documents using...
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def embedding_database_add(
+    action: str,
+    database_name: str,
+    documents: list[Any],
+    metadata: list[Any],
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Add new documents to an existing embedding database. Generates embeddings for new documents using...
+
+    Parameters
+    ----------
+    action : str
+        Action to add documents to existing database
+    database_name : str
+        Name of the existing database to add documents to
+    documents : list[Any]
+        List of new document texts to embed and add
+    metadata : list[Any]
+        Optional metadata for each new document (same length as documents)
+    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": "embedding_database_add",
+            "arguments": {
+                "action": action,
+                "database_name": database_name,
+                "documents": documents,
+                "metadata": metadata,
+            },
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["embedding_database_add"]

tooluniverse/tools/embedding_database_create.py

@@ -0,0 +1,71 @@
+"""
+embedding_database_create
+
+Create a new embedding database from a collection of documents. Generates embeddings using OpenAI...
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def embedding_database_create(
+    action: str,
+    database_name: str,
+    documents: list[Any],
+    metadata: list[Any],
+    model: str,
+    description: str,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Create a new embedding database from a collection of documents. Generates embeddings using OpenAI...
+
+    Parameters
+    ----------
+    action : str
+        Action to create database from documents
+    database_name : str
+        Name for the new database (must be unique)
+    documents : list[Any]
+        List of document texts to embed and store
+    metadata : list[Any]
+        Optional metadata for each document (same length as documents)
+    model : str
+        OpenAI/Azure OpenAI embedding model to use
+    description : str
+        Optional description for the database
+    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": "embedding_database_create",
+            "arguments": {
+                "action": action,
+                "database_name": database_name,
+                "documents": documents,
+                "metadata": metadata,
+                "model": model,
+                "description": description,
+            },
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["embedding_database_create"]

tooluniverse/tools/embedding_database_load.py

@@ -0,0 +1,63 @@
+"""
+embedding_database_load
+
+Load an existing embedding database from a local path or external source. Allows importing databa...
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def embedding_database_load(
+    action: str,
+    database_path: str,
+    database_name: str,
+    overwrite: bool,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Load an existing embedding database from a local path or external source. Allows importing databa...
+
+    Parameters
+    ----------
+    action : str
+        Action to load database from external source
+    database_path : str
+        Path to the existing database directory or file
+    database_name : str
+        Local name to assign to the loaded database
+    overwrite : bool
+        Whether to overwrite existing database with same name
+    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": "embedding_database_load",
+            "arguments": {
+                "action": action,
+                "database_path": database_path,
+                "database_name": database_name,
+                "overwrite": overwrite,
+            },
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["embedding_database_load"]

tooluniverse/tools/embedding_database_search.py

@@ -0,0 +1,67 @@
+"""
+embedding_database_search
+
+Search for semantically similar documents in an embedding database. Uses OpenAI embeddings to con...
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def embedding_database_search(
+    action: str,
+    database_name: str,
+    query: str,
+    top_k: int,
+    filters: dict[str, Any],
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Search for semantically similar documents in an embedding database. Uses OpenAI embeddings to con...
+
+    Parameters
+    ----------
+    action : str
+        Action to search the database
+    database_name : str
+        Name of the database to search in
+    query : str
+        Query text to find similar documents for
+    top_k : int
+        Number of most similar documents to return
+    filters : dict[str, Any]
+        Optional metadata filters to apply to search results
+    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": "embedding_database_search",
+            "arguments": {
+                "action": action,
+                "database_name": database_name,
+                "query": query,
+                "top_k": top_k,
+                "filters": filters,
+            },
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["embedding_database_search"]

tooluniverse/tools/embedding_sync_download.py

@@ -0,0 +1,63 @@
+"""
+embedding_sync_download
+
+Download an embedding database from HuggingFace Hub to local storage. Allows accessing databases ...
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def embedding_sync_download(
+    action: str,
+    repository: str,
+    local_name: str,
+    overwrite: bool,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Download an embedding database from HuggingFace Hub to local storage. Allows accessing databases ...
+
+    Parameters
+    ----------
+    action : str
+        Action to download database from HuggingFace
+    repository : str
+        HuggingFace repository to download from (format: username/repo-name)
+    local_name : str
+        Local name for the downloaded database (optional, defaults to repo name)
+    overwrite : bool
+        Whether to overwrite existing local database with same name
+    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": "embedding_sync_download",
+            "arguments": {
+                "action": action,
+                "repository": repository,
+                "local_name": local_name,
+                "overwrite": overwrite,
+            },
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["embedding_sync_download"]

tooluniverse/tools/embedding_sync_upload.py

@@ -0,0 +1,71 @@
+"""
+embedding_sync_upload
+
+Upload a local embedding database to HuggingFace Hub for sharing and collaboration. Creates a dat...
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def embedding_sync_upload(
+    action: str,
+    database_name: str,
+    repository: str,
+    description: str,
+    private: bool,
+    commit_message: str,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Upload a local embedding database to HuggingFace Hub for sharing and collaboration. Creates a dat...
+
+    Parameters
+    ----------
+    action : str
+        Action to upload database to HuggingFace
+    database_name : str
+        Name of the local database to upload
+    repository : str
+        HuggingFace repository name (format: username/repo-name)
+    description : str
+        Description for the HuggingFace dataset
+    private : bool
+        Whether to create a private repository
+    commit_message : str
+        Commit message for the upload
+    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": "embedding_sync_upload",
+            "arguments": {
+                "action": action,
+                "database_name": database_name,
+                "repository": repository,
+                "description": description,
+                "private": private,
+                "commit_message": commit_message,
+            },
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["embedding_sync_upload"]

tooluniverse/tools/enrichr_gene_enrichment_analysis.py

@@ -0,0 +1,52 @@
+"""
+enrichr_gene_enrichment_analysis
+
+Perform gene enrichment analysis using Enrichr to find biological pathways, processes, and molecu...
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def enrichr_gene_enrichment_analysis(
+    gene_list: list[Any],
+    libs: list[Any],
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Perform gene enrichment analysis using Enrichr to find biological pathways, processes, and molecu...
+
+    Parameters
+    ----------
+    gene_list : list[Any]
+        List of gene names or symbols to analyze. At least 2 genes are required for p...
+    libs : list[Any]
+        List of enrichment libraries to use for analysis.
+    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": "enrichr_gene_enrichment_analysis",
+            "arguments": {"gene_list": gene_list, "libs": libs},
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["enrichr_gene_enrichment_analysis"]

tooluniverse/tools/europepmc_disease_target_score.py

@@ -0,0 +1,52 @@
+"""
+europepmc_disease_target_score
+
+Extract disease-target association scores from Europe PMC literature. This includes literature-ba...
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def europepmc_disease_target_score(
+    efoId: str,
+    pageSize: int,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> dict[str, Any]:
+    """
+    Extract disease-target association scores from Europe PMC literature. This includes literature-ba...
+
+    Parameters
+    ----------
+    efoId : str
+        The EFO (Experimental Factor Ontology) ID of the disease, e.g., 'EFO_0000339'...
+    pageSize : int
+        Number of results per page (default: 100, max: 100)
+    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": "europepmc_disease_target_score",
+            "arguments": {"efoId": efoId, "pageSize": pageSize},
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["europepmc_disease_target_score"]