waldiez 0.5.3__py3-none-any.whl → 0.5.5__py3-none-any.whl

waldiez/exporting/agent/processor.py

@@ -73,20 +73,58 @@ class AgentProcessor:
         resolved_args = self.arguments_resolver(self.agent)
         if resolved_args:  # pragma: no branch
             extra_args += ",\n".join(resolved_args)
+        if not extra_args.startswith("\n"):
+            extra_args = "\n" + extra_args
+        if not extra_args.endswith("\n"):
+            extra_args += "\n"
         # Build the agent definition
-        agent_str = f"""{agent_name} = {ag2_class}(
-{self.get_name_arg()}
-{self.get_description_arg()},{self.extras.get_system_message_arg()}
-{self.get_human_input_mode_arg()},
-{self.get_max_consecutive_auto_reply_arg()},
-{self.get_auto_reply_arg()},
-{self.extras.get_code_execution_arg()}
-{self.extras.get_termination_arg()}
-{extra_args}
-)"""
+        agent_str = self.get_agent_string(
+            agent_name=agent_name, ag2_class=ag2_class, extra_args=extra_args
+        )
 
         return AgentProcessingResult(content=agent_str)
 
+    def get_agent_string(
+        self, agent_name: str, ag2_class: str, extra_args: str
+    ) -> str:
+        """Get the agent definition string.
+
+        Parameters
+        ----------
+        agent_name : str
+            The name of the agent.
+        ag2_class : str
+            The class of the agent.
+        extra_args : str
+            Additional arguments for the agent.
+
+        Returns
+        -------
+        str
+            The agent definition string.
+        """
+        agent_str: str = f"{agent_name} = {ag2_class}(\n"
+        if "name" not in self.agent.args_to_skip:
+            agent_str += self.get_name_arg()
+        if "description" not in self.agent.args_to_skip:
+            agent_str += self.get_description_arg()
+        if "system_message" not in self.agent.args_to_skip:
+            agent_str += self.get_system_message_arg()
+        if "human_input_mode" not in self.agent.args_to_skip:
+            agent_str += self.get_human_input_mode_arg()
+        if "max_consecutive_auto_reply" not in self.agent.args_to_skip:
+            agent_str += self.get_max_consecutive_auto_reply_arg()
+        if "default_auto_reply" not in self.agent.args_to_skip:
+            agent_str += self.get_auto_reply_arg()
+        if "code_execution_config" not in self.agent.args_to_skip:
+            agent_str += self.get_code_execution_arg()
+        if "is_termination_msg" not in self.agent.args_to_skip:
+            agent_str += self.get_termination_arg()
+        if extra_args:  # pragma: no branch
+            agent_str = self.add_extra_args(agent_str, extra_args)
+        agent_str += ")"
+        return agent_str
+
     def get_name_arg(self) -> str:
         """Get the agent name argument.
 
@@ -95,7 +133,46 @@ class AgentProcessor:
         str
             The agent name argument.
         """
-        return f'    name="{self.agent_names[self.agent.id]}",'
+        return f'    name="{self.agent_names[self.agent.id]}",\n'
+
+    def get_system_message_arg(self) -> str:
+        """Get the system message argument.
+
+        Returns
+        -------
+        str
+            The system message argument.
+        """
+        arg = str(self.extras.get_system_message_arg())
+        if arg:
+            return f"{arg},\n"
+        return ""
+
+    def get_code_execution_arg(self) -> str:
+        """Get the code execution argument.
+
+        Returns
+        -------
+        str
+            The code execution argument.
+        """
+        arg = str(self.extras.get_code_execution_arg())
+        if arg:
+            return f"{arg},\n"
+        return ""
+
+    def get_termination_arg(self) -> str:
+        """Get the termination argument.
+
+        Returns
+        -------
+        str
+            The termination argument.
+        """
+        arg = str(self.extras.get_termination_arg())
+        if arg:
+            return f"{arg}\n"
+        return ""
 
     def get_human_input_mode_arg(self) -> str:
         """Get the human input mode argument.
@@ -105,7 +182,7 @@ class AgentProcessor:
         str
             The human input mode argument.
         """
-        return f'    human_input_mode="{self.agent.data.human_input_mode}"'
+        return f'    human_input_mode="{self.agent.data.human_input_mode}",\n'
 
     def get_max_consecutive_auto_reply_arg(self) -> str:
         """Get the maximum consecutive auto reply argument.
@@ -116,7 +193,7 @@ class AgentProcessor:
             The maximum consecutive auto reply argument.
         """
         value = self.agent.data.max_consecutive_auto_reply
-        return f"    max_consecutive_auto_reply={value}"
+        return f"    max_consecutive_auto_reply={value},\n"
 
     def get_description_arg(self) -> str:
         """Get the agent description.
@@ -131,7 +208,7 @@ class AgentProcessor:
             if self.agent.description
             else '""'
         )
-        return f"    description={description}"
+        return f"    description={description},\n"
 
     def get_auto_reply_arg(self) -> str:
         """Get the default auto reply argument.
@@ -147,4 +224,25 @@ class AgentProcessor:
             default_auto_reply = json.dumps(
                 self.agent.data.agent_default_auto_reply
             )
-        return f"    default_auto_reply={default_auto_reply}"
+        return f"    default_auto_reply={default_auto_reply},\n"
+
+    def add_extra_args(self, agent_str: str, extra_args: str) -> str:
+        """Add extra agent args.
+
+        Parameters
+        ----------
+        agent_str : str
+            The current agent string
+        extra_args : str
+            The extra args to add
+
+        Returns
+        -------
+        str
+            The new agent string
+        """
+        agent_string = str(agent_str)
+        if agent_string.endswith("\n"):
+            agent_string = agent_string[: -len("\n")]
+        agent_string += extra_args
+        return agent_string

waldiez/exporting/chats/processor.py

@@ -197,30 +197,11 @@ class ChatsProcessor:
         """
         if self.is_group_patterned():
             if self._is_async:
-                import_string = (
-                    "from autogen.agentchat import a_initiate_group_chat"
-                )
+                import_string = "from autogen.agentchat import a_run_group_chat"
             else:
-                import_string = (
-                    "from autogen.agentchat import initiate_group_chat"
-                )
+                import_string = "from autogen.agentchat import run_group_chat"
             self._extras.add_import(
                 ImportStatement(
                     statement=import_string, position=ImportPosition.THIRD_PARTY
                 )
             )
-            return
-        if len(self._chats.main) == 1:
-            # no additional imports, it is `sender.initiate_chat(....)`
-            return
-        if self._is_async:
-            import_string = (
-                "from autogen.agentchat.chat import a_initiate_chats"
-            )
-        else:
-            import_string = "from autogen.agentchat.chat import initiate_chats"
-        self._extras.add_import(
-            ImportStatement(
-                statement=import_string, position=ImportPosition.THIRD_PARTY
-            )
-        )

waldiez/exporting/chats/utils/common.py

@@ -2,6 +2,7 @@
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
 """Common utilities for exporting chats."""
 
+import json
 from typing import Optional
 
 from waldiez.models import WaldiezAgent, WaldiezChat
@@ -36,7 +37,9 @@ def get_chat_message_string(
         if chat.message.content is None:  # pragma: no cover
             # should be coverred previousliy on pydantic validation
             return "None", None
-        return chat.message.content, None
+        if not chat.message.content:
+            return "", None
+        return json.dumps(chat.message.content, ensure_ascii=False), None
 
     is_rag_with_carryover = sender.is_rag_user and chat.message.use_carryover
     chat_name = chat_names[chat.id]
@@ -45,3 +48,65 @@ def get_chat_message_string(
         is_rag=is_rag_with_carryover,
     )
     return function_name, function_content
+
+
+def get_event_handler_string(
+    tab: str,
+    is_async: bool,
+) -> str:
+    """Get the event handler string.
+
+    Parameters
+    ----------
+    tab : str
+        The tab string.
+    is_async : bool
+        Whether the handler is asynchronous.
+
+    Returns
+    -------
+    str
+        The event handler string.
+    """
+    content = (
+        f"{tab}if on_event:\n"
+        f"{tab}    if not isinstance(results, list):\n"
+        f"{tab}        results = [results]\n"
+        f"{tab}    for index, result in enumerate(results):\n"
+    )
+    if is_async:
+        content += (
+            f"{tab}        async for event in result.events:\n"
+            f"{tab}            try:\n"
+            f"{tab}                should_continue = await on_event(event)\n"
+            f"{tab}            except Exception as e:\n"
+            f"{tab}                raise RuntimeError(\n"
+            f"{tab}                    'Error in event handler: ' + str(e)\n"
+            f"{tab}                ) from e\n"
+        )
+    else:
+        content += (
+            f"{tab}        for event in result.events:\n"
+            f"{tab}            try:\n"
+            f"{tab}                should_continue = on_event(event)\n"
+            f"{tab}            except Exception as e:\n"
+            f"{tab}                raise RuntimeError(\n"
+            f"{tab}                    'Error in event handler: ' + str(e)\n"
+            f"{tab}                ) from e\n"
+        )
+    content += (
+        f"{tab}            if event.type == 'run_completion':\n"
+        f"{tab}                should_continue = False\n"
+        f"{tab}            if not should_continue:\n"
+        f"{tab}                break\n"
+        f"{tab}else:\n"
+        f"{tab}    if not isinstance(results, list):\n"
+        f"{tab}        results = [results]\n"
+        f"{tab}    for result in results:\n"
+    )
+    if is_async:
+        content += f"{tab}        await result.process()\n"
+    else:
+        content += f"{tab}        result.process()\n"
+
+    return content

waldiez/exporting/chats/utils/group.py

@@ -10,6 +10,8 @@ import json
 
 from waldiez.models import WaldiezGroupManager
 
+from .common import get_event_handler_string
+
 
 def export_group_chats(
     agent_names: dict[str, str],
@@ -39,12 +41,12 @@ def export_group_chats(
         The group chat string and the import string.
     """
     tab = "    " * tabs
-    initiate_group_chat = "initiate_group_chat"
+    run_group_chat = "run_group_chat"
     if is_async:
-        initiate_group_chat = "a_initiate_group_chat"
+        run_group_chat = "a_run_group_chat"
     manager_name = agent_names[manager.id]
     pattern_name = f"{manager_name}_pattern"
-    content = f"{tab}results, _, __ = {initiate_group_chat}(" + "\n"
+    content = f"{tab}results = {run_group_chat}(" + "\n"
     content += f"{tab}    pattern={pattern_name}," + "\n"
     if initial_chat:
         content += f"{tab}    messages={json.dumps(initial_chat)}," + "\n"
@@ -52,4 +54,5 @@ def export_group_chats(
         content += f'{tab}    messages="",\n'
     content += f"{tab}    max_rounds={manager.data.max_round},\n"
     content += f"{tab})\n"
+    content += get_event_handler_string(tab=tab, is_async=is_async)
     return content

waldiez/exporting/chats/utils/nested.py

@@ -270,7 +270,7 @@ def get_chat_nested_string(
         return message.content, None
     chat_name = chat_names[chat.id]
     if is_reply:
-        function_content, function_name = chat.get_nested_chat_message_function(
+        function_content, function_name = chat.get_nested_chat_reply_function(
             name_suffix=chat_name
         )
     else:

waldiez/exporting/chats/utils/sequential.py

@@ -10,7 +10,7 @@ from waldiez.models import (
     WaldiezRagUserProxy,
 )
 
-from .common import get_chat_message_string
+from .common import get_chat_message_string, get_event_handler_string
 
 
 def export_sequential_chat(
@@ -115,9 +115,15 @@ def export_sequential_chat(
     tab = "    " * tabs if tabs > 0 else ""
     content = "\n"
     additional_methods_string = ""
-    content += _get_initiate_chats_line(tab, is_async)
-    for connection in main_chats:
+    sender = main_chats[0]["source"]
+    content += _get_initiate_chats_line(
+        tab=tab,
+        is_async=is_async,
+        sender=agent_names[sender.id],
+    )
+    for idx, connection in enumerate(main_chats):
         chat_string, additional_methods = _get_chat_dict_string(
+            is_first=idx == 0,
             chat_names=chat_names,
             connection=connection,
             agent_names=agent_names,
@@ -128,11 +134,13 @@ def export_sequential_chat(
         additional_methods_string += additional_methods
         content += "\n" + f"{tab}    {chat_string}"
     content += "\n" + "    " * tabs + "])\n"
+    content += get_event_handler_string(tab=tab, is_async=is_async)
     return content, additional_methods_string
 
 
 def _get_chat_dict_string(
     connection: WaldiezAgentConnection,
+    is_first: bool,
     chat_names: dict[str, str],
     agent_names: dict[str, str],
     serializer: Callable[..., str],
@@ -147,6 +155,8 @@ def _get_chat_dict_string(
 
     Parameters
     ----------
+    is_first : bool
+        Whether this is the first chat in the sequence.
     connection : WaldiezAgentConnection
         The connection object containing the chat and agents.
     chat_names : dict[str, str]
@@ -168,8 +178,9 @@ def _get_chat_dict_string(
     tab = "    " * tabs
     chat = connection["chat"]
     sender = connection["source"]
-    chat_string = _get_chat_strig_start(
+    chat_string = _get_chat_string_start(
         connection=connection,
+        is_first=is_first,
         agent_names=agent_names,
         serializer=serializer,
         tabs=tabs,
@@ -196,13 +207,14 @@ def _get_chat_dict_string(
                 additional_methods_string += "\n" + method_content
             chat_string += "\n" + f'{tab}    "message": {message},'
         elif chat.data.message.type == "string" and chat.data.message.content:
-            chat_string += "\n" + f'{tab}    "message": "{message}",'
+            chat_string += "\n" + f'{tab}    "message": {message},'
     chat_string += "\n" + tab + "},"
     return chat_string, additional_methods_string
 
 
-def _get_chat_strig_start(
+def _get_chat_string_start(
     connection: WaldiezAgentConnection,
+    is_first: bool,
     agent_names: dict[str, str],
     serializer: Callable[..., str],
     tabs: int,
@@ -215,7 +227,8 @@ def _get_chat_strig_start(
     chat_args = chat.get_chat_args(for_queue=True, sender=sender)
     # chat_args = update_summary_chat_args(chat_args)
     chat_string = "{"
-    chat_string += "\n" + f'{tab}    "sender": {agent_names[sender.id]},'
+    if not is_first:
+        chat_string += "\n" + f'{tab}    "sender": {agent_names[sender.id]},'
     chat_string += "\n" + f'{tab}    "recipient": {agent_names[recipient.id]},'
     if skip_cache is False:
         chat_string += "\n" + f'{tab}    "cache": cache,'
@@ -233,6 +246,7 @@ def _get_chat_strig_start(
 def _get_initiate_chats_line(
     tab: str,
     is_async: bool,
+    sender: str,
 ) -> str:
     """Get the initiate chats line.
 
@@ -242,6 +256,8 @@ def _get_initiate_chats_line(
         The tab string.
     is_async : bool
         Whether the chat is asynchronous.
+    sender : str
+        The sender that starts the chat.
 
     Returns
     -------
@@ -249,8 +265,8 @@ def _get_initiate_chats_line(
         The initiate chats line.
     """
     results_is = f"{tab}results = "
-    initiate = "initiate_chats"
+    initiate = f"{sender}.sequential_run"
     if is_async:
         results_is += "await "
-        initiate = "a_initiate_chats"
+        initiate = f"{sender}.a_sequential_run"
     return results_is + initiate + "(["

waldiez/exporting/chats/utils/single.py

@@ -13,7 +13,7 @@ from waldiez.models import (
     WaldiezRagUserProxy,
 )
 
-from .common import get_chat_message_string
+from .common import get_chat_message_string, get_event_handler_string
 
 
 def export_single_chat(
@@ -166,17 +166,17 @@ def get_simple_chat_string(
     """
     tab = "    " * tabs
     sender_name = agent_names[sender.id]
-    initiate = "initiate_chat"
+    initiate = "run"
     if is_async:
         sender_name = f"await {sender_name}"
-        initiate = "a_initiate_chat"
+        initiate = "a_run"
     recipient_name = agent_names[recipient.id]
     chat_string = "\n" + f"{tab}results = {sender_name}.{initiate}(" + "\n"
     chat_string += f"{tab}    {recipient_name},"
     if not skip_cache:
         chat_string += "\n" + f"{tab}    cache=cache,"
     for key, value in chat_args.items():
-        if isinstance(value, str):
+        if isinstance(value, str) and key != "message":
             chat_string += "\n" + f'{tab}    {key}="{value}",'
         elif isinstance(value, dict):
             chat_string += (
@@ -193,6 +193,7 @@ def get_simple_chat_string(
     )
     chat_string += message_arg
     chat_string += "\n" + f"{tab})" + "\n"
+    chat_string += get_event_handler_string(tab=tab, is_async=is_async)
     return chat_string, additional_methods_string
 
 
@@ -233,7 +234,7 @@ def get_empty_simple_chat_string(
     if is_async:
         sender_name = f"await {sender_name}"
     recipient_name = agent_names[recipient.id]
-    initiate = "a_initiate_chat" if is_async else "initiate_chat"
+    initiate = "a_run" if is_async else "run"
     content = "\n" + f"{tab}results = {sender_name}.{initiate}(" + "\n"
     content += f"{tab}    {recipient_name}," + "\n"
     if not skip_cache:
@@ -247,6 +248,7 @@ def get_empty_simple_chat_string(
     )
     content += message_arg
     content += f"{tab})" + "\n"
+    content += get_event_handler_string(tab=tab, is_async=is_async)
     return content, ""
 
 
@@ -303,7 +305,7 @@ def get_chat_message(
             )
         if chat.message.type == "string" and chat.data.message.content:
             return (
-                "\n" + f'{tab}    message="{message}",',
+                "\n" + f"{tab}    message={message},",
                 additional_methods_string,
             )
         if chat.message.type == "rag_message_generator":

waldiez/exporting/core/context.py

@@ -54,8 +54,6 @@ class ExporterContext:
         is_async: bool = False,
         output_directory: Optional[str] = None,
         cache_seed: Optional[int] = None,
-        structured_io: bool = False,
-        skip_patch_io: bool = True,
     ) -> ExportConfig:
         """Get export config or return default.
 
@@ -77,10 +75,6 @@ class ExporterContext:
             The directory where the output will be saved, by default None
         cache_seed : Optional[int], optional
             The seed for caching, by default None
-        structured_io : bool, optional
-            Whether to use structured I/O, by default False
-        skip_patch_io : bool, optional
-            Whether to skip patching I/O, by default True
 
         Returns
         -------
@@ -91,12 +85,6 @@ class ExporterContext:
             "requirements": requirements or [],
             "tags": tags or [],
             "is_async": self.config.is_async if self.config else is_async,
-            "structured_io": (
-                self.config.structured_io if self.config else structured_io
-            ),
-            "skip_patch_io": (
-                self.config.skip_patch_io if self.config else skip_patch_io
-            ),
         }
         if output_extension is not None:
             kwargs["output_extension"] = output_extension

waldiez/exporting/core/extras/agent_extras/standard_extras.py

@@ -139,6 +139,7 @@ class StandardExtras(BaseExtras):
             instance_id=self.instance_id,
             name="code_execution_config",
             value=argunent,
+            skip_trailing_comma=True,
             tabs=1,
         )
 
@@ -185,7 +186,8 @@ class StandardExtras(BaseExtras):
             name="system_message",
             value=argument,
             skip_if_empty_string=True,
-            with_new_line_before=True,
+            with_new_line_before=False,
+            skip_trailing_comma=True,
             tabs=1,
         )
 

waldiez/exporting/core/extras/base.py

@@ -101,11 +101,12 @@ class BaseExtras(ExportContributor):
         content : str
             The content to prepend.
         """
-        if content and content.strip():
+        stripped = content.rstrip()
+        if stripped and stripped not in self.before_agent:
             if self.before_agent:
-                self.before_agent = content.rstrip() + "\n" + self.before_agent
+                self.before_agent = stripped + "\n" + self.before_agent
             else:
-                self.before_agent = content.rstrip()
+                self.before_agent = stripped
 
     def append_before_agent(self, content: str) -> None:
         """Append content to the before_agent section.
@@ -115,11 +116,12 @@ class BaseExtras(ExportContributor):
         content : str
             The content to append.
         """
-        if content and content.strip():
+        stripped = content.rstrip()
+        if stripped and stripped not in self.before_agent:
             if self.before_agent:
-                self.before_agent += "\n" + content.rstrip()
+                self.before_agent += "\n" + stripped
             else:
-                self.before_agent = content.rstrip()
+                self.before_agent = stripped
 
     def append_after_agent(self, content: str) -> None:
         """Append content to the after_agent section.
@@ -129,11 +131,12 @@ class BaseExtras(ExportContributor):
         content : str
             The content to append.
         """
-        if content and content.strip():
+        stripped = content.rstrip()
+        if stripped and stripped not in self.after_agent:
             if self.after_agent:
-                self.after_agent += "\n" + content.rstrip()
+                self.after_agent += "\n" + stripped
             else:
-                self.after_agent = content.rstrip()
+                self.after_agent = stripped
 
     def append_after_all_agents(self, content: str) -> None:
         """Append content to the after_all_agents section.
@@ -143,11 +146,12 @@ class BaseExtras(ExportContributor):
         content : str
             The content to append.
         """
-        if content and content.strip():
+        stripped = content.rstrip()
+        if stripped and stripped not in self.after_all_agents:
             if self.after_all_agents:
-                self.after_all_agents += "\n" + content.rstrip()
+                self.after_all_agents += "\n" + stripped
             else:
-                self.after_all_agents = content.rstrip()
+                self.after_all_agents = stripped
 
     def prepend_after_all_agents(self, content: str) -> None:
         """Prepend content to the after_all_agents section.
@@ -157,13 +161,12 @@ class BaseExtras(ExportContributor):
         content : str
             The content to prepend.
         """
-        if content and content.strip():
+        stripped = content.rstrip()
+        if stripped and stripped not in self.after_all_agents:
             if self.after_all_agents:
-                self.after_all_agents = (
-                    content.rstrip() + "\n" + self.after_all_agents
-                )
+                self.after_all_agents = stripped + "\n" + self.after_all_agents
             else:
-                self.after_all_agents = content.rstrip()
+                self.after_all_agents = stripped
 
     def contribute_to_export(self, result: ExportResult) -> None:
         """Contribute this extras' content to the export result.