tooluniverse 1.0.5__py3-none-any.whl → 1.0.7__py3-none-any.whl

tooluniverse/tools/OpenTargets_get_target_genomic_location_by_ensemblID.py

@@ -0,0 +1,49 @@
+"""
+OpenTargets_get_target_genomic_location_by_ensemblID
+
+Retrieve genomic location data for a specific target, including chromosome, start, end, and strand.
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def OpenTargets_get_target_genomic_location_by_ensemblID(
+    ensemblId: str,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Retrieve genomic location data for a specific target, including chromosome, start, end, and strand.
+
+    Parameters
+    ----------
+    ensemblId : str
+        The Ensembl ID of the target for which to retrieve genomic location information.
+    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": "OpenTargets_get_target_genomic_location_by_ensemblID",
+            "arguments": {"ensemblId": ensemblId},
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["OpenTargets_get_target_genomic_location_by_ensemblID"]

tooluniverse/tools/OpenTargets_get_target_homologues_by_ensemblID.py

@@ -0,0 +1,49 @@
+"""
+OpenTargets_get_target_homologues_by_ensemblID
+
+Fetch homologues for a specific target by Ensembl ID.
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def OpenTargets_get_target_homologues_by_ensemblID(
+    ensemblId: str,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Fetch homologues for a specific target by Ensembl ID.
+
+    Parameters
+    ----------
+    ensemblId : str
+        The Ensembl ID of the target for which to retrieve homologues.
+    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": "OpenTargets_get_target_homologues_by_ensemblID",
+            "arguments": {"ensemblId": ensemblId},
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["OpenTargets_get_target_homologues_by_ensemblID"]

tooluniverse/tools/OpenTargets_get_target_id_description_by_name.py

@@ -0,0 +1,49 @@
+"""
+OpenTargets_get_target_id_description_by_name
+
+Get the ensemblId and description based on the target name.
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def OpenTargets_get_target_id_description_by_name(
+    targetName: str,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Get the ensemblId and description based on the target name.
+
+    Parameters
+    ----------
+    targetName : str
+        The name of the target for which the ID is required.
+    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": "OpenTargets_get_target_id_description_by_name",
+            "arguments": {"targetName": targetName},
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["OpenTargets_get_target_id_description_by_name"]

tooluniverse/tools/OpenTargets_get_target_interactions_by_ensemblID.py

@@ -0,0 +1,52 @@
+"""
+OpenTargets_get_target_interactions_by_ensemblID
+
+Retrieve interaction data for a specific target ensemblID, including interaction partners and evi...
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def OpenTargets_get_target_interactions_by_ensemblID(
+    ensemblId: str,
+    page: Optional[dict[str, Any]] = None,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Retrieve interaction data for a specific target ensemblID, including interaction partners and evi...
+
+    Parameters
+    ----------
+    ensemblId : str
+        The Ensembl ID of the target.
+    page : dict[str, Any]
+        Pagination parameters.
+    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": "OpenTargets_get_target_interactions_by_ensemblID",
+            "arguments": {"ensemblId": ensemblId, "page": page},
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["OpenTargets_get_target_interactions_by_ensemblID"]

tooluniverse/tools/OpenTargets_get_target_safety_profile_by_ensemblID.py

@@ -0,0 +1,49 @@
+"""
+OpenTargets_get_target_safety_profile_by_ensemblID
+
+Retrieve known target safety liabilities for a specific target Ensembl ID.
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def OpenTargets_get_target_safety_profile_by_ensemblID(
+    ensemblId: str,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Retrieve known target safety liabilities for a specific target Ensembl ID.
+
+    Parameters
+    ----------
+    ensemblId : str
+        The Ensembl ID of the target for which to retrieve safety liabilities.
+    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": "OpenTargets_get_target_safety_profile_by_ensemblID",
+            "arguments": {"ensemblId": ensemblId},
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["OpenTargets_get_target_safety_profile_by_ensemblID"]

tooluniverse/tools/OpenTargets_get_target_subcellular_locations_by_ensemblID.py

@@ -0,0 +1,49 @@
+"""
+OpenTargets_get_target_subcellular_locations_by_ensemblID
+
+Retrieve information about subcellular locations for a specific target ensemblID.
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def OpenTargets_get_target_subcellular_locations_by_ensemblID(
+    ensemblId: str,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Retrieve information about subcellular locations for a specific target ensemblID.
+
+    Parameters
+    ----------
+    ensemblId : str
+        The ensemblId of a target.
+    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": "OpenTargets_get_target_subcellular_locations_by_ensemblID",
+            "arguments": {"ensemblId": ensemblId},
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["OpenTargets_get_target_subcellular_locations_by_ensemblID"]

tooluniverse/tools/OpenTargets_get_target_synonyms_by_ensemblID.py

@@ -0,0 +1,49 @@
+"""
+OpenTargets_get_target_synonyms_by_ensemblID
+
+Retrieve synonyms for specified target, including alternative names and symbols, using given ense...
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def OpenTargets_get_target_synonyms_by_ensemblID(
+    ensemblId: str,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Retrieve synonyms for specified target, including alternative names and symbols, using given ense...
+
+    Parameters
+    ----------
+    ensemblId : str
+        The Ensembl ID of the target.
+    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": "OpenTargets_get_target_synonyms_by_ensemblID",
+            "arguments": {"ensemblId": ensemblId},
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["OpenTargets_get_target_synonyms_by_ensemblID"]

tooluniverse/tools/OpenTargets_get_target_tractability_by_ensemblID.py

@@ -0,0 +1,49 @@
+"""
+OpenTargets_get_target_tractability_by_ensemblID
+
+Retrieve tractability assessments, including modality and values, for a specific target ensembl ID.
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def OpenTargets_get_target_tractability_by_ensemblID(
+    ensemblId: str,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Retrieve tractability assessments, including modality and values, for a specific target ensembl ID.
+
+    Parameters
+    ----------
+    ensemblId : str
+        The Ensembl ID of the target.
+    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": "OpenTargets_get_target_tractability_by_ensemblID",
+            "arguments": {"ensemblId": ensemblId},
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["OpenTargets_get_target_tractability_by_ensemblID"]

tooluniverse/tools/OpenTargets_map_any_disease_id_to_all_other_ids.py

@@ -0,0 +1,49 @@
+"""
+OpenTargets_map_any_disease_id_to_all_other_ids
+
+Given any known disease or phenotype ID (EFO, OMIM, MONDO, UMLS, ICD10, MedDRA, etc.), return all...
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def OpenTargets_map_any_disease_id_to_all_other_ids(
+    inputId: str,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Given any known disease or phenotype ID (EFO, OMIM, MONDO, UMLS, ICD10, MedDRA, etc.), return all...
+
+    Parameters
+    ----------
+    inputId : str
+        Any known disease ID (e.g. OMIM:604302, UMLS:C0003873, ICD10:M05, EFO_0000685...
+    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": "OpenTargets_map_any_disease_id_to_all_other_ids",
+            "arguments": {"inputId": inputId},
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["OpenTargets_map_any_disease_id_to_all_other_ids"]

tooluniverse/tools/OpenTargets_multi_entity_search_by_query_string.py

@@ -0,0 +1,59 @@
+"""
+OpenTargets_multi_entity_search_by_query_string
+
+Perform a multi-entity search based on a query string, filtering by entity names and pagination s...
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def OpenTargets_multi_entity_search_by_query_string(
+    queryString: str,
+    entityNames: Optional[list[Any]] = None,
+    page: Optional[dict[str, Any]] = None,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Perform a multi-entity search based on a query string, filtering by entity names and pagination s...
+
+    Parameters
+    ----------
+    queryString : str
+        The search string for querying information.
+    entityNames : list[Any]
+        List of entity names to search for (e.g., target, disease, drug).
+    page : dict[str, Any]
+        Pagination settings with index and size.
+    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": "OpenTargets_multi_entity_search_by_query_string",
+            "arguments": {
+                "queryString": queryString,
+                "entityNames": entityNames,
+                "page": page,
+            },
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["OpenTargets_multi_entity_search_by_query_string"]

tooluniverse/tools/OpenTargets_search_category_counts_by_query_string.py

@@ -0,0 +1,49 @@
+"""
+OpenTargets_search_category_counts_by_query_string
+
+Get the count of entries in each entity category (disease, target, drug) based on a query string.
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def OpenTargets_search_category_counts_by_query_string(
+    queryString: str,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Get the count of entries in each entity category (disease, target, drug) based on a query string.
+
+    Parameters
+    ----------
+    queryString : str
+        The search string for querying information.
+    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": "OpenTargets_search_category_counts_by_query_string",
+            "arguments": {"queryString": queryString},
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["OpenTargets_search_category_counts_by_query_string"]

tooluniverse/tools/OpenTargets_target_disease_evidence.py

@@ -0,0 +1,52 @@
+"""
+OpenTargets_target_disease_evidence
+
+Explore evidence that supports a specific target-disease association. Input is disease efoId and ...
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def OpenTargets_target_disease_evidence(
+    efoId: str,
+    ensemblId: str,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Explore evidence that supports a specific target-disease association. Input is disease efoId and ...
+
+    Parameters
+    ----------
+    efoId : str
+        The efoId of a disease or phenotype.
+    ensemblId : str
+        The ensemblId of a target.
+    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": "OpenTargets_target_disease_evidence",
+            "arguments": {"efoId": efoId, "ensemblId": ensemblId},
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["OpenTargets_target_disease_evidence"]

tooluniverse/tools/OutputSummarizationComposer.py

@@ -0,0 +1,71 @@
+"""
+OutputSummarizationComposer
+
+Composes output summarization workflow by chunking long outputs, processing each chunk with AI su...
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def OutputSummarizationComposer(
+    tool_output: str,
+    query_context: str,
+    tool_name: str,
+    chunk_size: Optional[int] = 30000,
+    focus_areas: Optional[str] = "key_findings_and_results",
+    max_summary_length: Optional[int] = 10000,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Composes output summarization workflow by chunking long outputs, processing each chunk with AI su...
+
+    Parameters
+    ----------
+    tool_output : str
+        The original tool output to be summarized
+    query_context : str
+        Context about the original query
+    tool_name : str
+        Name of the tool that generated the output
+    chunk_size : int
+        Size of each chunk for processing
+    focus_areas : str
+        Areas to focus on in summarization
+    max_summary_length : int
+        Maximum length of final summary
+    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": "OutputSummarizationComposer",
+            "arguments": {
+                "tool_output": tool_output,
+                "query_context": query_context,
+                "tool_name": tool_name,
+                "chunk_size": chunk_size,
+                "focus_areas": focus_areas,
+                "max_summary_length": max_summary_length,
+            },
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["OutputSummarizationComposer"]