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

waldiez/exporting/agent/extras/group_member_extras.py

@@ -0,0 +1,181 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+# pylint: disable=no-self-use,too-few-public-methods
+"""Group member agent configuration processor."""
+
+from dataclasses import dataclass, field
+from typing import Callable
+
+from waldiez.models import (
+    WaldiezAgent,
+    WaldiezAgentUpdateSystemMessage,
+    WaldiezChat,
+)
+
+from ...core import (
+    ImportStatement,
+    InstanceArgument,
+)
+from .handoffs import HandoffProcessor
+
+
+@dataclass
+class GroupMemberProcessorResult:
+    """Result from processing group member agent configuration."""
+
+    before_agent: str = ""
+    after_agent: str = ""
+    extra_arguments: list[InstanceArgument] = field(
+        default_factory=list[InstanceArgument]
+    )
+    extra_imports: set[ImportStatement] = field(
+        default_factory=set[ImportStatement]
+    )
+
+
+class GroupMemberAgentProcessor:
+    """Processor for group member agent configuration."""
+
+    result: GroupMemberProcessorResult
+
+    def __init__(
+        self,
+        agent: WaldiezAgent,
+        agent_names: dict[str, str],
+        tool_names: dict[str, str],
+        all_chats: list[WaldiezChat],
+        chat_names: dict[str, str],
+        serializer: Callable[..., str],
+    ) -> None:
+        self.agent = agent
+        self.agent_names = agent_names
+        self.tool_names = tool_names
+        self.all_chats = all_chats
+        self.chat_names = chat_names
+        self.serializer = serializer
+
+    def process(
+        self,
+    ) -> GroupMemberProcessorResult:
+        """Process group member agent configuration.
+
+        Returns
+        -------
+        GroupMemberProcessorResult
+            The processed result containing before_agent code,
+            after_agent code, and extra imports.
+        """
+        self.result = GroupMemberProcessorResult()
+        if not self.agent.is_group_member:
+            return self.result
+        self._process_agent_functions()
+        self._process_agent_update_state_before_reply()
+        self._process_handoff_registrations()
+        return self.result
+
+    def _process_agent_functions(self) -> None:
+        """Process function arguments for the agent."""
+        tab = "    "
+        arg_string = "["
+
+        tools_added = self._add_tools()
+        if tools_added:
+            arg_string += f"{tools_added}\n{tab}"
+
+        arg_string += "]"
+        self.result.extra_arguments.append(
+            InstanceArgument(
+                name="functions",
+                value=arg_string,
+                instance_id=self.agent.id,
+                tabs=1,
+            )
+        )
+
+    def _add_tools(self) -> str:
+        """Add tools to the function arguments."""
+        tab = "    "
+        arg_string = ""
+        for tool in self.agent.data.tools:
+            tool_name = self.tool_names.get(tool.id)
+            if tool_name:
+                arg_string += f"\n{tab}{tab}{tool_name},"
+        return arg_string
+
+    def _process_agent_update_state_before_reply(self) -> None:
+        """Process agent update state before reply configuration."""
+        tab = "    "
+        arg_string = "["
+
+        arcg_content = self._process_update_functions()
+
+        if arcg_content:
+            arg_string += f"{arcg_content}\n{tab}"
+            self.result.extra_imports.add(
+                ImportStatement("from autogen import UpdateSystemMessage")
+            )
+        arg_string += "]"
+        self.result.extra_arguments.append(
+            InstanceArgument(
+                name="update_agent_state_before_reply",
+                value=arg_string,
+                instance_id=self.agent.id,
+                tabs=1,
+            )
+        )
+
+    def _process_update_functions(
+        self,
+    ) -> str:
+        """Process individual update functions."""
+        arg_content = ""
+
+        for function in self.agent.data.update_agent_state_before_reply:
+            if isinstance(function, WaldiezAgentUpdateSystemMessage):
+                arg_content = self._process_system_message_update(function)
+            else:
+                arg_content = self._process_tool_update(function)
+
+        return arg_content
+
+    def _process_system_message_update(
+        self,
+        function: WaldiezAgentUpdateSystemMessage,
+    ) -> str:
+        """Process system message update function."""
+        tab = "    "
+        space = tab * 2
+        if function.type == "callable":
+            content, name = function.get_content(
+                name_suffix=self.agent_names[self.agent.id]
+            )
+            arg_string = f"\n{space}UpdateSystemMessage({name}),"
+            self.result.before_agent += content + "\n"
+        else:
+            dumped = self.serializer(function.content)
+            arg_string = f"\n{space}UpdateSystemMessage({dumped}),"
+        return arg_string
+
+    def _process_tool_update(
+        self,
+        function_id: str,
+    ) -> str:
+        """Process tool-based update function."""
+        tool_name = self.tool_names.get(function_id)
+        if tool_name:
+            tab = "    "
+            return f"\n{tab}{tab}{tool_name},"
+        return ""
+
+    def _process_handoff_registrations(self) -> None:
+        """Process handoff registrations for the agent."""
+        result = HandoffProcessor(
+            agent=self.agent,
+            agent_names=self.agent_names,
+            chat_names=self.chat_names,
+            all_chats=self.all_chats,
+            serializer=self.serializer,
+        ).process()
+        for extra_import in result.extra_imports:
+            self.result.extra_imports.add(ImportStatement(extra_import))
+        self.result.after_agent += result.after_agent

waldiez/exporting/agent/extras/handoffs/__init__.py

@@ -0,0 +1,19 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+"""Utility functions for generating agent related strings."""
+
+from .after_work import AfterWorkProcessor, AfterWorkResult
+from .handoff import HandoffProcessor, HandoffResult
+from .target import (
+    TargetResult,
+    TransitionTargetProcessor,
+)
+
+__all__ = [
+    "AfterWorkProcessor",
+    "AfterWorkResult",
+    "HandoffProcessor",
+    "HandoffResult",
+    "TargetResult",
+    "TransitionTargetProcessor",
+]

waldiez/exporting/agent/extras/handoffs/after_work.py

@@ -0,0 +1,78 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+"""After-work processor for Waldiez agents."""
+
+# pylint: disable=too-few-public-methods
+from dataclasses import dataclass, field
+from typing import Callable
+
+from waldiez.models import WaldiezAgent, WaldiezChat, WaldiezTransitionTarget
+
+from .target import TransitionTargetProcessor
+
+
+@dataclass
+class AfterWorkResult:
+    """Result from processing after-work configuration.
+
+    Attributes
+    ----------
+    registration : str
+        Code to register the after-work transition.
+    after_agent : str
+        Code to be placed after the agent definition.
+    extra_imports : set[str]
+        Additional imports required for the after-work transition.
+    """
+
+    content: str = ""
+    before_content: str = ""
+    extra_imports: set[str] = field(default_factory=set[str])
+
+
+class AfterWorkProcessor:
+    """Processor for after-work configurations."""
+
+    def __init__(
+        self,
+        agent: WaldiezAgent,
+        agent_names: dict[str, str],
+        chat_names: dict[str, str],
+        all_chats: list[WaldiezChat],
+        serializer: Callable[..., str],
+    ):
+        """Initialize the processor."""
+        self.agent = agent
+        self.agent_names = agent_names
+        self.agent_name = agent_names[agent.id]
+        self.chat_names = chat_names
+        self.all_chats = all_chats
+        self.serializer = serializer
+
+    def process(self, after_work: WaldiezTransitionTarget) -> AfterWorkResult:
+        """Process after-work configuration.
+
+        Parameters
+        ----------
+        after_work : WaldiezTransitionTarget
+            The after-work transition target to process.
+
+        Returns
+        -------
+        AfterWorkResult
+            The processed result containing the registration string,
+            before_content code, and extra imports.
+        """
+        target_processor = TransitionTargetProcessor(
+            agent=self.agent,
+            agent_names=self.agent_names,
+            chat_names=self.chat_names,
+            all_chats=self.all_chats,
+            serializer=self.serializer,
+        )
+        target_result = target_processor.process(after_work)
+        return AfterWorkResult(
+            content=target_result.content,
+            before_content=target_result.before_content,
+            extra_imports=target_result.extra_imports,
+        )

waldiez/exporting/agent/extras/handoffs/available.py

@@ -0,0 +1,74 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+# pylint: disable=too-few-public-methods
+"""Transition availability processor for Waldiez agents."""
+
+from dataclasses import dataclass, field
+from typing import Callable
+
+from waldiez.models import WaldiezTransitionAvailability
+
+
+@dataclass
+class TransitionAvailableResult:
+    """Result from processing transition availability."""
+
+    content: str = ""
+    extra_imports: set[str] = field(default_factory=set[str])
+
+
+class TransitionAvailableProcessor:
+    """Processor for transition availability."""
+
+    def __init__(
+        self,
+        serializer: Callable[..., str],
+    ) -> None:
+        """Initialize the processor."""
+        self.serializer = serializer
+
+    def process(
+        self,
+        available: WaldiezTransitionAvailability,
+    ) -> TransitionAvailableResult:
+        """Process the transition availability.
+
+        Parameters
+        ----------
+        available : WaldiezTransitionAvailability
+            The transition availability to process.
+
+        Returns
+        -------
+        TransitionAvailableResult
+            The result of processing the transition availability.
+
+        Raises
+        ------
+        ValueError
+            If the transition type is unsupported.
+        """
+        result = TransitionAvailableResult()
+        if available.type == "none":
+            return result
+        import_prefix = "from autogen.agentchat.group import "
+        if available.type == "string":
+            content = self.serializer(available.value)
+            result.content = f"StringAvailableCondition({content})"
+            result.extra_imports.add(f"{import_prefix}StringAvailableCondition")
+            return result
+        if available.type == "expression":
+            content = self.serializer(available.value)
+            result.content = (
+                "ExpressionAvailableCondition(\n"
+                f"            expression=ContextExpression({content})\n"
+                "        )"
+            )
+            result.extra_imports.add(
+                f"{import_prefix}ExpressionAvailableCondition"
+            )
+            result.extra_imports.add(f"{import_prefix}ContextExpression")
+            return result
+        raise ValueError(
+            f"Unsupported transition availability type: {available.type}"
+        )

waldiez/exporting/agent/extras/handoffs/condition.py

@@ -0,0 +1,158 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+# pylint: disable=too-few-public-methods
+"""Handoff condition processing for Waldiez agents."""
+
+from dataclasses import dataclass, field
+from typing import Callable
+
+from waldiez.models import (
+    WaldiezAgent,
+    WaldiezChat,
+    WaldiezContextStrLLMCondition,
+    WaldiezExpressionContextCondition,
+    WaldiezHandoffCondition,
+    WaldiezStringContextCondition,
+    WaldiezStringLLMCondition,
+)
+
+
+@dataclass
+class ConditionResult:
+    """Result from processing handoff conditions.
+
+    Attributes
+    ----------
+    content : str
+        Content to be used for the handoff condition.
+    extra_imports : set[str]
+        Additional imports required for the handoff.
+    """
+
+    content: str = ""
+    extra_imports: set[str] = field(default_factory=set[str])
+
+
+class ConditionProcessor:
+    """Processor for handoff conditions."""
+
+    IMPORT_PREFIX = "from autogen.agentchat.group import "
+
+    def __init__(
+        self,
+        agent: WaldiezAgent,
+        agent_names: dict[str, str],
+        chat_names: dict[str, str],
+        all_chats: list[WaldiezChat],
+        serializer: Callable[..., str],
+    ) -> None:
+        """Initialize the processor with agent context."""
+        self.agent = agent
+        self.agent_names = agent_names
+        self.agent_name = agent_names[agent.id]
+        self.chat_names = chat_names
+        self.all_chats = all_chats
+        self.serializer = serializer
+        self.result = ConditionResult()
+
+    def process(self, condition: WaldiezHandoffCondition) -> ConditionResult:
+        """Process handoff conditions.
+
+        Parameters
+        ----------
+        condition : WaldiezHandoffCondition
+            The handoff condition to process.
+
+        Returns
+        -------
+        ConditionResult
+            The processed result containing the relevant code and extra imports.
+
+        Raises
+        ------
+        ValueError
+            If the condition type is unsupported.
+        """
+        if isinstance(condition, WaldiezStringLLMCondition):
+            self._process_string_llm_condition(condition)
+        elif isinstance(condition, WaldiezContextStrLLMCondition):
+            self._process_context_str_llm_condition(condition)
+        elif isinstance(condition, WaldiezStringContextCondition):
+            self._process_string_context_condition(condition)
+        elif isinstance(
+            condition,
+            WaldiezExpressionContextCondition,
+        ):  # pyright: ignore
+            self._process_expression_context_condition(condition)
+        else:
+            raise ValueError(f"Unsupported condition type: {type(condition)}")
+        return self.result
+
+    def _process_string_llm_condition(
+        self,
+        condition: WaldiezStringLLMCondition,
+    ) -> None:
+        """Process a string LLM condition handoff."""
+        prompt = self.serializer(condition.prompt)
+
+        if hasattr(condition, "data") and condition.data:
+            data_str = self.serializer(condition.data)
+            condition_string = (
+                f"StringLLMCondition(prompt={prompt}, data={data_str})"
+            )
+        else:
+            condition_string = f"StringLLMCondition(prompt={prompt})"
+        self.result.content += condition_string
+        extra_import = f"{self.IMPORT_PREFIX}StringLLMCondition"
+        self.result.extra_imports.add(extra_import)
+
+    def _process_context_str_llm_condition(
+        self,
+        condition: WaldiezContextStrLLMCondition,
+    ) -> None:
+        """Process a context string LLM condition handoff."""
+        context_str = self.serializer(
+            condition.context_str,
+        )
+
+        if hasattr(condition, "data") and condition.data:
+            data_str = self.serializer(condition.data)
+            condition_string = (
+                f"ContextStrLLMCondition(context_str={context_str}, "
+                f"data={data_str})"
+            )
+        else:
+            condition_string = (
+                f"ContextStrLLMCondition(context_str={context_str})"
+            )
+        self.result.content += condition_string
+        extra_import = f"{self.IMPORT_PREFIX}ContextStrLLMCondition"
+        self.result.extra_imports.add(extra_import)
+
+    def _process_string_context_condition(
+        self,
+        condition: WaldiezStringContextCondition,
+    ) -> None:
+        """Process a string context condition handoff."""
+        variable_name = self.serializer(
+            condition.variable_name,
+        )
+        condition_string = (
+            f"StringContextCondition(variable_name={variable_name})"
+        )
+        self.result.content += condition_string
+        extra_import = f"{self.IMPORT_PREFIX}StringContextCondition"
+        self.result.extra_imports.add(extra_import)
+
+    def _process_expression_context_condition(
+        self,
+        condition: WaldiezExpressionContextCondition,
+    ) -> None:
+        """Process an expression context condition handoff."""
+        expression = self.serializer(condition.expression)
+        condition_string = (
+            f"ExpressionContextCondition(expression={expression})"
+        )
+        self.result.content += condition_string
+        extra_import = f"{self.IMPORT_PREFIX}ExpressionContextCondition"
+        self.result.extra_imports.add(extra_import)

waldiez/exporting/agent/extras/handoffs/handoff.py

@@ -0,0 +1,171 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+# pylint: disable=too-few-public-methods
+"""Handoff processor for Waldiez agents."""
+
+from dataclasses import dataclass, field
+from typing import Callable
+
+from waldiez.models import (
+    WaldiezAgent,
+    WaldiezChat,
+    WaldiezHandoff,
+    WaldiezTransitionTarget,
+)
+
+from .available import (
+    TransitionAvailableProcessor,
+    TransitionAvailableResult,
+)
+from .condition import ConditionProcessor, ConditionResult
+from .target import TargetResult, TransitionTargetProcessor
+
+
+@dataclass
+class HandoffResult:
+    """Result from processing handoffs.
+
+    Attributes
+    ----------
+        Content to be placed before the agent definition.
+    after_agent : str
+        Content to be placed after the agent definition.
+    extra_imports : set[str]
+        Additional imports required for the handoff.
+    """
+
+    after_agent: str = ""
+    extra_imports: set[str] = field(default_factory=set[str])
+
+
+class HandoffProcessor:
+    """Processor for agent handoffs."""
+
+    result: HandoffResult
+    IMPORT_PREFIX = "from autogen.agentchat.group import "
+
+    def __init__(
+        self,
+        agent: WaldiezAgent,
+        agent_names: dict[str, str],
+        chat_names: dict[str, str],
+        all_chats: list[WaldiezChat],
+        serializer: Callable[..., str],
+    ) -> None:
+        self.agent = agent
+        self.agent_names = agent_names
+        self.agent_name = agent_names[agent.id]
+        self.chat_names = chat_names
+        self.all_chats = all_chats
+        self.serializer = serializer
+        self.result = HandoffResult()
+
+    def process(self) -> HandoffResult:
+        """Process all handoff configurations.
+
+        Returns
+        -------
+        HandoffResult
+            The processed handoff result containing after_agent code,
+            and extra imports.
+        """
+        for handoff in self.agent.handoffs:
+            if handoff.is_empty():
+                continue
+            target = TransitionTargetProcessor(
+                agent=self.agent,
+                agent_names=self.agent_names,
+                chat_names=self.chat_names,
+                all_chats=self.all_chats,
+                serializer=self.serializer,
+            ).process(target=handoff.target)
+            self.result.extra_imports.update(target.extra_imports)
+            if target.before_content:
+                self.result.after_agent += f"{target.before_content}\n"
+            condition = ConditionProcessor(
+                agent=self.agent,
+                agent_names=self.agent_names,
+                chat_names=self.chat_names,
+                all_chats=self.all_chats,
+                serializer=self.serializer,
+            ).process(condition=handoff.condition)
+            self.result.extra_imports.update(condition.extra_imports)
+            available = TransitionAvailableProcessor(
+                serializer=self.serializer,
+            ).process(
+                available=handoff.available,
+            )
+            registration = self._create_handoff_registration(
+                handoff=handoff,
+                target=target,
+                condition=condition,
+                available=available,
+            )
+            self.result.extra_imports.update(available.extra_imports)
+            if registration:
+                self.result.after_agent += f"{registration}\n"
+
+        if self.agent.data.after_work:
+            after_work_result = self._process_after_work(
+                self.agent.data.after_work
+            )
+            if after_work_result.before_content:
+                self.result.after_agent += (
+                    f"{after_work_result.before_content}\n"
+                )
+            self.result.after_agent += after_work_result.content
+            self.result.extra_imports.update(after_work_result.extra_imports)
+        return self.result
+
+    def _create_handoff_registration(
+        self,
+        handoff: WaldiezHandoff,
+        target: TargetResult,
+        condition: ConditionResult,
+        available: TransitionAvailableResult,
+    ) -> str:
+        """Create the handoff registration string."""
+        if handoff.is_empty():
+            return ""
+        reg_string = ""
+        if handoff.is_llm_based():
+            reg_string += f"{self.agent_name}.handoffs.add_llm_condition(\n"
+            reg_string += "    condition=OnCondition(\n"
+            self.result.extra_imports.add(f"{self.IMPORT_PREFIX}OnCondition")
+        else:
+            reg_string += f"{self.agent_name}.handoffs.add_context_condition(\n"
+            reg_string += "    condition=OnContextCondition(\n"
+            self.result.extra_imports.add(
+                f"{self.IMPORT_PREFIX}OnContextCondition"
+            )
+        reg_string += f"        target={target.content},\n"
+        reg_string += f"        condition={condition.content},\n"
+        if available.content:
+            reg_string += f"        available={available.content},\n"
+        reg_string += "    )\n"
+        reg_string += ")"
+        return reg_string
+
+    def _process_after_work(
+        self, after_work: WaldiezTransitionTarget
+    ) -> TargetResult:
+        target_processor = TransitionTargetProcessor(
+            agent=self.agent,
+            agent_names=self.agent_names,
+            chat_names=self.chat_names,
+            all_chats=self.all_chats,
+            serializer=self.serializer,
+        )
+        target_result = target_processor.process(after_work)
+        if not target_result.content:
+            return TargetResult()
+        registration = (
+            f"{self.agent_name}.handoffs.set_after_work(\n"
+            f"    target={target_result.content}\n"
+            ")"
+        )
+        return TargetResult(
+            content=registration,
+            before_content=target_result.before_content,
+            extra_imports=target_result.extra_imports,
+        )