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

waldiez/__init__.py

@@ -1,3 +1,5 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
 """Waldiez package."""
 
 import logging

waldiez/__main__.py

@@ -1,3 +1,5 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
 """Waldiez entrypoint when called as a module."""
 
 from .cli import app

waldiez/_version.py

@@ -1,3 +1,5 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
 """Version information for Waldiez."""
 
-__version__ = "0.2.2"
+__version__ = "0.3.0"

waldiez/cli.py

@@ -1,6 +1,8 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+# pylint: disable=missing-function-docstring,missing-param-doc,missing-raises-doc  # noqa: E501
 """Command line interface to convert or run a waldiez file."""
 
-# pylint: disable=missing-function-docstring,missing-param-doc,missing-raises-doc  # noqa: E501
 import json
 import logging
 import os
@@ -9,6 +11,7 @@ import warnings
 from pathlib import Path
 from typing import TYPE_CHECKING, Optional
 
+import anyio
 import typer
 from typing_extensions import Annotated
 
@@ -87,6 +90,10 @@ def run(
     ),
 ) -> None:
     """Run a Waldiez flow."""
+    # swarm without a user,
+    # creates a new user (this has a default code execution with docker)
+    # temp (until we handle/detect docker setup)
+    os.environ["AUTOGEN_USE_DOCKER"] = "0"
     output_path = _get_output_path(output, force)
     with file.open("r", encoding="utf-8") as _file:
         try:
@@ -96,14 +103,17 @@ def run(
             raise typer.Exit(code=1) from error
     waldiez = Waldiez.from_dict(data)
     runner = WaldiezRunner(waldiez)
-    results = runner.run(output_path=output_path)
+    if waldiez.is_async:
+        results = anyio.run(runner.a_run, output_path)
+    else:
+        results = runner.run(output_path=output_path)
     logger = _get_logger()
     if isinstance(results, list):
         logger.info("Results:")
         for result in results:
             _log_result(result, logger)
             sep = "-" * 80
-            print(f"\n{sep}\n")
+            print("\n" + f"{sep}" + "\n")
     else:
         _log_result(results, logger)
 

waldiez/cli_extras.py

@@ -1,6 +1,7 @@
-# type: ignore
-# flake8: noqa
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
 # pylint: skip-file
+# type: ignore
 # isort: skip_file
 """Extra typer commands for CLI."""
 
@@ -20,7 +21,7 @@ except BaseException:
     pass
 
 try:
-    import waldiez_jupyter
+    import waldiez_jupyter  # noqa: F401
 
     HAVE_JUPYTER = True
 except BaseException:

waldiez/conflict_checker.py

@@ -1,6 +1,7 @@
-"""Check for conflicts with 'autogen-agentchat' package."""
-
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
 # pylint: disable=line-too-long
+"""Check for conflicts with 'autogen-agentchat' package."""
 
 import sys
 from importlib.metadata import PackageNotFoundError, version
@@ -16,7 +17,7 @@ def check_conflicts() -> None:  # pragma: no cover
             "in the current environment, \n"
             "which conflicts with 'ag2' / 'pyautogen'.\n"
             "Please uninstall 'autogen-agentchat': \n"
-            f"{sys.executable} -m pip uninstall -y autogen-agentchat \n"
+            f"{sys.executable} -m pip uninstall -y autogen-agentchat" + "\n"
             "And install 'pyautogen' (and/or 'waldiez') again: \n"
             f"{sys.executable} -m pip install --force pyautogen waldiez"
         )

waldiez/exporter.py

@@ -1,5 +1,6 @@
-"""Waldiez exporter.
-
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+"""
 The role of the exporter is to export the model's data
 to an autogen's flow with one or more chats.
 
@@ -8,8 +9,8 @@ to trigger the chat(s).
 If additional tools/skills are used,
 they are exported as their `skill_name` in the same directory with
 the `flow.py` file. So the `flow.py` could have entries like:
-`form {skill1_name} import {skill1_name}`
-`form {skill2_name} import {skill2_name}`
+`form {flow_name}_{skill1_name} import {skill1_name}`
+`form {flow_name}_{skill2_name} import {skill2_name}`
 """
 
 # pylint: disable=inconsistent-quotes
@@ -19,16 +20,10 @@ import shutil
 import subprocess
 import sys
 from pathlib import Path
-from typing import Dict, List, Optional, Union
+from typing import List, Optional, Union
 
-from .exporting import comment, export_flow, get_valid_instance_name
-from .models import (
-    Waldiez,
-    WaldiezAgent,
-    WaldiezChat,
-    WaldiezModel,
-    WaldiezSkill,
-)
+from .exporting import FlowExporter
+from .models import Waldiez
 
 
 class WaldiezExporter:
@@ -38,15 +33,6 @@ class WaldiezExporter:
         waldiez (Waldiez): The Waldiez instance.
     """
 
-    _agent_names: Dict[str, str]
-    _model_names: Dict[str, str]
-    _skill_names: Dict[str, str]
-    _chat_names: Dict[str, str]
-    _chats: List[WaldiezChat]
-    _skills: List[WaldiezSkill]
-    _models: List[WaldiezModel]
-    _agents: List[WaldiezAgent]
-
     def __init__(self, waldiez: Waldiez) -> None:
         """Initialize the Waldiez exporter.
 
@@ -54,7 +40,7 @@ class WaldiezExporter:
             waldiez (Waldiez): The Waldiez instance.
         """
         self.waldiez = waldiez
-        self._initialize()
+        # self._initialize()
 
     @classmethod
     def load(cls, file_path: Path) -> "WaldiezExporter":
@@ -73,56 +59,6 @@ class WaldiezExporter:
         waldiez = Waldiez.load(file_path)
         return cls(waldiez)
 
-    def _initialize(
-        self,
-    ) -> None:
-        """Get all the names in the flow.
-
-        We need to make sure that no duplicate names are used,
-        and that the names can be used as python variables.
-        """
-        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] = {}
-        chats: List[WaldiezChat] = []
-        skills: List[WaldiezSkill] = []
-        models: List[WaldiezModel] = []
-        agents: List[WaldiezAgent] = []
-        for agent in self.waldiez.agents:
-            all_names = get_valid_instance_name(
-                (agent.id, agent.name), all_names, prefix="wa"
-            )
-            agent_names[agent.id] = all_names[agent.id]
-            agents.append(agent)
-        for model in self.waldiez.models:
-            all_names = get_valid_instance_name(
-                (model.id, model.name), all_names, prefix="wm"
-            )
-            model_names[model.id] = all_names[model.id]
-            models.append(model)
-        for skill in self.waldiez.skills:
-            all_names = get_valid_instance_name(
-                (skill.id, skill.name), all_names, prefix="ws"
-            )
-            skill_names[skill.id] = all_names[skill.id]
-            skills.append(skill)
-        for chat in self.waldiez.flow.data.chats:
-            all_names = get_valid_instance_name(
-                (chat.id, chat.name), all_names, prefix="wc"
-            )
-            chat_names[chat.id] = all_names[chat.id]
-            chats.append(chat)
-        self._agent_names = agent_names
-        self._model_names = model_names
-        self._skill_names = skill_names
-        self._chat_names = chat_names
-        self._chats = chats
-        self._skills = skills
-        self._models = models
-        self._agents = agents
-
     def export(self, path: Union[str, Path], force: bool = False) -> None:
         """Export the Waldiez instance.
 
@@ -175,25 +111,17 @@ class WaldiezExporter:
         RuntimeError
             If the notebook could not be generated.
         """
-        content = f"{comment(True)}{self.waldiez.name}" + "\n\n"
-        content += f"{comment(True, 2)}Dependencies" + "\n\n"
-        content += "import sys\n"
-        requirements = " ".join(self.waldiez.requirements)
-        if requirements:
-            content += (
-                f"# !{{sys.executable}} -m pip install -q {requirements}" + "\n"
-            )
-        content += export_flow(
+        # we first create a .py file with the content
+        # and then convert it to a notebook using jupytext
+        exporter = FlowExporter(
             waldiez=self.waldiez,
-            agents=(self._agents, self._agent_names),
-            chats=(self._chats, self._chat_names),
-            models=(self._models, self._model_names),
-            skills=(self._skills, self._skill_names),
             output_dir=path.parent,
-            notebook=True,
+            for_notebook=True,
         )
-        # we first create a .py file with the content
-        # and then convert it to a notebook using jupytext
+        output = exporter.export()
+        content = output["content"]
+        if not content:
+            raise RuntimeError("Could not generate notebook")
         py_path = path.with_suffix(".tmp.py")
         with open(py_path, "w", encoding="utf-8", newline="\n") as f:
             f.write(content)
@@ -226,26 +154,21 @@ class WaldiezExporter:
         ----------
         path : Path
             The path to export to.
+
+        Raises
+        ------
+        RuntimeError
+            If the python script could not be generated.
         """
-        content = "#!/usr/bin/env python\n"
-        content += f'"""{self.waldiez.name}\n\n'
-        content += f"{self.waldiez.description}\n\n"
-        content += f"Tags: {', '.join(self.waldiez.tags)}\n\n"
-        content += f"Requirements: {', '.join(self.waldiez.requirements)}\n\n"
-        content += '"""\n\n'
-        content += "# cspell: disable\n"
-        content += "# flake8: noqa\n\n"
-        content += export_flow(
+        exporter = FlowExporter(
             waldiez=self.waldiez,
-            agents=(self._agents, self._agent_names),
-            chats=(self._chats, self._chat_names),
-            models=(self._models, self._model_names),
-            skills=(self._skills, self._skill_names),
             output_dir=path.parent,
-            notebook=False,
+            for_notebook=False,
         )
-        content += '\n\nif __name__ == "__main__":\n'
-        content += "    print(main())\n"
+        output = exporter.export()
+        content = output["content"]
+        if not content:
+            raise RuntimeError("Could not generate python script")
         with open(path, "w", encoding="utf-8", newline="\n") as file:
             file.write(content)
 

waldiez/exporting/__init__.py

@@ -1,14 +1,13 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
 """Tools for exporting agents, models, skills and chats to strings."""
 
-from .flow import export_flow
-from .models import export_models
-from .skills import export_skills
-from .utils import comment, get_valid_instance_name
+from .flow import FlowExporter
+from .models import ModelsExporter
+from .skills import SkillsExporter
 
 __all__ = [
-    "export_flow",
-    "comment",
-    "get_valid_instance_name",
-    "export_models",
-    "export_skills",
+    "FlowExporter",
+    "ModelsExporter",
+    "SkillsExporter",
 ]

waldiez/exporting/agent/__init__.py

@@ -0,0 +1,7 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+"""Agents exporter."""
+
+from .agent_exporter import AgentExporter
+
+__all__ = ["AgentExporter"]

waldiez/exporting/agent/agent_exporter.py

@@ -0,0 +1,279 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+# pylint: disable=too-many-return-statements,too-many-instance-attributes
+"""Export agents."""
+
+from pathlib import Path
+from typing import Callable, Dict, List, Optional, Tuple, Union
+
+from waldiez.models import WaldiezAgent, WaldiezChat
+
+from ..base import (
+    AgentPosition,
+    AgentPositions,
+    BaseExporter,
+    ExporterMixin,
+    ExporterReturnType,
+    ExportPosition,
+    ImportPosition,
+)
+from .utils import (
+    get_agent_class_name,
+    get_agent_code_execution_config,
+    get_agent_imports,
+    get_group_manager_extras,
+    get_is_termination_message,
+    get_rag_user_extras,
+    get_swarm_extras,
+)
+
+
+class AgentExporter(BaseExporter, ExporterMixin):
+    """Agents exporter."""
+
+    def __init__(
+        self,
+        agent: WaldiezAgent,
+        agent_names: Dict[str, str],
+        model_names: Dict[str, str],
+        skill_names: Dict[str, str],
+        chats: Tuple[List[WaldiezChat], Dict[str, str]],
+        is_async: bool,
+        group_chat_members: List[WaldiezAgent],
+        for_notebook: bool,
+        arguments_resolver: Callable[[WaldiezAgent], List[str]],
+        output_dir: Optional[Union[str, Path]] = None,
+    ) -> None:
+        """Initialize the agents exporter.
+
+        Parameters
+        ----------
+        agent : WaldiezAgent
+            The agent to export.
+        agent_names : Dict[str, str]
+            The agent ids to names mapping.
+        model_names : Dict[str, str]
+            The model ids to names mapping.
+        skill_names : Dict[str, str]
+            The skill ids to names mapping.
+        all_chats : List[WaldiezChat]
+            All the chats in the flow.
+        chat_names : Dict[str, str]
+            The chat ids to names mapping.
+        is_async : bool
+            Whether the whole flow is async.
+        for_notebook : bool
+            Whether the exporter is for a notebook.
+        output_dir : Optional[Union[str, Path]], optional
+            The output directory, by default None
+        """
+        self.for_notebook = for_notebook
+        self.agent = agent
+        self.agent_names = agent_names
+        if output_dir is not None and not isinstance(output_dir, Path):
+            output_dir = Path(output_dir)
+        self.output_dir = output_dir
+        self.model_names = model_names
+        self.skill_names = skill_names
+        self.arguments_resolver = arguments_resolver
+        self.group_chat_members = group_chat_members
+        self.chats = chats
+        self.is_async = is_async
+        self._agent_name = agent_names[agent.id]
+        self._agent_class = get_agent_class_name(self.agent)
+        # content, argument, import
+        self._code_execution = get_agent_code_execution_config(
+            agent=self.agent,
+            agent_name=self._agent_name,
+            skill_names=self.skill_names,
+        )
+        # before_rag, retrieve_arg, rag_imports
+        self._rag = get_rag_user_extras(
+            agent=self.agent,
+            agent_name=self._agent_name,
+            model_names=self.model_names,
+            path_resolver=self.path_resolver,
+            serializer=self.serializer,
+        )
+        # before_manager, group_chat_arg
+        self._group_chat = get_group_manager_extras(
+            agent=self.agent,
+            agent_names=self.agent_names,
+            group_chat_members=self.group_chat_members,
+            serializer=self.serializer,
+        )
+        # before_agent, extra args, handoff_registrations
+        self._swarm = get_swarm_extras(
+            agent=self.agent,
+            agent_names=self.agent_names,
+            skill_names=self.skill_names,
+            chats=self.chats,
+            is_async=self.is_async,
+            serializer=self.serializer,
+            string_escape=self.string_escape,
+        )
+        # before_agent, termination_arg
+        self._termination = get_is_termination_message(
+            agent=self.agent, agent_name=self._agent_name
+        )
+
+    def get_imports(self) -> Optional[List[Tuple[str, ImportPosition]]]:
+        """Get the imports.
+
+        Returns
+        -------
+        Optional[Tuple[str, ImportPosition]]
+            The imports.
+        """
+        position = ImportPosition.THIRD_PARTY
+        # default imports based on the agent class.
+        agent_imports = get_agent_imports(self._agent_class)
+        # if code execution is enabled, update the imports.
+        if self._code_execution[2]:
+            agent_imports.add(self._code_execution[2])
+        # if RAG is enabled, update the imports.
+        if self._rag[2]:
+            agent_imports.update(self._rag[2])
+        # if the agent has skills, add the register_function import.
+        if self.agent.data.skills:
+            agent_imports.add("from autogen import register_function")
+        return [(import_string, position) for import_string in agent_imports]
+
+    def get_system_message_arg(self) -> str:
+        """Get the system message argument.
+
+        Returns
+        -------
+        str
+            The system message argument.
+        """
+        if not self.agent.data.system_message:
+            return ""
+        system_message = self.string_escape(self.agent.data.system_message)
+        return ",\n    system_message=" + f'"{system_message}"'
+
+    def get_before_export(
+        self,
+    ) -> Optional[List[Tuple[str, Union[ExportPosition, AgentPosition]]]]:
+        """Generate the content before the main export.
+
+        Returns
+        -------
+        Optional[List[Tuple[str, Union[ExportPosition, AgentPosition]]]]
+            The exported content before the main export and its position.
+        """
+        before_agent_string = ""
+        if self._code_execution[0] and self._code_execution[2]:
+            before_agent_string += self._code_execution[0]
+        if self._termination[1]:
+            before_agent_string += self._termination[1]
+        if self._group_chat[0]:
+            before_agent_string += self._group_chat[0]
+        if self._rag[0]:
+            before_agent_string += self._rag[0]
+        if self._swarm[0]:
+            before_agent_string += self._swarm[0]
+        if before_agent_string:
+            return [
+                (
+                    before_agent_string,
+                    AgentPosition(self.agent, AgentPositions.BEFORE),
+                )
+            ]
+        return None
+
+    def get_after_export(
+        self,
+    ) -> Optional[List[Tuple[str, Union[ExportPosition, AgentPosition]]]]:
+        """Generate the content after the main export.
+
+        Returns
+        -------
+        Optional[List[Tuple[str, Union[ExportPosition, AgentPosition]]]]
+            The exported content after the main export and its position.
+        """
+        after_agent_string = ""
+        if self._swarm[2]:
+            after_agent_string += self._swarm[2]
+        if after_agent_string:
+            return [
+                (
+                    after_agent_string,
+                    AgentPosition(self.agent, AgentPositions.AFTER_ALL),
+                )
+            ]
+        return None
+
+    def generate(self) -> Optional[str]:
+        """Generate the exported agent.
+
+        Returns
+        -------
+        Optional[str]
+            The exported agent.
+        """
+        agent = self.agent
+        agent_name = self._agent_name
+        agent_class = self._agent_class
+        retrieve_arg = self._rag[1]
+        group_chat_arg = self._group_chat[1]
+        is_termination = self._termination[0]
+        code_execution_arg = self._code_execution[1]
+        system_message_arg = self.get_system_message_arg()
+        default_auto_reply: str = "None"
+        if agent.data.agent_default_auto_reply:
+            default_auto_reply = (
+                f'"{self.string_escape(agent.data.agent_default_auto_reply)}"'
+            )
+        agent_str = f"""{agent_name} = {agent_class}(
+    name="{agent_name}",
+    description="{agent.description}"{system_message_arg},
+    human_input_mode="{agent.data.human_input_mode}",
+    max_consecutive_auto_reply={agent.data.max_consecutive_auto_reply},
+    default_auto_reply={default_auto_reply},
+    code_execution_config={code_execution_arg},
+    is_termination_msg={is_termination},{group_chat_arg}{retrieve_arg}
+"""
+        if self._swarm[1]:
+            agent_str += self._swarm[1]
+        # e.g. llm_config=...
+        other_args = self.arguments_resolver(agent)
+        if other_args:
+            agent_str += ",\n".join(other_args)
+        if not agent_str.endswith("\n"):
+            agent_str += "\n"
+        agent_str += ")"
+        return agent_str
+
+    def export(self) -> ExporterReturnType:
+        """Export the agent.
+
+        Returns
+        -------
+        ExporterReturnType
+            The exported agent.
+        """
+        agent_string = self.generate() or ""
+        is_group_manager = self.agent.agent_type == "group_manager"
+        after_export = self.get_after_export() or []
+        content: Optional[str] = agent_string
+        if is_group_manager and agent_string:
+            content = None
+            # make sure the group manager is defined
+            # after the rest of the agents.
+            # to avoid issues with (for example):
+            #  'group_manager_group_chat = GroupChat(
+            #    # assistant and rag_user should be defined first
+            # '    agents=[assistant, rag_user],
+            # '    enable_clear_history=True,
+            # ...
+            after_export.append(
+                (agent_string, AgentPosition(None, AgentPositions.AFTER_ALL, 0))
+            )
+        return {
+            "content": content,
+            "imports": self.get_imports(),
+            "environment_variables": [],
+            "before_export": self.get_before_export(),
+            "after_export": after_export,
+        }

waldiez/exporting/agent/utils/__init__.py

@@ -0,0 +1,23 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+"""Utility functions for generating agent related strings."""
+
+from .agent_class_name import get_agent_class_name
+from .agent_imports import get_agent_imports
+from .code_execution import get_agent_code_execution_config
+from .group_manager import get_group_manager_extras
+from .rag_user import get_rag_user_extras
+from .swarm_agent import get_swarm_extras
+from .teachability import get_agent_teachability_string
+from .termination_message import get_is_termination_message
+
+__all__ = [
+    "get_agent_class_name",
+    "get_agent_imports",
+    "get_agent_code_execution_config",
+    "get_agent_teachability_string",
+    "get_group_manager_extras",
+    "get_is_termination_message",
+    "get_rag_user_extras",
+    "get_swarm_extras",
+]

waldiez/exporting/agent/utils/agent_class_name.py

@@ -0,0 +1,34 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+"""Get the agent class name."""
+
+from waldiez.models import WaldiezAgent
+
+
+# pylint: disable=too-many-return-statements
+def get_agent_class_name(agent: WaldiezAgent) -> str:
+    """Get the agent class name.
+
+    Parameters
+    ----------
+    agent : WaldiezAgent
+        The agent.
+
+    Returns
+    -------
+    str
+        The agent class name.
+    """
+    if agent.data.is_multimodal:
+        return "MultimodalConversableAgent"
+    if agent.agent_type == "assistant":
+        return "AssistantAgent"
+    if agent.agent_type == "user":
+        return "UserProxyAgent"
+    if agent.agent_type == "manager":
+        return "GroupChatManager"
+    if agent.agent_type == "rag_user":
+        return "RetrieveUserProxyAgent"
+    if agent.agent_type == "swarm":
+        return "SwarmAgent"
+    return "ConversableAgent"  # pragma: no cover