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

waldiez/exporting/core/context.py

@@ -0,0 +1,244 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+"""Singleton context for exporters."""
+
+import threading
+from dataclasses import dataclass
+from typing import Any, Optional
+
+from waldiez.logger import WaldiezLogger
+
+from .extras.path_resolver import DefaultPathResolver
+from .extras.serializer import DefaultSerializer
+from .protocols import ExportingLogger, PathResolver, Serializer, Validator
+from .types import ExportConfig
+
+
+@dataclass
+class ExporterContext:
+    """Context object containing common exporter dependencies."""
+
+    serializer: Optional[Serializer] = None
+    path_resolver: Optional[PathResolver] = None
+    validator: Optional[Validator] = None
+    config: Optional[ExportConfig] = None
+    logger: Optional[ExportingLogger] = None
+
+    def get_serializer(self) -> Serializer:
+        """Get serializer or raise if not set.
+
+        Returns
+        -------
+        Serializer
+            The serializer instance.
+        """
+        return self.serializer or DefaultSerializer()
+
+    def get_path_resolver(self) -> PathResolver:
+        """Get path resolver or return default.
+
+        Returns
+        -------
+        PathResolver
+            The path resolver instance.
+        """
+        return self.path_resolver or DefaultPathResolver()
+
+    def get_config(
+        self,
+        name: Optional[str] = None,
+        description: Optional[str] = None,
+        requirements: Optional[list[str]] = None,
+        tags: Optional[list[str]] = None,
+        output_extension: Optional[str] = None,
+        is_async: bool = False,
+        output_directory: Optional[str] = None,
+        cache_seed: Optional[int] = None,
+    ) -> ExportConfig:
+        """Get export config or return default.
+
+        Parameters
+        ----------
+        name : Optional[str], optional
+            The name of the export, by default None
+        description : Optional[str], optional
+            A brief description of the export, by default None
+        requirements : Optional[list[str]], optional
+            A list of requirements for the export, by default None
+        tags : Optional[list[str]], optional
+            A list of tags associated with the export, by default None
+        output_extension : Optional[str], optional
+            The file extension for the output, by default None
+        is_async : bool, optional
+            Whether the export is asynchronous, by default False
+        output_directory : Optional[str], optional
+            The directory where the output will be saved, by default None
+        cache_seed : Optional[int], optional
+            The seed for caching, by default None
+
+        Returns
+        -------
+        ExportConfig
+            The export configuration.
+        """
+        kwargs: dict[str, Any] = {
+            "requirements": requirements or [],
+            "tags": tags or [],
+            "is_async": self.config.is_async if self.config else is_async,
+        }
+        if output_extension is not None:
+            kwargs["output_extension"] = output_extension
+        if output_directory is not None:
+            kwargs["output_directory"] = output_directory
+        if cache_seed is not None:
+            kwargs["cache_seed"] = cache_seed
+        if name is not None:
+            kwargs["name"] = name
+        if description is not None:
+            kwargs["description"] = description
+        if self.config is not None:
+            self.config.update(**kwargs)
+        else:
+            self.config = ExportConfig.create(**kwargs)
+        return self.config
+
+    def set_config(self, config: ExportConfig) -> None:
+        """Set the export configuration.
+
+        Parameters
+        ----------
+        config : ExportConfig
+            The export configuration to set.
+        """
+        self.config = config
+
+    def get_logger(self) -> ExportingLogger:
+        """Get logger or create a default one.
+
+        Returns
+        -------
+        ExportingLogger
+            The logger instance.
+        """
+        return self.logger or WaldiezLogger()
+
+
+# pylint: disable=too-few-public-methods
+class DefaultExporterContext(ExporterContext):
+    """Singleton context for exporters.
+
+    Provides a default configuration with standard serializer and escaper.
+    Access via get_default_exporter_context() for proper initialization.
+
+    Note
+    ----
+    This is a singleton - only one instance exists per application.
+    Direct instantiation may not behave as expected.
+    """
+
+    _instance: Optional["DefaultExporterContext"] = None
+    _lock = threading.Lock()
+
+    def __new__(cls, *args: Any, **kwargs: Any) -> "DefaultExporterContext":
+        """Create a new instance of DefaultExporterContext.
+
+        Parameters
+        ----------
+        cls : type
+            The class type for which the instance is being created.
+        *args : Any
+            Positional arguments for the constructor.
+        **kwargs : Any
+            Keyword arguments for the constructor.
+
+        Returns
+        -------
+        DefaultExporterContext
+            The singleton instance of DefaultExporterContext.
+        """
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:  # Double-check
+                    cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __init__(
+        self,
+        serializer: Optional[Serializer] = None,
+        validator: Optional[Validator] = None,
+        path_resolver: Optional[PathResolver] = None,
+        logger: Optional[ExportingLogger] = None,
+        config: Optional[ExportConfig] = None,
+    ) -> None:
+        if hasattr(self, "_initialized"):
+            return
+        super().__init__(
+            serializer=serializer or DefaultSerializer(),
+            path_resolver=path_resolver or DefaultPathResolver(),
+            logger=logger or WaldiezLogger(),
+            validator=validator,
+            config=config,
+        )
+        self._initialized = True
+
+
+def get_default_exporter_context(
+    config: Optional[ExportConfig] = None,
+    logger: Optional[ExportingLogger] = None,
+) -> ExporterContext:
+    """Get the default exporter context.
+
+    Parameters
+    ----------
+    config : Optional[ExportConfig], optional
+        The export configuration, by default None
+    logger : Optional[ExportingLogger], optional
+        The logger instance, by default None
+
+    Returns
+    -------
+    ExporterContext
+        The default exporter context.
+    """
+    return DefaultExporterContext(
+        serializer=DefaultSerializer(),
+        path_resolver=DefaultPathResolver(),
+        logger=logger or WaldiezLogger(),
+        config=config,
+    )
+
+
+def create_exporter_context(
+    serializer: Optional[Serializer] = None,
+    validator: Optional[Validator] = None,
+    path_resolver: Optional[PathResolver] = None,
+    config: Optional[ExportConfig] = None,
+    logger: Optional[ExportingLogger] = None,
+) -> ExporterContext:
+    """Create an exporter context with the given components.
+
+    Parameters
+    ----------
+    serializer : Optional[Serializer], optional
+        The serializer component, by default None
+    path_resolver : Optional[PathResolver], optional
+        The path resolver component, by default None
+    validator : Optional[Validator], optional
+        The validator component, by default None
+    config : Optional[ExportConfig], optional
+        The export configuration, by default None
+    logger : Optional[ExportingLogger], optional
+        The logger instance, by default None
+
+    Returns
+    -------
+    ExporterContext
+        The created context.
+    """
+    return ExporterContext(
+        serializer=serializer or DefaultSerializer(),
+        path_resolver=path_resolver or DefaultPathResolver(),
+        validator=validator,
+        logger=logger or WaldiezLogger(),
+        config=config,
+    )

waldiez/exporting/core/enums.py

@@ -0,0 +1,89 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+"""Enums for Waldiez exporting core."""
+
+from enum import Enum
+
+
+# Position Enums
+class ImportPosition(Enum):
+    """Position for import statements in the generated code."""
+
+    BUILTINS = 0  # Built-in imports (os, sys, etc.)
+    THIRD_PARTY = 1  # Third-party imports (autogen, openai, etc.)
+    LOCAL = 2  # Local/relative imports
+
+
+class ExportPosition(Enum):
+    """Position for content in the exported code.
+
+    Attributes
+    ----------
+    TOP : int
+        Position at the top of the file, typically for comments or metadata.
+    IMPORTS : int
+        Position for import statements.
+    TOOLS : int
+        Position for tool definitions.
+    MODELS : int
+        Position for model configurations (llm_config).
+    AGENTS : int
+        Position for agent definitions.
+    CHATS : int
+        Position for chat/connection definitions.
+    BOTTOM : int
+        Position at the bottom of the file,
+        typically for main execution or final code.
+    """
+
+    TOP = 0  # Top of file (comments, metadata)
+    IMPORTS = 1  # Import statements section
+    TOOLS = 2  # Tool definitions
+    MODELS = 3  # Model configurations (llm_config)
+    AGENTS = 4  # Agent definitions
+    CHATS = 5  # Chat/connection definitions
+    BOTTOM = 6  # Bottom of file (main execution, etc.)
+
+
+class AgentPosition(Enum):
+    """Position relative to a specific agent."""
+
+    BEFORE_ALL = 0  # Before all agents are defined
+    BEFORE = 1  # Before this specific agent
+    AS_ARGUMENT = 2  # As part of agent's initialization arguments
+    AFTER = 3  # After this specific agent
+    AFTER_ALL = 4  # After all agents are defined
+
+
+# Content Order Enums
+class ContentOrder(Enum):
+    """Standard ordering for positioned content."""
+
+    EARLY_SETUP = -100
+    SETUP = -50
+    PRE_CONTENT = -10
+    MAIN_CONTENT = 0  # Default
+    POST_CONTENT = 10
+    CLEANUP = 50
+    LATE_CLEANUP = 100
+
+
+# Content Type Markers
+class ContentType(Enum):
+    """Type of content being exported."""
+
+    AGENT_DEFINITION = 0
+    MODEL_CONFIG = 1
+    TOOL_DEFINITION = 2
+    CHAT_DEFINITION = 3
+    FLOW_SETUP = 4
+    UTILITY_FUNCTION = 5
+    IMPORT_STATEMENT = 6
+    ENVIRONMENT_SETUP = 7
+
+
+class GroupManagerStrategy(Enum):
+    """Strategy for group manager agent."""
+
+    PATTERN = "pattern"  # Use AG2 Pattern system
+    TRADITIONAL = "traditional"  # Use traditional GroupChat + GroupChatManager

waldiez/exporting/core/errors.py

@@ -0,0 +1,19 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+"""Exporter core exceptions module."""
+
+
+class ExporterError(Exception):
+    """Base exception for exporter errors."""
+
+
+class ExporterInitializationError(ExporterError):
+    """Exception raised when exporter initialization fails."""
+
+
+class ExporterValidationError(ExporterError):
+    """Exception raised when export validation fails."""
+
+
+class ExporterContentError(ExporterError):
+    """Exception raised when content generation fails."""