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

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

@@ -0,0 +1,53 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+"""RAG related extas."""
+
+from dataclasses import dataclass, field
+
+from waldiez.exporting.core.result import ExportResult
+
+from ...enums import AgentPosition, ExportPosition
+from .standard_extras import StandardExtras
+
+
+@dataclass
+class RAGUserExtras(StandardExtras):
+    """RAG configuration."""
+
+    before_content: str = ""
+    imports: set[str] = field(default_factory=set[str])
+
+    def _contribute_specific_content(self, result: ExportResult) -> None:
+        """Contribute RAG specific content to the export result."""
+        if self.extra_args:
+            for arg in self.extra_args:
+                result.add_instance_argument(
+                    name=arg.name,
+                    value=arg.value,
+                    instance_id=arg.instance_id,
+                    tabs=arg.tabs,
+                )
+        if self.imports:
+            for imp in self.imports:
+                result.add_import(imp)
+        if self.before_content.strip():
+            result.add_content(
+                self.before_content,
+                position=ExportPosition.AGENTS,
+                agent_position=AgentPosition.BEFORE,
+                agent_id=self.instance_id,
+            )
+
+    def has_specific_content(self) -> bool:
+        """Check if there's any RAG content.
+
+        Returns
+        -------
+        bool
+            True if there's any RAG configuration.
+        """
+        if not super().has_specific_content():
+            return bool(
+                self.extra_args or self.before_content.strip() or self.imports
+            )
+        return True

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

@@ -0,0 +1,68 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+# pylint: disable=too-few-public-methods
+"""Resoning agent extras module."""
+
+from dataclasses import dataclass
+
+from waldiez.exporting.core.result import ExportResult
+
+from ...enums import AgentPosition, ExportPosition
+from .standard_extras import StandardExtras
+
+
+@dataclass
+class ReasoningExtras(StandardExtras):
+    """Extras for reasoning agents."""
+
+    def _contribute_specific_content(self, result: ExportResult) -> None:
+        """Contribute reasoning specific content to the export result.
+
+        Parameters
+        ----------
+        result : ExportResult
+            The export result to contribute to.
+        """
+        super()._contribute_specific_content(result)
+        if self.extra_args:
+            for arg in self.extra_args:
+                result.add_instance_argument(
+                    name=arg.name,
+                    value=arg.value,
+                    instance_id=arg.instance_id,
+                    tabs=arg.tabs,
+                )
+        if self.extra_imports:
+            for imp in self.extra_imports:
+                result.add_import(imp.statement, imp.position)
+        if self.before_agent.strip():
+            result.add_content(
+                self.before_agent,
+                position=ExportPosition.AGENTS,
+                agent_position=AgentPosition.BEFORE,
+                agent_id=self.instance_id,
+            )
+        if self.after_agent.strip():
+            result.add_content(
+                self.after_agent,
+                position=ExportPosition.AGENTS,
+                agent_position=AgentPosition.AFTER,
+                agent_id=self.instance_id,
+            )
+
+    def has_specific_content(self) -> bool:
+        """Check for reasoning specific content.
+
+        Returns
+        -------
+        bool
+            True if there's reasoning specific content.
+        """
+        if not super().has_specific_content():
+            return bool(
+                self.extra_args
+                or self.extra_imports
+                or self.before_agent.strip()
+                or self.after_agent.strip()
+            )
+        return True

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

@@ -0,0 +1,263 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+# pylint: disable=too-few-public-methods,no-self-use
+"""Standard agent extras module."""
+
+from dataclasses import dataclass
+from typing import Optional
+
+from ...enums import AgentPosition, ExportPosition
+from ...result import ExportResult
+from ...types import ImportStatement, InstanceArgument
+from ..base import BaseExtras
+
+
+@dataclass
+class TerminationConfig:
+    """Termination configuration."""
+
+    termination_arg: str = "None"
+    before_content: str = ""
+
+    def has_content(self) -> bool:
+        """Check if there's any termination content.
+
+        Returns
+        -------
+        bool
+            True if there's any termination configuration.
+        """
+        return bool(self.before_content.strip())
+
+
+@dataclass
+class CodeExecutionConfig:
+    """Code execution configuration."""
+
+    executor_content: str = ""
+    executor_argument: str = "False"
+    executor_import: ImportStatement | None = None
+
+    def has_content(self) -> bool:
+        """Check if there's any code execution content.
+
+        Returns
+        -------
+        bool
+            True if there's any code execution configuration.
+        """
+        return bool(
+            self.executor_content.strip()
+            or self.executor_argument != "False"
+            or self.executor_import
+        )
+
+
+@dataclass
+class SystemMessageConfig:
+    """System message configuration."""
+
+    # in case we support later custom methods for system messages
+    before_agent_conent: str = ""
+    system_message_arg: str = ""
+
+    def has_content(self) -> bool:
+        """Check if there's any system message content.
+
+        Returns
+        -------
+        bool
+            True if there's any system message configuration.
+        """
+        return bool(str(self.system_message_arg).strip())
+
+
+@dataclass
+class StandardExtras(BaseExtras):
+    """Extras for standard agents (UserProxy, Assistant, etc.)."""
+
+    code_execution_config: Optional[CodeExecutionConfig] = None
+    termination_config: Optional[TerminationConfig] = None
+    system_message_config: Optional[SystemMessageConfig] = None
+
+    def set_code_execution(self, config: CodeExecutionConfig) -> None:
+        """Set code execution configuration.
+
+        Parameters
+        ----------
+        config : CodeExecutionConfig
+            The code execution configuration.
+        """
+        self.code_execution_config = config
+        if config.executor_import:
+            self.add_import(config.executor_import)
+        # we either add the executor content here or
+        # in _contribute_specific_content below
+        if config.executor_content:
+            self.append_before_agent(config.executor_content)
+
+    def set_termination_config(self, config: TerminationConfig) -> None:
+        """Set termination configuration.
+
+        Parameters
+        ----------
+        config : TerminationConfig
+            The termination configuration.
+        """
+        self.termination_config = config
+        if config.before_content:
+            self.append_before_agent(config.before_content)
+
+    def set_system_message_config(self, config: SystemMessageConfig) -> None:
+        """Set system message configuration.
+
+        Parameters
+        ----------
+        config : SystemMessageConfig
+            The system message configuration.
+        """
+        self.system_message_config = config
+        if config.before_agent_conent:
+            self.append_before_agent(config.before_agent_conent)
+
+    def get_code_execution_arg(self) -> InstanceArgument:
+        """Get the code execution argument string.
+
+        Returns
+        -------
+        InstanceArgument
+            The code execution argument.
+        """
+        if (
+            self.code_execution_config
+            and self.code_execution_config.executor_argument
+        ):
+            argunent = self.code_execution_config.executor_argument
+        else:
+            argunent = "False"
+        return InstanceArgument(
+            instance_id=self.instance_id,
+            name="code_execution_config",
+            value=argunent,
+            tabs=1,
+        )
+
+    def get_termination_arg(self) -> InstanceArgument:
+        """Get the termination argument.
+
+        Returns
+        -------
+        InstanceArgument
+            The termination argument.
+        """
+        if self.termination_config and self.termination_config.termination_arg:
+            argument = self.termination_config.termination_arg
+        else:
+            argument = "None"
+        comment: str | None = None
+        if argument == "None":
+            comment = "pyright: ignore"
+        return InstanceArgument(
+            instance_id=self.instance_id,
+            name="is_termination_msg",
+            value=argument,
+            comment=comment,
+            tabs=1,
+        )
+
+    def get_system_message_arg(self) -> InstanceArgument:
+        """Get the system message argument.
+
+        Returns
+        -------
+        InstanceArgument
+            The system message argument.
+        """
+        if (
+            self.system_message_config
+            and self.system_message_config.system_message_arg
+        ):
+            argument = self.system_message_config.system_message_arg
+        else:
+            argument = ""
+        return InstanceArgument(
+            instance_id=self.instance_id,
+            name="system_message",
+            value=argument,
+            skip_if_empty_string=True,
+            with_new_line_before=True,
+            tabs=1,
+        )
+
+    def has_specific_content(self) -> bool:
+        """Check for standard agent specific content.
+
+        Returns
+        -------
+        bool
+            True if there's standard agent specific content.
+        """
+        return bool(
+            self.extra_args
+            or (
+                self.code_execution_config
+                and self.code_execution_config.has_content()
+            )
+            or (
+                self.termination_config
+                and self.termination_config.has_content()
+            )
+            or (
+                self.system_message_config
+                and self.system_message_config.has_content()
+            )
+        )
+
+    def _contribute_specific_content(self, result: ExportResult) -> None:
+        """Contribute standard agent specific content.
+
+        Parameters
+        ----------
+        result : ExportResult
+            The export result to contribute to.
+        """
+        if self.extra_args:
+            result.add_content(
+                self.get_extra_args_content(),
+                position=ExportPosition.AGENTS,
+                agent_position=AgentPosition.AS_ARGUMENT,
+                agent_id=self.instance_id,
+            )
+        # content added above
+        # alternatively, we could add it here
+        # (but we should pay attention with the order)
+        # if (
+        #     self.code_execution_config
+        #     and self.code_execution_config.has_content()
+        # ):
+        #     result.add_content(
+        #         self.code_execution_config.executor_content,
+        #         position=ExportPosition.AGENTS,
+        #         agent_position=AgentPosition.BEFORE,
+        #         order=ContentOrder.EARLY_SETUP,
+        #         agent_id=self.instance_id,
+        #     )
+        #     if self.code_execution_config.executor_import:
+        #    \statement = self.code_execution_config.executor_import.statement
+        #         position = self.code_execution_config.executor_import.position
+        #         result.add_import(
+        #             statement=statement,
+        #             position=position,
+        #         )
+        # if self.termination_config and self.termination_config.has_content():
+        #     result.add_content(
+        #         self.termination_config.before_content,
+        #         position=ExportPosition.AGENTS,
+        #         agent_position=AgentPosition.BEFORE,
+        #         agent_id=self.instance_id,
+        #     )
+        # for extra_import in self.extra_imports:
+        #     result.add_import(
+        #         statement=extra_import.statement,
+        #         position=extra_import.position,
+        #     )

waldiez/exporting/core/extras/base.py

@@ -0,0 +1,241 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+
+"""Base extras system for all exporters."""
+
+import abc
+from dataclasses import dataclass, field
+from typing import Sequence
+
+from ..enums import AgentPosition, ContentOrder, ExportPosition, ImportPosition
+from ..protocols import ExportContributor
+from ..result import ExportResult
+from ..types import ImportStatement, InstanceArgument
+
+
+@dataclass
+class BaseExtras(ExportContributor):
+    """Base class for all exporter extras with export contribution."""
+
+    instance_id: str
+    extra_imports: list[ImportStatement] = field(
+        default_factory=list[ImportStatement]
+    )
+    before_agent: str = ""
+    after_agent: str = ""
+    after_all_agents: str = ""
+    extra_args: list[InstanceArgument] = field(
+        default_factory=list[InstanceArgument]
+    )
+
+    def get_extra_args_content(self) -> str:
+        """Get the extra arguments content.
+
+        Returns
+        -------
+        str
+            The extra arguments content.
+        """
+        return "\n".join([arg.get_content() for arg in self.extra_args]) + "\n"
+
+    def add_arg(self, arg: InstanceArgument | str, tabs: int = 0) -> None:
+        """Add an extra argument.
+
+        Parameters
+        ----------
+        arg : InstanceArgument
+            The argument to add.
+        tabs : int, optional
+            The number of tabs to indent the argument, by default 0.
+        """
+        if isinstance(arg, InstanceArgument):
+            if arg not in self.extra_args:
+                self.extra_args.append(arg)
+        elif isinstance(arg, str) and arg.strip():  # pyright: ignore
+            # If it's a string, create an InstanceArgument
+            # split by '=' (it's an argument line)
+            parts = arg.split("=", 1)
+            if len(parts) == 2:
+                name, value = parts
+                comment = ""
+                if " #" in value:
+                    value, _comment = value.split(" #", 1)
+                    comment = _comment.strip()
+                new_arg = InstanceArgument(
+                    instance_id=self.instance_id,
+                    name=name.strip(),
+                    value=value.strip(),
+                    tabs=tabs,
+                    comment=comment.strip(),
+                )
+                if new_arg not in self.extra_args:
+                    self.extra_args.append(new_arg)
+
+    def add_import(self, import_statement: ImportStatement) -> None:
+        """Add an import statement.
+
+        Parameters
+        ----------
+        import_statement : str
+            The import statement to add.
+        """
+        if import_statement and import_statement.statement.strip():
+            self.extra_imports.append(import_statement)
+
+    def add_imports(self, imports: Sequence[ImportStatement]) -> None:
+        """Add multiple import statements.
+
+        Parameters
+        ----------
+        imports : Set[str]
+            The import statements to add.
+        """
+        for imp in imports:
+            self.add_import(imp)
+
+    def prepend_before_agent(self, content: str) -> None:
+        """Prepend content to the before_agent section.
+
+        Parameters
+        ----------
+        content : str
+            The content to prepend.
+        """
+        if content and content.strip():
+            if self.before_agent:
+                self.before_agent = content.rstrip() + "\n" + self.before_agent
+            else:
+                self.before_agent = content.rstrip()
+
+    def append_before_agent(self, content: str) -> None:
+        """Append content to the before_agent section.
+
+        Parameters
+        ----------
+        content : str
+            The content to append.
+        """
+        if content and content.strip():
+            if self.before_agent:
+                self.before_agent += "\n" + content.rstrip()
+            else:
+                self.before_agent = content.rstrip()
+
+    def append_after_agent(self, content: str) -> None:
+        """Append content to the after_agent section.
+
+        Parameters
+        ----------
+        content : str
+            The content to append.
+        """
+        if content and content.strip():
+            if self.after_agent:
+                self.after_agent += "\n" + content.rstrip()
+            else:
+                self.after_agent = content.rstrip()
+
+    def append_after_all_agents(self, content: str) -> None:
+        """Append content to the after_all_agents section.
+
+        Parameters
+        ----------
+        content : str
+            The content to append.
+        """
+        if content and content.strip():
+            if self.after_all_agents:
+                self.after_all_agents += "\n" + content.rstrip()
+            else:
+                self.after_all_agents = content.rstrip()
+
+    def prepend_after_all_agents(self, content: str) -> None:
+        """Prepend content to the after_all_agents section.
+
+        Parameters
+        ----------
+        content : str
+            The content to prepend.
+        """
+        if content and content.strip():
+            if self.after_all_agents:
+                self.after_all_agents = (
+                    content.rstrip() + "\n" + self.after_all_agents
+                )
+            else:
+                self.after_all_agents = content.rstrip()
+
+    def contribute_to_export(self, result: ExportResult) -> None:
+        """Contribute this extras' content to the export result.
+
+        Parameters
+        ----------
+        result : ExportResult
+            The export result to contribute to.
+        """
+        # Add imports
+        result.add_imports(self.extra_imports, ImportPosition.THIRD_PARTY)
+
+        # Add before/after content with default positioning
+        # Subclasses can override this method for custom positioning
+        if self.before_agent:
+            result.add_content(
+                self.before_agent,
+                ExportPosition.AGENTS,
+                order=ContentOrder.PRE_CONTENT,
+            )
+
+        if self.extra_args:
+            for arg in self.extra_args:
+                result.add_content(
+                    arg.get_content(),
+                    ExportPosition.AGENTS,
+                    order=ContentOrder.MAIN_CONTENT,
+                    agent_position=AgentPosition.AS_ARGUMENT,
+                )
+
+        if self.after_agent:
+            result.add_content(
+                self.after_agent,
+                ExportPosition.AGENTS,
+                order=ContentOrder.POST_CONTENT,
+            )
+
+        # Allow subclasses to contribute additional content
+        self._contribute_specific_content(result)
+
+    def _contribute_specific_content(self, result: ExportResult) -> None:
+        """Contribute subclass-specific content.
+
+        Override in subclasses to add type-specific content.
+
+        Parameters
+        ----------
+        result : ExportResult
+            The export result to contribute to.
+        """
+
+    @abc.abstractmethod
+    def has_specific_content(self) -> bool:
+        """Check if there's subclass-specific content.
+
+        Returns
+        -------
+        bool
+            True if there's specific content for this extras type.
+        """
+
+    def has_content(self) -> bool:
+        """Check if there's any meaningful content.
+
+        Returns
+        -------
+        bool
+            True if there's any content in this extras instance.
+        """
+        return bool(
+            self.extra_imports
+            or self.before_agent.strip()
+            or self.after_agent.strip()
+            or self.has_specific_content()
+        )