waldiez 0.2.2__py3-none-any.whl → 0.3.0__py3-none-any.whl

waldiez/exporting/flow/utils/agent_utils.py

@@ -0,0 +1,204 @@
+# 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

@@ -0,0 +1,71 @@
+# 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

@@ -0,0 +1,62 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+"""Get the main function."""
+
+from .logging_utils import get_logging_stop_string, get_sqlite_out_call
+
+
+def get_def_main(flow_chats: str, is_async: bool) -> 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.
+    is_async : bool
+        Whether the main function is asynchronous.
+    Returns
+    -------
+    str
+        The main function.
+    """
+    content = ""
+    if is_async:
+        content += "async "
+    content += "def main():\n"
+    content += "    # type: () -> Union[ChatResult, List[ChatResult]]\n"
+    content += '    """Start chatting."""\n'
+    content += f"{flow_chats}" + "\n"
+    content += get_logging_stop_string(1) + "\n"
+    content += get_sqlite_out_call(1) + "\n"
+    content += "    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'
+    # fmt: off
+    if is_async:
+        content += (
+            "    results: Union[ChatResult, List[ChatResult]] = await main()\n"
+        )
+    else:
+        content += (
+            "    results: Union[ChatResult, List[ChatResult]] = main()\n"
+        )
+    # fmt: on
+    content += "    if not isinstance(results, list):\n"
+    content += "        results = [results]\n"
+    content += "    for result in results:\n"
+    content += "        pprint(asdict(result))\n\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

@@ -0,0 +1,112 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+"""Utils to generate the content of a flow."""
+
+from typing import Callable, 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:
+        # pylint: disable=line-too-long
+        # fmt: off
+        content += "# " + f"!{{sys.executable}} -m pip install -q {requirements}" + "\n"  # noqa: E501
+        # 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",
+    "invalid-name",
+    "import-error",
+    "inconsistent-quotes",
+    "missing-function-docstring",
+    "missing-param-doc",
+    "missing-return-doc",
+]
+
+
+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"

waldiez/exporting/flow/utils/flow_names.py

@@ -0,0 +1,115 @@
+# 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 = 64,
+    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