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

waldiez/exporting/agent/processor.py

@@ -0,0 +1,150 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+# pylint: disable=too-few-public-methods, no-self-use
+"""Processor for generating Waldiez agent definitions."""
+
+import json
+from dataclasses import dataclass
+from typing import Callable
+
+from waldiez.models import WaldiezAgent
+
+from ..core.enums import GroupManagerStrategy
+from ..core.extras.agent_extras import GroupManagerExtras, StandardExtras
+
+
+@dataclass
+class AgentProcessingResult:
+    """Result from processing an agent."""
+
+    content: str = ""
+
+
+class AgentProcessor:
+    """Processor for main agent definition generation."""
+
+    def __init__(
+        self,
+        agent: WaldiezAgent,
+        agent_names: dict[str, str],
+        arguments_resolver: Callable[[WaldiezAgent], list[str]],
+        extras: StandardExtras,
+    ):
+        self.agent = agent
+        self.agent_names = agent_names
+        self.arguments_resolver = arguments_resolver
+        self.extras = extras
+
+    def _should_skip_group_manager(self) -> bool:
+        """Check if the group manager should be skipped.
+
+        Returns
+        -------
+        bool
+            True if the group manager should be skipped, False otherwise.
+        """
+        return (
+            isinstance(self.extras, GroupManagerExtras)
+            and self.extras.strategy == GroupManagerStrategy.PATTERN
+        )
+
+    def process(self) -> AgentProcessingResult:
+        """Process the agent and generate its definition.
+
+        Returns
+        -------
+        str
+            The generated agent definition string.
+        """
+        if (
+            isinstance(self.extras, GroupManagerExtras)
+            and self._should_skip_group_manager()
+        ):
+            return AgentProcessingResult(content="")
+        agent_name = self.agent_names[self.agent.id]
+
+        ag2_class = self.agent.ag2_class
+        # Build extra arguments
+        extra_args = ""
+        for arg in self.extras.extra_args:
+            extra_args += arg.get_content(append_new_line=True)
+
+        # Get additional arguments from resolver
+        resolved_args = self.arguments_resolver(self.agent)
+        if resolved_args:  # pragma: no branch
+            extra_args += ",\n".join(resolved_args)
+        # 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}
+)"""
+
+        return AgentProcessingResult(content=agent_str)
+
+    def get_name_arg(self) -> str:
+        """Get the agent name argument.
+
+        Returns
+        -------
+        str
+            The agent name argument.
+        """
+        return f'    name="{self.agent_names[self.agent.id]}",'
+
+    def get_human_input_mode_arg(self) -> str:
+        """Get the human input mode argument.
+
+        Returns
+        -------
+        str
+            The human input mode argument.
+        """
+        return f'    human_input_mode="{self.agent.data.human_input_mode}"'
+
+    def get_max_consecutive_auto_reply_arg(self) -> str:
+        """Get the maximum consecutive auto reply argument.
+
+        Returns
+        -------
+        str
+            The maximum consecutive auto reply argument.
+        """
+        value = self.agent.data.max_consecutive_auto_reply
+        return f"    max_consecutive_auto_reply={value}"
+
+    def get_description_arg(self) -> str:
+        """Get the agent description.
+
+        Returns
+        -------
+        str
+            The agent description.
+        """
+        description = (
+            json.dumps(self.agent.description)
+            if self.agent.description
+            else '""'
+        )
+        return f"    description={description}"
+
+    def get_auto_reply_arg(self) -> str:
+        """Get the default auto reply argument.
+
+        Returns
+        -------
+        str
+            The default auto reply argument.
+        """
+        default_auto_reply = '""'
+        if self.agent.data.agent_default_auto_reply:
+            # Escape the default auto reply string
+            default_auto_reply = json.dumps(
+                self.agent.data.agent_default_auto_reply
+            )
+        return f"    default_auto_reply={default_auto_reply}"

waldiez/exporting/agent/system_message.py

@@ -0,0 +1,36 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+# pylint: disable=too-few-public-methods
+"""Termination message configuration for Waldiez agents."""
+
+import json
+
+from waldiez.models import WaldiezAgent
+
+from ..core import SystemMessageConfig
+
+
+class SystemMessageProcessor:
+    """Processor for system message configuration."""
+
+    def __init__(
+        self,
+        agent: WaldiezAgent,
+    ):
+        self.agent = agent
+
+    def process(self) -> SystemMessageConfig:
+        """Process system message configuration.
+
+        Returns
+        -------
+        SystemMessageConfig
+            The processed system message configuration.
+        """
+        if not self.agent.data.system_message:
+            return SystemMessageConfig()
+
+        return SystemMessageConfig(
+            before_agent_conent="",
+            system_message_arg=json.dumps(self.agent.data.system_message),
+        )

waldiez/exporting/agent/termination.py

@@ -0,0 +1,50 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+# pylint: disable=too-few-public-methods
+"""Termination message configuration for Waldiez agents."""
+
+from waldiez.models import WaldiezAgent
+
+from ..core import TerminationConfig
+
+
+class TerminationProcessor:
+    """Processor for termination message configuration."""
+
+    def __init__(
+        self,
+        agent: WaldiezAgent,
+        agent_name: str,
+    ):
+        self.agent = agent
+        self.agent_name = agent_name
+
+    def process(self) -> TerminationConfig:
+        """Process termination configuration.
+
+        Returns
+        -------
+        TerminationConfig
+            The processed termination configuration.
+        """
+        if self.agent.data.termination.type == "none":
+            return TerminationConfig(
+                termination_arg="None",
+                before_content="",
+            )
+        if self.agent.data.termination.type == "keyword":
+            return TerminationConfig(
+                termination_arg=self.agent.data.termination.string,
+                before_content="",
+            )
+        if self.agent.data.termination.type == "method":
+            content, function_name = (
+                self.agent.data.termination.get_termination_function(
+                    name_suffix=self.agent_name
+                )
+            )
+            return TerminationConfig(
+                termination_arg=function_name,
+                before_content="\n\n" + content + "\n",
+            )
+        return TerminationConfig()

waldiez/exporting/chats/__init__.py

@@ -1,7 +1,11 @@
 # SPDX-License-Identifier: Apache-2.0.
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
-"""Export chats in a flow."""
+"""Chats exporter."""
 
-from .chats_exporter import ChatsExporter
+from .exporter import ChatsExporter
+from .factory import create_chats_exporter
 
-__all__ = ["ChatsExporter"]
+__all__ = [
+    "ChatsExporter",
+    "create_chats_exporter",
+]

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",
 ]