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

tooluniverse/tools/HypothesisGenerator.py

@@ -0,0 +1,63 @@
+"""
+HypothesisGenerator
+
+Generates research hypotheses based on provided background context, domain, and desired format. U...
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def HypothesisGenerator(
+    context: str,
+    domain: str,
+    number_of_hypotheses: str,
+    hypothesis_format: Optional[str] = "concise declarative sentences",
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Generates research hypotheses based on provided background context, domain, and desired format. U...
+
+    Parameters
+    ----------
+    context : str
+        Background information, observations, or data description from which to deriv...
+    domain : str
+        Field of study or research area (e.g., 'neuroscience', 'ecology', 'materials ...
+    number_of_hypotheses : str
+        Number of hypotheses to generate (e.g., '3', '5').
+    hypothesis_format : str
+        Optional directive on how to structure each hypothesis. Choose from one of th...
+    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": "HypothesisGenerator",
+            "arguments": {
+                "context": context,
+                "domain": domain,
+                "number_of_hypotheses": number_of_hypotheses,
+                "hypothesis_format": hypothesis_format,
+            },
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["HypothesisGenerator"]

tooluniverse/tools/LabelGenerator.py

@@ -0,0 +1,67 @@
+"""
+LabelGenerator
+
+Generates relevant keyword labels for tools based on their name, description, parameters, and cat...
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def LabelGenerator(
+    tool_name: str,
+    tool_description: str,
+    tool_parameters: str,
+    category: str,
+    existing_labels: Optional[str] = None,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Generates relevant keyword labels for tools based on their name, description, parameters, and cat...
+
+    Parameters
+    ----------
+    tool_name : str
+        The name of the tool
+    tool_description : str
+        Detailed description of what the tool does
+    tool_parameters : str
+        JSON string describing the tool's input parameters and their types
+    category : str
+        The general category or domain the tool belongs to
+    existing_labels : str
+        JSON array string of existing labels to consider reusing (optional)
+    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": "LabelGenerator",
+            "arguments": {
+                "tool_name": tool_name,
+                "tool_description": tool_description,
+                "tool_parameters": tool_parameters,
+                "category": category,
+                "existing_labels": existing_labels,
+            },
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["LabelGenerator"]

tooluniverse/tools/LiteratureContextReviewer.py

@@ -0,0 +1,55 @@
+"""
+LiteratureContextReviewer
+
+Reviews coverage, relevance, and critical synthesis of prior scholarship.
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def LiteratureContextReviewer(
+    paper_title: str,
+    literature_review: str,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Reviews coverage, relevance, and critical synthesis of prior scholarship.
+
+    Parameters
+    ----------
+    paper_title : str
+
+    literature_review : str
+        Full literature-review text
+    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": "LiteratureContextReviewer",
+            "arguments": {
+                "paper_title": paper_title,
+                "literature_review": literature_review,
+            },
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["LiteratureContextReviewer"]

tooluniverse/tools/LiteratureSearchTool.py

@@ -0,0 +1,49 @@
+"""
+LiteratureSearchTool
+
+Comprehensive literature search and summary tool that searches multiple databases (EuropePMC, Ope...
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def LiteratureSearchTool(
+    research_topic: str,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Comprehensive literature search and summary tool that searches multiple databases (EuropePMC, Ope...
+
+    Parameters
+    ----------
+    research_topic : str
+        The research topic or query to search for in the literature
+    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": "LiteratureSearchTool",
+            "arguments": {"research_topic": research_topic},
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["LiteratureSearchTool"]

tooluniverse/tools/LiteratureSynthesisAgent.py

@@ -0,0 +1,59 @@
+"""
+LiteratureSynthesisAgent
+
+AI agent that synthesizes literature findings and provides evidence-based insights
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def LiteratureSynthesisAgent(
+    topic: str,
+    literature_data: str,
+    focus_area: Optional[str] = "General",
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    AI agent that synthesizes literature findings and provides evidence-based insights
+
+    Parameters
+    ----------
+    topic : str
+        Research topic or question
+    literature_data : str
+        Literature findings or abstracts to synthesize
+    focus_area : str
+        Specific focus area for synthesis
+    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": "LiteratureSynthesisAgent",
+            "arguments": {
+                "topic": topic,
+                "literature_data": literature_data,
+                "focus_area": focus_area,
+            },
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["LiteratureSynthesisAgent"]

tooluniverse/tools/MedRxiv_search_preprints.py

@@ -0,0 +1,52 @@
+"""
+MedRxiv_search_preprints
+
+Search medRxiv preprints using the public medRxiv API. Returns preprints with title, authors, yea...
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def MedRxiv_search_preprints(
+    query: str,
+    max_results: int,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> list[Any]:
+    """
+    Search medRxiv preprints using the public medRxiv API. Returns preprints with title, authors, yea...
+
+    Parameters
+    ----------
+    query : str
+        Search query for medRxiv preprints. Use keywords separated by spaces to refin...
+    max_results : int
+        Maximum number of preprints to return. Default is 10, maximum is 200.
+    stream_callback : Callable, optional
+        Callback for streaming output
+    use_cache : bool, default False
+        Enable caching
+    validate : bool, default True
+        Validate parameters
+
+    Returns
+    -------
+    list[Any]
+    """
+    # Handle mutable defaults to avoid B006 linting error
+
+    return get_shared_client().run_one_function(
+        {
+            "name": "MedRxiv_search_preprints",
+            "arguments": {"query": query, "max_results": max_results},
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["MedRxiv_search_preprints"]

tooluniverse/tools/MedicalLiteratureReviewer.py

@@ -0,0 +1,71 @@
+"""
+MedicalLiteratureReviewer
+
+Conducts systematic reviews of medical literature on specific topics. Synthesizes findings from m...
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def MedicalLiteratureReviewer(
+    research_topic: str,
+    literature_content: str,
+    focus_area: str,
+    study_types: str,
+    quality_level: str,
+    review_scope: str,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Conducts systematic reviews of medical literature on specific topics. Synthesizes findings from m...
+
+    Parameters
+    ----------
+    research_topic : str
+        The specific medical/research topic for literature review (e.g., 'efficacy of...
+    literature_content : str
+        The literature content, abstracts, full studies, or research papers to review...
+    focus_area : str
+        Primary focus area for the review (e.g., 'therapeutic efficacy', 'safety prof...
+    study_types : str
+        Types of studies to prioritize in the analysis (e.g., 'randomized controlled ...
+    quality_level : str
+        Minimum evidence quality level to include (e.g., 'high quality only', 'modera...
+    review_scope : str
+        Scope of the review (e.g., 'comprehensive systematic review', 'rapid review',...
+    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": "MedicalLiteratureReviewer",
+            "arguments": {
+                "research_topic": research_topic,
+                "literature_content": literature_content,
+                "focus_area": focus_area,
+                "study_types": study_types,
+                "quality_level": quality_level,
+                "review_scope": review_scope,
+            },
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["MedicalLiteratureReviewer"]

tooluniverse/tools/MedicalTermNormalizer.py

@@ -0,0 +1,46 @@
+"""
+MedicalTermNormalizer
+
+Identifies and corrects misspelled drug or disease names, returning a list of plausible standardi...
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def MedicalTermNormalizer(
+    raw_terms: str,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Identifies and corrects misspelled drug or disease names, returning a list of plausible standardi...
+
+    Parameters
+    ----------
+    raw_terms : str
+        A comma- or whitespace-separated string containing one misspelled drug or dis...
+    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": "MedicalTermNormalizer", "arguments": {"raw_terms": raw_terms}},
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["MedicalTermNormalizer"]

tooluniverse/tools/MedlinePlus_connect_lookup_by_code.py

@@ -0,0 +1,67 @@
+"""
+MedlinePlus_connect_lookup_by_code
+
+Look up corresponding MedlinePlus page information through MedlinePlus Connect Web Service using ...
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def MedlinePlus_connect_lookup_by_code(
+    cs: str,
+    c: str,
+    dn: str,
+    language: str,
+    format: str,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Look up corresponding MedlinePlus page information through MedlinePlus Connect Web Service using ...
+
+    Parameters
+    ----------
+    cs : str
+        Code system OID, e.g., ICD-10 CM=2.16.840.1.113883.6.90, RXCUI=2.16.840.1.113...
+    c : str
+        Specific code value to query, e.g., "E11.9" (ICD-10 CM) or "637188" (RXCUI).
+    dn : str
+        Optional, descriptive name (English) corresponding to the code, for drugs can...
+    language : str
+        Return information language, "en" for English, "es" for Spanish, default "en".
+    format : str
+        Return format, options "json" or "xml", default "json".
+    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": "MedlinePlus_connect_lookup_by_code",
+            "arguments": {
+                "cs": cs,
+                "c": c,
+                "dn": dn,
+                "language": language,
+                "format": format,
+            },
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["MedlinePlus_connect_lookup_by_code"]

tooluniverse/tools/MedlinePlus_get_genetics_condition_by_name.py

@@ -0,0 +1,52 @@
+"""
+MedlinePlus_get_genetics_condition_by_name
+
+Get detailed information from MedlinePlus Genetics corresponding to genetic condition name, suppo...
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def MedlinePlus_get_genetics_condition_by_name(
+    condition: str,
+    format: str,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Get detailed information from MedlinePlus Genetics corresponding to genetic condition name, suppo...
+
+    Parameters
+    ----------
+    condition : str
+        URL slug of genetic condition, e.g., "alzheimer-disease", must match MedlineP...
+    format : str
+        Return format, options "json" or "xml", default "json".
+    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": "MedlinePlus_get_genetics_condition_by_name",
+            "arguments": {"condition": condition, "format": format},
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["MedlinePlus_get_genetics_condition_by_name"]

tooluniverse/tools/MedlinePlus_get_genetics_gene_by_name.py

@@ -0,0 +1,52 @@
+"""
+MedlinePlus_get_genetics_gene_by_name
+
+Get detailed information from MedlinePlus Genetics corresponding to gene name, supports JSON or X...
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def MedlinePlus_get_genetics_gene_by_name(
+    gene: str,
+    format: str,
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Get detailed information from MedlinePlus Genetics corresponding to gene name, supports JSON or X...
+
+    Parameters
+    ----------
+    gene : str
+        URL slug of gene name, e.g., "BRCA1", must match MedlinePlus page path.
+    format : str
+        Return format, options "json" or "xml", default "json".
+    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": "MedlinePlus_get_genetics_gene_by_name",
+            "arguments": {"gene": gene, "format": format},
+        },
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["MedlinePlus_get_genetics_gene_by_name"]

tooluniverse/tools/MedlinePlus_get_genetics_index.py

@@ -0,0 +1,44 @@
+"""
+MedlinePlus_get_genetics_index
+
+Download index file (XML) of all genetics entries in MedlinePlus, get complete list in one call.
+"""
+
+from typing import Any, Optional, Callable
+from ._shared_client import get_shared_client
+
+
+def MedlinePlus_get_genetics_index(
+    *,
+    stream_callback: Optional[Callable[[str], None]] = None,
+    use_cache: bool = False,
+    validate: bool = True,
+) -> Any:
+    """
+    Download index file (XML) of all genetics entries in MedlinePlus, get complete list in one call.
+
+    Parameters
+    ----------
+    No 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": "MedlinePlus_get_genetics_index", "arguments": {}},
+        stream_callback=stream_callback,
+        use_cache=use_cache,
+        validate=validate,
+    )
+
+
+__all__ = ["MedlinePlus_get_genetics_index"]