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

waldiez/exporting/chats/utils/{single_chat.py → single.py}

@@ -4,29 +4,30 @@
 # pylint: disable=line-too-long
 """Utilities for exporting a single chat in a flow."""
 
-from typing import Any, Callable, Dict, Optional, Tuple
+from typing import Any, Callable, Optional
 
 from waldiez.models import (
     WaldiezAgent,
     WaldiezChat,
     WaldiezChatMessage,
-    WaldiezRagUser,
+    WaldiezRagUserProxy,
 )
 
-from .common import get_chat_message_string, update_summary_chat_args
+from .common import get_chat_message_string
 
 
 def export_single_chat(
     sender: WaldiezAgent,
     recipient: WaldiezAgent,
     chat: WaldiezChat,
-    agent_names: Dict[str, str],
-    chat_names: Dict[str, str],
+    agent_names: dict[str, str],
+    chat_names: dict[str, str],
     serializer: Callable[[str], str],
-    string_escape: Callable[[str], str],
     tabs: int,
     is_async: bool,
-) -> Tuple[str, str]:
+    skip_cache: bool,
+    tab_leng: int = 4,
+) -> tuple[str, str]:
     """Get the chat string when there is only one chat in the flow.
 
     Parameters
@@ -37,22 +38,24 @@ def export_single_chat(
         The recipient.
     chat : WaldiezChat
         The chat.
-    agent_names : Dict[str, str]
+    agent_names : dict[str, str]
         A mapping of agent id to agent name.
-    chat_names : Dict[str, str]
+    chat_names : dict[str, str]
         A mapping of chat id to chat name.
     serializer : Callable[[str], str]
         The serializer function to escape quotes in a string.
-    string_escape : Callable[[str], str]
-        The string escape function.
     tabs : int
         The number of tabs to use for indentation.
     is_async : bool
         Whether the chat is asynchronous.
+    skip_cache : bool
+        Whether to skip the cache argument.
+    tab_leng : int, optional
+        The length of the tab string, by default 4.
 
     Returns
     -------
-    Tuple[str, str]
+    tuple[str, str]
         The chat string and additional methods string if any
 
     Example
@@ -91,18 +94,18 @@ def export_single_chat(
     )
     ```
     """
-    tab = "    " * tabs if tabs > 0 else ""
+    tab = " " * tab_leng * tabs if tabs > 0 else ""
     chat_args = chat.get_chat_args(for_queue=False, sender=sender)
-    chat_args = update_summary_chat_args(chat_args, string_escape)
+    # chat_args = update_summary_chat_args(chat_args, skip_summary=True)
     if not chat_args:
         return get_empty_simple_chat_string(
             chat=chat,
             sender=sender,
             recipient=recipient,
             agent_names=agent_names,
-            string_escape=string_escape,
             tab=tab,
             is_async=is_async,
+            skip_cache=skip_cache,
         )
     return get_simple_chat_string(
         chat=chat,
@@ -112,9 +115,9 @@ def export_single_chat(
         agent_names=agent_names,
         chat_names=chat_names,
         serializer=serializer,
-        string_escape=string_escape,
         tabs=tabs,
         is_async=is_async,
+        skip_cache=skip_cache,
     )
 
 
@@ -123,14 +126,14 @@ def get_simple_chat_string(
     chat: WaldiezChat,
     sender: WaldiezAgent,
     recipient: WaldiezAgent,
-    agent_names: Dict[str, str],
-    chat_names: Dict[str, str],
-    chat_args: Dict[str, Any],
+    agent_names: dict[str, str],
+    chat_names: dict[str, str],
+    chat_args: dict[str, Any],
     serializer: Callable[..., str],
-    string_escape: Callable[[str], str],
     tabs: int,
     is_async: bool,
-) -> Tuple[str, str]:
+    skip_cache: bool,
+) -> tuple[str, str]:
     """Get the chat string when there are chat arguments.
 
     Parameters
@@ -141,24 +144,24 @@ def get_simple_chat_string(
         The sender.
     recipient : WaldiezAgent
         The recipient.
-    agent_names : Dict[str, str]
+    agent_names : dict[str, str]
         A mapping of agent id to agent name.
-    chat_names : Dict[str, str]
+    chat_names : dict[str, str]
         A mapping of chat id to chat name.
-    chat_args : Dict[str, Any]
+    chat_args : dict[str, Any]
         The chat arguments.
     serializer : Callable[[str], str]
         The serializer function to escape quotes in a string.
-    string_escape : Callable[[str], str]
-        The string escape function.
     tabs : int
         The number of tabs to use for indentation.
     is_async : bool
         Whether the chat is asynchronous.
+    skip_cache : bool
+        Whether to skip the cache argument.
 
     Returns
     -------
-    Tuple[str, str]
+    tuple[str, str]
         The chat string and additional methods string if any.
     """
     tab = "    " * tabs
@@ -170,13 +173,14 @@ def get_simple_chat_string(
     recipient_name = agent_names[recipient.id]
     chat_string = "\n" + f"{tab}results = {sender_name}.{initiate}(" + "\n"
     chat_string += f"{tab}    {recipient_name},"
-    chat_string += "\n" + f"{tab}    cache=cache,"
+    if not skip_cache:
+        chat_string += "\n" + f"{tab}    cache=cache,"
     for key, value in chat_args.items():
         if isinstance(value, str):
             chat_string += "\n" + f'{tab}    {key}="{value}",'
         elif isinstance(value, dict):
             chat_string += (
-                "\n" + f"{tab}    {key}={serializer(value, tabs + 1)},"
+                "\n" + f"{tab}    {key}={serializer(value, tabs=tabs + 1)},"
             )
         else:
             chat_string += "\n" + f"{tab}    {key}={value},"
@@ -186,7 +190,6 @@ def get_simple_chat_string(
         chat_names=chat_names,
         sender=sender,
         sender_name=sender_name,
-        string_escape=string_escape,
     )
     chat_string += message_arg
     chat_string += "\n" + f"{tab})" + "\n"
@@ -197,11 +200,11 @@ def get_empty_simple_chat_string(
     chat: WaldiezChat,
     sender: WaldiezAgent,
     recipient: WaldiezAgent,
-    agent_names: Dict[str, str],
-    string_escape: Callable[[str], str],
+    agent_names: dict[str, str],
     tab: str,
     is_async: bool,
-) -> Tuple[str, str]:
+    skip_cache: bool,
+) -> tuple[str, str]:
     """Get the chat string when there are no chat arguments.
 
     Parameters
@@ -212,18 +215,18 @@ def get_empty_simple_chat_string(
         The sender.
     recipient : WaldiezAgent
         The recipient.
-    agent_names : Dict[str, str]
+    agent_names : dict[str, str]
         A mapping of agent id to agent name.
-    string_escape : Callable[[str], str]
-        The string escape function.
     tab : str
         The tab string.
     is_async : bool
         Whether the chat is asynchronous.
+    skip_cache : bool
+        Whether to skip the cache argument.
 
     Returns
     -------
-    Tuple[str, str]
+    tuple[str, str]
         The chat string and additional methods string if any
     """
     sender_name = agent_names[sender.id]
@@ -233,14 +236,14 @@ def get_empty_simple_chat_string(
     initiate = "a_initiate_chat" if is_async else "initiate_chat"
     content = "\n" + f"{tab}results = {sender_name}.{initiate}(" + "\n"
     content += f"{tab}    {recipient_name}," + "\n"
-    content += f"{tab}    cache=cache," + "\n"
+    if not skip_cache:
+        content += f"{tab}    cache=cache," + "\n"
     message_arg, _ = get_chat_message(
         tab=tab,
         chat=chat,
         chat_names={},
         sender=sender,
         sender_name=sender_name,
-        string_escape=string_escape,
     )
     content += message_arg
     content += f"{tab})" + "\n"
@@ -250,11 +253,10 @@ def get_empty_simple_chat_string(
 def get_chat_message(
     tab: str,
     chat: WaldiezChat,
-    chat_names: Dict[str, str],
+    chat_names: dict[str, str],
     sender: WaldiezAgent,
     sender_name: str,
-    string_escape: Callable[[str], str],
-) -> Tuple[str, str]:
+) -> tuple[str, str]:
     """Get the chat message string.
 
     Parameters
@@ -263,25 +265,23 @@ def get_chat_message(
         The tab string.
     chat : WaldiezChat
         The chat.
-    chat_names : Dict[str, str]
+    chat_names : dict[str, str]
         A mapping of chat id to chat name.
     sender : WaldiezAgent
         The sender.
     sender_name : str
         The sender name.
-    string_escape : Callable[[str], str]
-        The string escape function.
 
     Returns
     -------
-    Tuple[str, str]
+    tuple[str, str]
         The message argument and additional methods string if any.
     """
     additional_methods_string = ""
     method_content: Optional[str] = None
     if (
-        sender.agent_type == "rag_user"
-        and isinstance(sender, WaldiezRagUser)
+        sender.is_rag_user
+        and isinstance(sender, WaldiezRagUserProxy)
         and chat.message.type == "rag_message_generator"
         and chat.message.use_carryover is False
     ):
@@ -291,10 +291,8 @@ def get_chat_message(
         sender=sender,
         chat=chat,
         chat_names=chat_names,
-        string_escape=string_escape,
     )
     if message and isinstance(chat.data.message, WaldiezChatMessage):
-        message = string_escape(message)
         if chat.data.message.type == "method":
             additional_methods_string += (
                 method_content if method_content else ""

waldiez/exporting/core/__init__.py

@@ -0,0 +1,196 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+
+"""Core exporting infrastructure.
+
+This module provides base classes, types, result builders,
+and extras for exportign flows.
+"""
+
+# Core base class
+# Context management
+# Constants / defaults
+from .constants import (
+    DEFAULT_AGENT_POSITION,
+    DEFAULT_EXPORT_POSITION,
+    DEFAULT_IMPORT_POSITION,
+    FILE_HEADER,
+)
+
+# Content
+from .content import ContentMetadata, PositionedContent
+
+# Context management
+from .context import (
+    ExporterContext,
+    create_exporter_context,
+    get_default_exporter_context,
+)
+
+# Enums
+from .enums import (
+    AgentPosition,
+    ContentOrder,
+    ContentType,
+    ExportPosition,
+    GroupManagerStrategy,
+    ImportPosition,
+)
+
+# Errors
+from .errors import (
+    ExporterContentError,
+    ExporterError,
+    ExporterInitializationError,
+    ExporterValidationError,
+)
+from .exporter import (
+    Exporter,
+)
+from .exporters import (
+    ConfigurableExporter,
+    SimpleExporter,
+)
+
+# Agent-specific extras
+from .extras.agent_extras import (
+    CaptainExtras,
+    CodeExecutionConfig,
+    GroupManagerExtras,
+    RAGUserExtras,
+    ReasoningExtras,
+    StandardExtras,
+    SystemMessageConfig,
+    TerminationConfig,
+)
+
+# Base extras system
+from .extras.base import BaseExtras
+
+# Chat-specific extras
+from .extras.chat_extras import (
+    ChatExtras,
+)
+
+# Model-specific extras
+from .extras.model_extras import (
+    ModelExtras,
+)
+
+# Defaults
+from .extras.path_resolver import DefaultPathResolver
+from .extras.serializer import DefaultSerializer
+
+# Tool-specific extras
+from .extras.tool_extras import (
+    ToolExtras,
+)
+
+# Protocols
+from .protocols import (
+    ContentGenerator,
+    ExportContributor,
+    ExportingLogger,
+    PathResolver,
+    Serializer,
+    Validator,
+)
+
+# Export result system
+from .result import (
+    ExportResult,
+    ExportResultBuilder,
+    create_empty_result,
+    create_result_with_content,
+    merge_export_results,
+)
+from .types import (
+    EnvironmentVariable,
+    ExportConfig,
+    Extras,
+    ImportStatement,
+    InstanceArgument,
+    NoExtras,
+)
+from .utils import (
+    get_agent_llm_config_arg,
+    get_comment,
+)
+from .validation import (
+    ValidationError,
+    ValidationResult,
+)
+
+__all__ = [
+    # Core base classes
+    "Exporter",
+    "SimpleExporter",
+    "ConfigurableExporter",
+    # Protocols
+    "ContentGenerator",
+    "ExportingLogger",
+    "ExportContributor",
+    "Validator",
+    "Serializer",
+    "PathResolver",
+    # Core types and enums
+    "ImportPosition",
+    "ExportPosition",
+    "AgentPosition",
+    "ContentOrder",
+    "GroupManagerStrategy",
+    "Extras",
+    "ImportStatement",
+    "PositionedContent",
+    "EnvironmentVariable",
+    "ExportConfig",
+    "ContentType",
+    "ContentMetadata",
+    "InstanceArgument",
+    "NoExtras",
+    "ValidationError",
+    "ValidationResult",
+    # Constants
+    "FILE_HEADER",
+    "DEFAULT_IMPORT_POSITION",
+    "DEFAULT_EXPORT_POSITION",
+    "DEFAULT_AGENT_POSITION",
+    # Context management
+    "ExporterContext",
+    "get_default_exporter_context",
+    "create_exporter_context",
+    "create_exporter_context",
+    # Export result system
+    "ExportResult",
+    "ExportResultBuilder",
+    "merge_export_results",
+    "create_empty_result",
+    "create_result_with_content",
+    # Base extras
+    "BaseExtras",
+    "DefaultSerializer",
+    "DefaultPathResolver",
+    # Agent extras
+    "StandardExtras",
+    "GroupManagerExtras",
+    "CaptainExtras",
+    "CodeExecutionConfig",
+    "RAGUserExtras",
+    "ReasoningExtras",
+    "SystemMessageConfig",
+    "TerminationConfig",
+    # Model extras
+    "ModelExtras",
+    # Tool extras
+    "ToolExtras",
+    # Chat extras
+    "ChatExtras",
+    # Errors
+    "ExporterError",
+    "ExporterInitializationError",
+    "ExporterValidationError",
+    "ExporterContentError",
+    # utils
+    "get_comment",
+    "get_agent_llm_config_arg",
+]

waldiez/exporting/core/constants.py

@@ -0,0 +1,17 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+"""Constants for Waldiez exporting core."""
+
+from .enums import (
+    AgentPosition,
+    ExportPosition,
+    ImportPosition,
+)
+
+FILE_HEADER = (
+    "# SPDX-License-Identifier: Apache-2.0.\n"
+    "# Copyright (c) 2024 - 2025 Waldiez and contributors."
+)
+DEFAULT_IMPORT_POSITION = ImportPosition.THIRD_PARTY
+DEFAULT_EXPORT_POSITION = ExportPosition.AGENTS
+DEFAULT_AGENT_POSITION = AgentPosition.AFTER

waldiez/exporting/core/content.py

@@ -0,0 +1,69 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+"""Content module for Waldiez exporting core."""
+
+from dataclasses import dataclass, field
+from typing import Any, Optional
+
+from .enums import (
+    AgentPosition,
+    ContentType,
+    ExportPosition,
+)
+from .errors import ExporterContentError
+
+
+@dataclass
+class PositionedContent:
+    """Content with position and ordering metadata."""
+
+    content: str
+    position: ExportPosition
+    order: int = 0
+    agent_id: Optional[str] = None
+    agent_position: Optional[AgentPosition] = None
+    metadata: dict[str, Any] = field(default_factory=dict[str, Any])
+
+    def __post_init__(self) -> None:
+        """Validate positioned content."""
+        if not self.content.strip():
+            raise ExporterContentError("Content cannot be empty or whitespace.")
+
+    def is_agent_positioned(self) -> bool:
+        """Check if this content is positioned relative to an agent.
+
+        Returns
+        -------
+        bool
+            True if this content has an agent ID and position, otherwise False.
+        """
+        return self.agent_position is not None and self.agent_id is not None
+
+    def __lt__(self, other: "PositionedContent") -> bool:
+        """Enable sorting by position, then order, then content.
+
+        Parameters
+        ----------
+        other : PositionedContent
+            The other positioned content to compare against.
+
+        Returns
+        -------
+        bool
+            True if this positioned content should come before the other.
+        """
+        if self.position != other.position:
+            return self.position.value < other.position.value
+        if self.order != other.order:
+            return self.order < other.order
+        return self.content < other.content
+
+
+@dataclass
+class ContentMetadata:
+    """Metadata about exported content."""
+
+    content_type: ContentType
+    source_id: Optional[str] = None
+    dependencies: list[str] = field(default_factory=list[str])
+    tags: set[str] = field(default_factory=set[str])