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

waldiez/exporting/chats/exporter.py

@@ -0,0 +1,97 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+"""Chats exporter."""
+
+from typing import Any, Optional
+
+from waldiez.models import (
+    WaldiezAgent,
+    WaldiezAgentConnection,
+    WaldiezChat,
+    WaldiezGroupManager,
+)
+
+from ..core import ChatExtras, Exporter, ExporterContext
+from .processor import ChatsProcessor
+
+
+class ChatsExporter(Exporter[ChatExtras]):
+    """Chats exporter with structured extras."""
+
+    def __init__(
+        self,
+        all_agents: list[WaldiezAgent],
+        agent_names: dict[str, str],
+        all_chats: list[WaldiezChat],
+        chat_names: dict[str, str],
+        main_chats: list[WaldiezAgentConnection],
+        root_group_manager: Optional[WaldiezGroupManager],
+        context: Optional[ExporterContext] = None,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize the chats exporter.
+
+        Parameters
+        ----------
+        all_agents : list[WaldiezAgent]
+            All agents involved in the chats.
+        agent_names : dict[str, str]
+            Mapping of agent IDs to their names.
+        all_chats : list[WaldiezChat]
+            All chats to be exported.
+        chat_names : dict[str, str]
+            Mapping of chat IDs to their names.
+        main_chats : list[WaldiezAgentConnection]
+            Main chats that are connections between agents.
+        root_group_manager : Optional[WaldiezGroupManager]
+            The root group manager for managing chat groups, if any.
+        context : Optional[ExporterContext], optional
+            Exporter context with dependencies, by default None
+        **kwargs : Any
+            Additional keyword arguments for the exporter.
+        """
+        super().__init__(context, **kwargs)
+
+        self.all_agents = all_agents
+        self.agent_names = agent_names
+        self.all_chats = all_chats
+        self.chat_names = chat_names
+        self.main_chats = main_chats
+        self.root_group_manager = root_group_manager
+        config = self.context.get_config()
+        self.for_notebook = config.for_notebook
+        self.is_async = config.is_async
+        self.cache_seed = config.cache_seed
+        # Initialize extras with processed chat content
+        self._extras = self._create_chat_extras()
+
+    @property
+    def extras(self) -> ChatExtras:
+        """Get the chat extras."""
+        return self._extras
+
+    # pylint: disable=no-self-use
+    def _create_chat_extras(self) -> ChatExtras:
+        """Create and populate chat extras."""
+        extras = ChatExtras("chats")
+        processor = ChatsProcessor(
+            all_agents=self.all_agents,
+            agent_names=self.agent_names,
+            all_chats=self.all_chats,
+            chat_names=self.chat_names,
+            main_chats=self.main_chats,
+            root_group_manager=self.root_group_manager,
+            for_notebook=self.for_notebook,
+            is_async=self.is_async,
+            cache_seed=self.cache_seed,
+            serializer=self.context.get_serializer(),
+            extras=extras,
+        )
+        processor.process()
+        if extras.chat_registration:
+            extras.append_after_all_agents(extras.chat_registration)
+        return extras
+
+    def generate_main_content(self) -> Optional[str]:
+        """Generate the main content of the export."""
+        return None

waldiez/exporting/chats/factory.py

@@ -0,0 +1,65 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+"""Factory function for creating a ChatsExporter instance."""
+
+from typing import Any, Optional
+
+from waldiez.models import (
+    WaldiezAgent,
+    WaldiezAgentConnection,
+    WaldiezChat,
+    WaldiezGroupManager,
+)
+
+from ..core import ExporterContext, get_default_exporter_context
+from .exporter import ChatsExporter
+
+
+def create_chats_exporter(
+    all_agents: list[WaldiezAgent],
+    agent_names: dict[str, str],
+    all_chats: list[WaldiezChat],
+    chat_names: dict[str, str],
+    main_chats: list[WaldiezAgentConnection],
+    root_group_manager: Optional[WaldiezGroupManager] = None,
+    context: Optional[ExporterContext] = None,
+    **kwargs: Any,
+) -> ChatsExporter:
+    """Create a chats exporter.
+
+    Parameters
+    ----------
+    all_agents : list[WaldiezAgent]
+        All agents involved in the chats.
+    agent_names : dict[str, str]
+        Mapping of agent IDs to their names.
+    all_chats : list[WaldiezChat]
+        All chats to be exported.
+    chat_names : dict[str, str]
+        Mapping of chat IDs to their names.
+    main_chats : list[WaldiezAgentConnection]
+        Main chats that are connections between agents.
+    root_group_manager : Optional[WaldiezGroupManager], optional
+        The root group manager for managing chat groups, if any.
+    context : Optional[ExporterContext], optional
+        Exporter context with dependencies, by default None
+    **kwargs : Any
+        Additional keyword arguments for the exporter.
+
+    Returns
+    -------
+    ChatsExporter
+        The created chats exporter.
+    """
+    if context is None:
+        context = get_default_exporter_context()
+    return ChatsExporter(
+        all_agents=all_agents,
+        agent_names=agent_names,
+        all_chats=all_chats,
+        chat_names=chat_names,
+        main_chats=main_chats,
+        root_group_manager=root_group_manager,
+        context=context,
+        **kwargs,
+    )

waldiez/exporting/chats/processor.py

@@ -0,0 +1,226 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+"""Chats processor."""
+
+from dataclasses import dataclass
+from typing import Optional
+
+from waldiez.models import (
+    WaldiezAgent,
+    WaldiezAgentConnection,
+    WaldiezChat,
+    WaldiezGroupManager,
+)
+
+from ..core import (
+    ChatExtras,
+    ImportPosition,
+    ImportStatement,
+    Serializer,
+)
+from .utils import (
+    export_group_chats,
+    export_nested_chat_registration,
+    export_sequential_chat,
+    export_single_chat,
+)
+
+
+@dataclass
+class ChatParams:
+    """Parameters for the chat export processor."""
+
+    main: list[WaldiezAgentConnection]
+    """Main chats that are connections between agents."""
+    all: list[WaldiezChat]
+    """All the chats in the flow."""
+    names: dict[str, str]
+    """Mapping of chat IDs to their names."""
+
+
+# pylint: disable=too-many-arguments,too-many-positional-arguments
+class ChatsProcessor:
+    """Processor for chats export."""
+
+    def __init__(
+        self,
+        all_agents: list[WaldiezAgent],
+        agent_names: dict[str, str],
+        all_chats: list[WaldiezChat],
+        chat_names: dict[str, str],
+        main_chats: list[WaldiezAgentConnection],
+        root_group_manager: Optional[WaldiezGroupManager],
+        for_notebook: bool,
+        is_async: bool,
+        cache_seed: Optional[int],
+        serializer: Serializer,
+        extras: ChatExtras,
+    ) -> None:
+        """Initialize the chats processor.
+
+        Parameters
+        ----------
+        extras : ChatExtras
+            The structured extras for the chats export.
+        """
+        self._all_agents = all_agents
+        self._agent_names = agent_names
+        self._chats = ChatParams(
+            main=main_chats,
+            all=all_chats,
+            names=chat_names,
+        )
+        self._root_group_manager = root_group_manager
+        self._is_async = is_async
+        self._for_notebook = for_notebook
+        self._cache_seed = cache_seed
+        self._serializer = serializer
+        self._extras = extras
+        chat_tabs = 1
+        if cache_seed is not None:
+            chat_tabs += 1
+        self._chat_tabs = chat_tabs
+
+    def is_group_patterned(self) -> bool:
+        """Check if the chats are group patterned.
+
+        Returns
+        -------
+        bool
+            True if the chats are group patterned, False otherwise.
+        """
+        if len(self._chats.main) == 0 and self._root_group_manager is not None:
+            return True
+        if len(self._chats.main) == 1:
+            main_chat = self._chats.main[0]
+            sender = main_chat["source"]
+            recipient = main_chat["target"]
+            if recipient.is_group_manager or sender.is_group_member:
+                return True
+        return False
+
+    def process(self) -> None:
+        """Process the chats export."""
+        self._gather_imports()
+        self._handle_chat_registrations()
+        chat_initiation = self._generate_chat_initation()
+        self._extras.set_chat_initiation(chat_initiation)
+
+    def _generate_chat_initation(self) -> str:
+        """Generate the chat definition string.
+
+        Returns
+        -------
+        str
+            The chat definition string.
+        """
+        if len(self._chats.main) == 0:
+            if not self._root_group_manager:
+                return ""
+            return export_group_chats(
+                agent_names=self._agent_names,
+                manager=self._root_group_manager,
+                intial_chat=None,
+                tabs=self._chat_tabs,
+                is_async=self._is_async,
+            )
+        if len(self._chats.main) == 1:
+            main_chat = self._chats.main[0]
+            chat = main_chat["chat"]
+            sender = main_chat["source"]
+            recipient = main_chat["target"]
+            if (
+                isinstance(recipient, WaldiezGroupManager)
+                and not chat.message.is_method()
+            ):
+                chat_massage_string: str | None = None
+                if chat.message.type == "string":
+                    chat_massage_string = chat.message.content
+                return export_group_chats(
+                    agent_names=self._agent_names,
+                    manager=recipient,
+                    intial_chat=chat_massage_string,
+                    tabs=self._chat_tabs,
+                    is_async=self._is_async,
+                )
+            chat_string, before_chat = export_single_chat(
+                sender=sender,
+                recipient=recipient,
+                chat=chat,
+                agent_names=self._agent_names,
+                chat_names=self._chats.names,
+                serializer=self._serializer.serialize,
+                tabs=self._chat_tabs,
+                is_async=self._is_async,
+                skip_cache=self._cache_seed is None,
+            )
+            if before_chat:
+                self._extras.set_chat_prerequisites(before_chat)
+            return chat_string
+        chat_string, before_chat = export_sequential_chat(
+            main_chats=self._chats.main,
+            agent_names=self._agent_names,
+            chat_names=self._chats.names,
+            serializer=self._serializer.serialize,
+            tabs=self._chat_tabs,
+            is_async=self._is_async,
+            skip_cache=self._cache_seed is None,
+        )
+        if before_chat:
+            self._extras.set_chat_prerequisites(before_chat)
+        return chat_string
+
+    def _handle_chat_registrations(self) -> None:
+        """Handle chat registrations."""
+        for agent in self._all_agents:
+            if (
+                agent.agent_type != "group_manager"
+                and not agent.is_group_member
+            ):
+                registration_string = export_nested_chat_registration(
+                    agent=agent,
+                    all_chats=self._chats.all,
+                    chat_names=self._chats.names,
+                    agent_names=self._agent_names,
+                    serializer=self._serializer.serialize,
+                    is_async=self._is_async,
+                )
+                self._extras.add_registration(registration_string)
+
+    def _gather_imports(self) -> None:
+        """Get the imports string.
+
+        Returns
+        -------
+        list[tuple[str, ImportPosition]]
+            List of import strings and their positions.
+        """
+        if self.is_group_patterned():
+            if self._is_async:
+                import_string = (
+                    "from autogen.agentchat import a_initiate_group_chat"
+                )
+            else:
+                import_string = (
+                    "from autogen.agentchat import initiate_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/__init__.py

@@ -1,15 +1,16 @@
 # SPDX-License-Identifier: Apache-2.0.
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
-"""Utils for exporting chats."""
+"""Chat utils for exporting chatsper chat type."""
 
-from .nested import export_nested_chat_registration
+from .group import export_group_chats
+from .nested import export_nested_chat_registration, get_nested_chat_queue
 from .sequential import export_sequential_chat
-from .single_chat import export_single_chat
-from .swarm import export_swarm_chat
+from .single import export_single_chat
 
 __all__ = [
+    "export_group_chats",
     "export_nested_chat_registration",
+    "get_nested_chat_queue",
     "export_sequential_chat",
     "export_single_chat",
-    "export_swarm_chat",
 ]

waldiez/exporting/chats/utils/common.py

@@ -2,44 +2,16 @@
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
 """Common utilities for exporting chats."""
 
-from typing import Any, Callable, Dict, Optional, Tuple
+from typing import Optional
 
 from waldiez.models import WaldiezAgent, WaldiezChat
 
 
-def update_summary_chat_args(
-    chat_args: Dict[str, Any],
-    string_escape: Callable[[str], str],
-) -> Dict[str, Any]:
-    """Escape quotes in the summary args if they are strings.
-
-    Parameters
-    ----------
-    chat_args : Dict[str, Any]
-        The chat arguments.
-    string_escape : Callable[[str], str]
-        The function to escape the string
-
-    Returns
-    -------
-    Dict[str, Any]
-        The chat arguments with the summary prompt escaped.
-    """
-    if "summary_args" in chat_args and isinstance(
-        chat_args["summary_args"], dict
-    ):
-        for key, value in chat_args["summary_args"].items():
-            if isinstance(value, str):
-                chat_args["summary_args"][key] = string_escape(value)
-    return chat_args
-
-
 def get_chat_message_string(
     sender: WaldiezAgent,
     chat: WaldiezChat,
-    chat_names: Dict[str, str],
-    string_escape: Callable[[str], str],
-) -> Tuple[str, Optional[str]]:
+    chat_names: dict[str, str],
+) -> tuple[str, Optional[str]]:
     """Get the agent's message as a string.
 
     Parameters
@@ -48,31 +20,25 @@ def get_chat_message_string(
         The sender.
     chat : WaldiezChat
         The chat.
-    chat_names : Dict[str, str]
+    chat_names : dict[str, str]
         A mapping of chat id to chat name with all the chats in the flow.
-    string_escape : Callable[[str], str]
-        The function to escape the string.
 
     Returns
     -------
-    Tuple[str, Optional[str]]
+    tuple[str, Optional[str]]
         If the message is a string, the message content and None.
         If the message is a method, the method name and the method content.
         If the message is None, 'None' and None.
     """
-    if (
-        not chat.message
-        or chat.message.type == "none"
-        or chat.message.content is None
-        or chat.message_content is None
-    ):
+    if not chat.message or chat.message.type == "none":
         return "None", None
     if chat.message.type == "string":
-        return string_escape(chat.message.content), None
+        if chat.message.content is None:  # pragma: no cover
+            # should be coverred previousliy on pydantic validation
+            return "None", None
+        return chat.message.content, None
 
-    is_rag_with_carryover = (
-        sender.agent_type == "rag_user" and chat.message.use_carryover
-    )
+    is_rag_with_carryover = sender.is_rag_user and chat.message.use_carryover
     chat_name = chat_names[chat.id]
     function_content, function_name = chat.get_message_function(
         name_suffix=chat_name,

waldiez/exporting/chats/utils/group.py

@@ -0,0 +1,55 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+
+"""Exporting group chat utils.
+
+Using the group patterns (no group manager agent)
+"""
+
+import json
+
+from waldiez.models import WaldiezGroupManager
+
+
+def export_group_chats(
+    agent_names: dict[str, str],
+    manager: WaldiezGroupManager,
+    intial_chat: str | None,
+    tabs: int,
+    is_async: bool,
+) -> str:
+    """Get the group chat string.
+
+    Parameters
+    ----------
+    agent_names : dict[str, str]
+        The agent names.
+    manager : WaldiezGroupManager
+        The group manager agent.
+    intial_chat : str | None
+        The initial chat to use if any.
+    tabs : int
+        The number of tabs for indentation.
+    is_async : bool
+        Whether the chat is asynchronous.
+
+    Returns
+    -------
+    tuple[str, str]
+        The group chat string and the import string.
+    """
+    tab = "    " * tabs
+    initiate_group_chat = "initiate_group_chat"
+    if is_async:
+        initiate_group_chat = "a_initiate_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}    pattern={pattern_name}," + "\n"
+    if intial_chat:
+        content += f"{tab}    messages={json.dumps(intial_chat)}," + "\n"
+    else:
+        content += f'{tab}    messages="",\n'
+    content += f"{tab}    max_rounds={manager.data.max_round},\n"
+    content += f"{tab})\n"
+    return content