waldiez 0.4.7__py3-none-any.whl → 0.4.8__py3-none-any.whl

waldiez/exporting/flow/utils/agent_utils.py

@@ -1,204 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0.
-# Copyright (c) 2024 - 2025 Waldiez and contributors.
-"""Handle agent contents before and after the agent(s) exports."""
-
-from typing import List, Tuple, Union
-
-from waldiez.exporting.base import (
-    AgentPosition,
-    AgentPositions,
-    ExporterReturnType,
-    ExportPosition,
-)
-from waldiez.models import WaldiezAgent
-
-
-def add_after_all_agents_content(
-    agents_contents: str,
-    after_export: List[Tuple[str, Union[ExportPosition, AgentPosition]]],
-) -> str:
-    """Add the after all agents content.
-
-    Parameters
-    ----------
-    agents_contents : str
-        The agents content.
-    after_export : List[Tuple[str, Union[ExportPosition, AgentPosition]]]
-        The after export.
-
-    Returns
-    -------
-    str
-        The agents content with the after all agents content.
-    """
-    new_content = str(agents_contents)
-    # let's get the list first, and sort it by the order
-    after_all_agent_exports = [
-        (content, position)
-        for content, position in after_export
-        if isinstance(position, AgentPosition)
-        and position.position == AgentPositions.AFTER_ALL
-    ]
-    by_order = sorted(after_all_agent_exports, key=lambda x: x[1].order)
-    for content, _ in by_order:
-        new_content += content + "\n"
-    if not new_content.endswith("\n"):
-        new_content += "\n"
-    return new_content
-
-
-def add_before_all_agents_content(
-    agents_contents: str,
-    before_export: List[Tuple[str, Union[ExportPosition, AgentPosition]]],
-) -> str:
-    """Add the before all agents content.
-
-    Parameters
-    ----------
-    agents_contents : str
-        The agents content.
-    before_export : List[Tuple[str, Union[ExportPosition, AgentPosition]]]
-        The before export.
-
-    Returns
-    -------
-    str
-        The agents content with the before all agents content.
-    """
-    new_content = str(agents_contents)
-    before_all_agents_exports = [
-        (content, position)
-        for content, position in before_export
-        if isinstance(position, AgentPosition)
-        and position.position == AgentPositions.BEFORE_ALL
-    ]
-    for content, _ in before_all_agents_exports:
-        new_content = content + "\n" + new_content
-    if not new_content.startswith("\n"):
-        new_content = "\n" + new_content
-    return new_content
-
-
-def add_before_agent_content(
-    agent_content: str,
-    before_export: List[Tuple[str, Union[ExportPosition, AgentPosition]]],
-    agent: WaldiezAgent,
-) -> str:
-    """Add the before agent content.
-
-    Parameters
-    ----------
-    agent_content : str
-        The agent content.
-    before_export : List[Tuple[str, Union[ExportPosition, AgentPosition]]]
-        The before export.
-    agent : WaldiezAgent
-        The agent.
-
-    Returns
-    -------
-    str
-        The agent content with the before agent content.
-    """
-    new_content = str(agent_content)
-    for content, position in before_export:
-        if (
-            isinstance(position, AgentPosition)
-            and position.agent == agent
-            and position.position == AgentPositions.BEFORE
-        ):
-            new_content = content + "\n" + new_content
-    if not new_content.startswith("\n"):
-        new_content = "\n" + new_content
-    return new_content
-
-
-def add_after_agent_content(
-    agent_content: str,
-    after_export: List[Tuple[str, Union[ExportPosition, AgentPosition]]],
-    agent: WaldiezAgent,
-) -> str:
-    """Add the after agent content.
-
-    Parameters
-    ----------
-    agent_content : str
-        The agent content.
-    after_export : List[Tuple[str, Union[ExportPosition, AgentPosition]]]
-        The after export.
-    agent : WaldiezAgent
-        The agent.
-
-    Returns
-    -------
-    str
-        The agent content with the after agent content.
-    """
-    new_content = str(agent_content)
-    for content, position in after_export:
-        if (
-            isinstance(position, AgentPosition)
-            and position.agent == agent
-            and position.position == AgentPositions.AFTER
-        ):
-            new_content += content + "\n"
-    if not new_content.endswith("\n"):
-        new_content += "\n"
-    return new_content
-
-
-def gather_agent_outputs(
-    before_export: List[Tuple[str, Union[ExportPosition, AgentPosition]]],
-    after_export: List[Tuple[str, Union[ExportPosition, AgentPosition]]],
-    agent_outputs: List[ExporterReturnType],
-) -> ExporterReturnType:
-    """Gather all the agent outputs.
-
-    Parameters
-    ----------
-    before_export : List[Tuple[str, Union[ExportPosition, AgentPosition]]]
-        The before export.
-    after_export : List[Tuple[str, Union[ExportPosition, AgentPosition]]]
-        The after export.
-    agent_outputs : List[ExporterReturnType]
-        The agent outputs.
-
-    Returns
-    -------
-    ExporterReturnType
-        The gathered agent outputs.
-    """
-    agents_contents = ""
-    agents_imports = []
-    agents_before_export = []
-    agents_after_export = []
-    agents_env_vars = []
-    for output in agent_outputs:
-        if output["content"]:
-            agents_contents += output["content"]
-        if output["imports"]:
-            agents_imports.extend(output["imports"])
-        if output["before_export"]:
-            agents_before_export.extend(output["before_export"])
-        if output["after_export"]:
-            agents_after_export.extend(output["after_export"])
-        if output["environment_variables"]:
-            agents_env_vars.extend(output["environment_variables"])
-    agents_contents = add_before_all_agents_content(
-        agents_contents,
-        before_export,
-    )
-    agents_contents = add_after_all_agents_content(
-        agents_contents,
-        after_export,
-    )
-    agents_contents = agents_contents.replace("\n\n\n\n", "\n\n\n")
-    while agents_contents.endswith("\n\n\n"):
-        agents_contents = agents_contents[: -len("\n")]
-    return {
-        "content": agents_contents,
-        "imports": agents_imports,
-        "before_export": agents_before_export,
-        "after_export": agents_after_export,
-        "environment_variables": agents_env_vars,
-    }

waldiez/exporting/flow/utils/chat_utils.py

@@ -1,71 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0.
-# Copyright (c) 2024 - 2025 Waldiez and contributors.
-"""Utilities for chat content after exporting."""
-
-from typing import List, Tuple, Union
-
-from waldiez.exporting.base import (
-    AgentPosition,
-    ExportPosition,
-    ExportPositions,
-)
-
-
-def add_before_chat_content(
-    chat_content: str,
-    before_export: List[Tuple[str, Union[ExportPosition, AgentPosition]]],
-) -> str:
-    """Add the before chat content.
-
-    Parameters
-    ----------
-    chat_content : str
-        The chat content.
-    before_export : List[Tuple[str, Union[ExportPosition, AgentPosition]]]
-        The before export.
-
-    Returns
-    -------
-    str
-        The chat content with the before chat content.
-    """
-    new_content = str(chat_content)
-    for content, position in before_export:
-        if (
-            isinstance(position, ExportPosition)
-            and position.position == ExportPositions.CHATS
-        ):
-            new_content = content + "\n" + new_content
-    if not new_content.endswith("\n"):
-        new_content += "\n"
-    return new_content
-
-
-def add_after_chat_content(
-    chat_content: str,
-    after_export: List[Tuple[str, Union[ExportPosition, AgentPosition]]],
-) -> str:
-    """Add the after chat content.
-
-    Parameters
-    ----------
-    chat_content : str
-        The chat content.
-    after_export : List[Tuple[str, Union[ExportPosition, AgentPosition]]]
-        The after export.
-
-    Returns
-    -------
-    str
-        The chat content with the after chat content.
-    """
-    new_content = str(chat_content)
-    for content, position in after_export:
-        if (
-            isinstance(position, ExportPosition)
-            and position.position == ExportPositions.CHATS
-        ):
-            new_content += content + "\n"
-    if not new_content.endswith("\n"):
-        new_content += "\n"
-    return new_content

waldiez/exporting/flow/utils/def_main.py

@@ -1,77 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0.
-# Copyright (c) 2024 - 2025 Waldiez and contributors.
-# flake8: noqa: E501
-# pylint: disable=inconsistent-quotes, line-too-long
-"""Get the main function."""
-
-from typing import Optional
-
-
-def get_def_main(
-    flow_chats: str, after_run: str, is_async: bool, cache_seed: Optional[int]
-) -> str:
-    """Get the main function.
-
-    When exporting to python, waldiez_chats string will be the
-    content of the main function. It contains either a
-    `{sender.initiate_chat(recipient, ...)}` (if there is only one chat)
-    or `initiate_chats([..])`, with the list of chats to initiate.
-    If async: (sender.a_initiate_chat, a_initiate_chats)
-
-    Parameters
-    ----------
-    flow_chats : str
-        The content of the main function.
-    after_run : str
-        The content after the run of the flow.
-    is_async : bool
-        Whether the main function is asynchronous.
-    cache_seed : Optional[int]
-        The seed for the cache. If None, cache should be disabled.
-
-    Returns
-    -------
-    str
-        The main function.
-    """
-    if flow_chats.startswith("\n"):
-        flow_chats = flow_chats[1:]
-    content = ""
-    if is_async:
-        content += "async "
-    content += "def main() -> Union[ChatResult, List[ChatResult], Dict[int, ChatResult]]:\n"
-    content += '    """Start chatting."""\n'
-    content += f"    with Cache.disk(cache_seed={cache_seed}" + ") as cache:\n"
-    content += f"{flow_chats}" + "\n"
-    if is_async:
-        content += "    await stop_logging()"
-    else:
-        content += "    stop_logging()"
-    content += after_run
-    content += "\n    return results\n\n\n"
-    if is_async:
-        content += "async def call_main():\n"
-    else:
-        content += "def call_main() -> None:\n"
-    content += '    """Run the main function and print the results."""\n'
-    content += "    results: Union[ChatResult, List[ChatResult], Dict[int, ChatResult]] = "
-    if is_async:
-        content += "await "
-    content += "main()\n"
-    content += "    if isinstance(results, dict):\n"
-    content += "        # order by key\n"
-    content += "        ordered_results = dict(sorted(results.items()))\n"
-    content += "        for _, result in ordered_results.items():\n"
-    content += "            pprint(asdict(result))\n"
-    content += "    else:\n"
-    content += "        if not isinstance(results, list):\n"
-    content += "            results = [results]\n"
-    content += "        for result in results:\n"
-    content += "            pprint(asdict(result))\n"
-    content += "\n\n"
-    content += 'if __name__ == "__main__":\n'
-    if is_async:
-        content += "    anyio.run(call_main)\n"
-    else:
-        content += "    call_main()\n"
-    return content

waldiez/exporting/flow/utils/flow_content.py

@@ -1,202 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0.
-# Copyright (c) 2024 - 2025 Waldiez and contributors.
-# flake8: noqa: E501
-# pylint: disable=line-too-long
-"""Utils to generate the content of a flow."""
-
-from typing import Callable, Dict, List, Optional
-
-from waldiez.models import Waldiez
-
-
-def get_py_content_start(waldiez: Waldiez) -> str:
-    """Get the first part of the python script.
-
-    Parameters
-    ----------
-    waldiez : Waldiez
-        The waldiez object.
-
-    Returns
-    -------
-    str
-        The first part of the python script.
-    """
-    content = "#!/usr/bin/env python\n"
-    content += "# flake8: noqa: E501\n"
-    content += get_pylint_ignore_comment(False)
-    content += "# cspell: disable\n"
-    content += f'"""{waldiez.name}.' + "\n\n"
-    content += f"{waldiez.description}" + "\n\n"
-    tags = ", ".join(waldiez.tags)
-    content += f"Tags: {tags}" + "\n\n"
-    requirements = " ".join(waldiez.requirements)
-    content += f"Requirements: {requirements}" + "\n\n"
-    content += '"""\n\n'
-    return content
-
-
-def get_ipynb_content_start(
-    waldiez: Waldiez, comment: Callable[[bool, int], str]
-) -> str:
-    """Get the first part of the ipynb file.
-
-    Parameters
-    ----------
-    waldiez : Waldiez
-        The waldiez object.
-    comment : Callable[[bool, int], str]
-        The function to create a comment.
-
-    Returns
-    -------
-    str
-        The first part of the ipynb file.
-    """
-    content = f"{comment(True, 1)}{waldiez.name}." + "\n\n"
-    content += f"{comment(True, 2)}{waldiez.description}" + "\n\n"
-    content += f"{comment(True, 2)}Dependencies" + "\n\n"
-    content += "import sys\n"
-    requirements = " ".join(waldiez.requirements)
-    if requirements:
-        # fmt: off
-        content += "# " + f"!{{sys.executable}} -m pip install -q {requirements}" + "\n"
-        # fmt: on
-    content += "# flake8: noqa: E501"
-    content += get_pylint_ignore_comment(True)
-    content += "# cspell: disable\n"
-    return content
-
-
-PYLINT_RULES = [
-    "line-too-long",
-    "unknown-option-value",
-    "unused-argument",
-    "unused-import",
-    "unused-variable",
-    "invalid-name",
-    "import-error",
-    "inconsistent-quotes",
-    "missing-function-docstring",
-    "missing-param-doc",
-    "missing-return-doc",
-    "ungrouped-imports",
-]
-
-
-def get_pylint_ignore_comment(
-    notebook: bool, rules: Optional[List[str]] = None
-) -> str:
-    """Get the pylint ignore comment string.
-
-    Parameters
-    ----------
-    notebook : bool
-        Whether the comment is for a notebook.
-    rules : Optional[List[str]], optional
-        The pylint rules to ignore, by default None.
-
-    Returns
-    -------
-    str
-        The pylint ignore comment string.
-
-    Example
-    -------
-    ```python
-    >>> get_pylint_ignore_comment(True, ["invalid-name", "line-too-long"])
-
-    # pylint: disable=invalid-name, line-too-long
-    ```
-    """
-    if not rules:
-        rules = PYLINT_RULES
-    line = "# pylint: disable=" + ",".join(rules)
-    if notebook is True:
-        line = "\n" + line
-    return line + "\n"
-
-
-def get_after_run_content(
-    waldiez: Waldiez,
-    agent_names: Dict[str, str],
-    tabs: int,
-) -> str:
-    """Get content to add after the flow is run.
-
-    Parameters
-    ----------
-    waldiez : Waldiez
-        The waldiez object.
-    agent_names : Dict[str, str]
-        The dictionary of agent names and their corresponding ids
-    tabs : int
-        The number of tabs to add before the content.
-
-    Returns
-    -------
-    str
-        The content to add after the flow is run.
-    """
-    # if the flow has a reasoning agents, we add
-    # agent.visualize_tree() for each agent
-    content = ""
-    tab = "    "
-    space = tab * tabs
-    for agent in waldiez.agents:
-        if agent.agent_type == "reasoning":
-            agent_name = agent_names[agent.id]
-            content += f"""
-{space}# pylint: disable=broad-except,too-many-try-statements
-{space}try:
-{space}{tab}{agent_name}.visualize_tree()
-{space}{tab}if os.path.exists("tree_of_thoughts.png"):
-{space}{tab}{tab}new_name = "{agent_name}_tree_of_thoughts.png"
-{space}{tab}{tab}os.rename("tree_of_thoughts.png", new_name)
-{space}except BaseException:
-{space}{tab}pass
-{space}# save the tree to json
-{space}try:
-{space}{tab}data = {agent_name}._root.to_dict()  # pylint: disable=protected-access
-{space}{tab}with open("{agent_name}_reasoning_tree.json", "w", encoding="utf-8") as f:
-{space}{tab}{tab}json.dump(data, f)
-{space}except BaseException:
-{space}{tab}pass
-"""
-    return content
-
-
-def get_np_no_nep50_handle() -> str:
-    """Handle catching the "module numpy has no attribute _no_pep50_warning" error.
-
-    Returns
-    -------
-    str
-        The content to handle the error.
-    """
-    # https://github.com/numpy/numpy/blob/v2.2.2/\
-    #   doc/source/release/2.2.0-notes.rst#nep-50-promotion-state-option-removed
-    content = '''
-# try to make sure we don't get:
-# module 'numpy' has no attribute '_no_nep50_warning'"
-os.environ["NEP50_DEPRECATION_WARNING"] = "0"
-os.environ["NEP50_DISABLE_WARNING"] = "1"
-os.environ["NPY_PROMOTION_STATE"] = "weak"
-if not hasattr(np, "_no_pep50_warning"):
-
-    import contextlib
-    from typing import Generator
-
-    @contextlib.contextmanager
-    def _np_no_nep50_warning() -> Generator[None, None, None]:
-        """Dummy function to avoid the warning.
-
-        Yields
-        ------
-        None
-            Nothing.
-        """
-        yield
-    setattr(np, "_no_pep50_warning", _np_no_nep50_warning)  # noqa
-'''
-    return content

waldiez/exporting/flow/utils/flow_names.py

@@ -1,116 +0,0 @@
-# SPDX-License-Identifier: Apache-2.0.
-# Copyright (c) 2024 - 2025 Waldiez and contributors.
-"""Ensure unique names for agents, models, skills, and chats."""
-
-from typing import Callable, Dict, List, TypedDict
-
-from waldiez.models import (
-    Waldiez,
-    WaldiezAgent,
-    WaldiezChat,
-    WaldiezModel,
-    WaldiezSkill,
-)
-
-
-class ResultType(TypedDict):
-    """The result type for ensure_unique_names."""
-
-    agent_names: Dict[str, str]
-    model_names: Dict[str, str]
-    skill_names: Dict[str, str]
-    chat_names: Dict[str, str]
-    agents: List[WaldiezAgent]
-    models: List[WaldiezModel]
-    skills: List[WaldiezSkill]
-    chats: List[WaldiezChat]
-    flow_name: str
-
-
-# pylint: disable=too-many-locals
-def ensure_unique_names(
-    waldiez: Waldiez,
-    get_valid_instance_name: Callable[..., Dict[str, str]],
-    max_length: int = 46,
-    flow_name_max_length: int = 20,
-) -> ResultType:
-    """Ensure unique names for agents, models, skills, and chats and flow.
-
-    Parameters
-    ----------
-    waldiez : Waldiez
-        The Waldiez instance.
-    get_valid_instance_name : Callable[..., Dict[str, str]]
-        The function to get a valid instance name.
-    max_length : int, optional
-        The maximum length of the name, by default 64
-    flow_name_max_length : int, optional
-        The maximum length of the flow name, by default 20
-
-    Returns
-    -------
-    ResultType
-        The result with unique names for agents, models, skills, chats, flow.
-    """
-    all_names: Dict[str, str] = {}
-    agent_names: Dict[str, str] = {}
-    model_names: Dict[str, str] = {}
-    skill_names: Dict[str, str] = {}
-    chat_names: Dict[str, str] = {}
-    agents: List[WaldiezAgent] = []
-    models: List[WaldiezModel] = []
-    skills: List[WaldiezSkill] = []
-    chats: List[WaldiezChat] = []
-
-    for agent in waldiez.agents:
-        all_names = get_valid_instance_name(
-            (agent.id, agent.name),
-            all_names,
-            prefix="wa",
-            max_length=max_length,
-        )
-        agent_names[agent.id] = all_names[agent.id]
-        agents.append(agent)
-    for model in waldiez.models:
-        all_names = get_valid_instance_name(
-            (model.id, model.name),
-            all_names,
-            prefix="wm",
-            max_length=max_length,
-        )
-        model_names[model.id] = all_names[model.id]
-        models.append(model)
-    for skill in waldiez.skills:
-        all_names = get_valid_instance_name(
-            (skill.id, skill.name),
-            all_names,
-            prefix="ws",
-            max_length=max_length,
-        )
-        skill_names[skill.id] = all_names[skill.id]
-        skills.append(skill)
-    for chat in waldiez.flow.data.chats:
-        all_names = get_valid_instance_name(
-            (chat.id, chat.name), all_names, prefix="wc", max_length=max_length
-        )
-        chat_names[chat.id] = all_names[chat.id]
-        chats.append(chat)
-    all_names = get_valid_instance_name(
-        (waldiez.flow.id, waldiez.flow.name),
-        all_names,
-        prefix="wf",
-        max_length=flow_name_max_length,
-    )
-    flow_name = all_names[waldiez.flow.id]
-    result: ResultType = {
-        "agent_names": agent_names,
-        "model_names": model_names,
-        "skill_names": skill_names,
-        "chat_names": chat_names,
-        "agents": agents,
-        "models": models,
-        "skills": skills,
-        "chats": chats,
-        "flow_name": flow_name,
-    }
-    return result