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

waldiez/exporting/tools/factory.py

@@ -0,0 +1,57 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+"""Factory function for creating a ToolsExporter instance."""
+
+from pathlib import Path
+from typing import Optional, Union
+
+from waldiez.models import WaldiezAgent, WaldiezTool
+
+from ..core import ExporterContext, get_default_exporter_context
+from .exporter import ToolsExporter
+
+
+def create_tools_exporter(
+    flow_name: str,
+    agents: list[WaldiezAgent],
+    agent_names: dict[str, str],
+    tools: list[WaldiezTool],
+    tool_names: dict[str, str],
+    output_dir: Optional[Union[str, Path]] = None,
+    context: Optional[ExporterContext] = None,
+) -> ToolsExporter:
+    """Create a tools exporter.
+
+    Parameters
+    ----------
+    flow_name : str
+        The name of the flow.
+    agents : list[WaldiezAgent]
+        The agents that use tools.
+    agent_names : dict[str, str]
+        Mapping of agent IDs to names.
+    tools : list[WaldiezTool]
+        The tools to export.
+    tool_names : dict[str, str]
+        Mapping of tool IDs to names.
+    output_dir : Optional[Union[str, Path]], optional
+        Output directory for generated files, by default None
+    context : Optional[ExporterContext], optional
+        Exporter context with dependencies, by default None
+
+    Returns
+    -------
+    ToolsExporter
+        The created tools exporter.
+    """
+    if context is None:
+        context = get_default_exporter_context()
+    return ToolsExporter(
+        flow_name=flow_name,
+        agents=agents,
+        agent_names=agent_names,
+        tools=tools,
+        tool_names=tool_names,
+        output_dir=output_dir,
+        context=context,
+    )

waldiez/exporting/tools/processor.py

@@ -0,0 +1,248 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+# pylint: disable=too-few-public-methods
+"""Tool related utilities and processors."""
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+from waldiez.models import WaldiezTool
+
+from ..core.constants import FILE_HEADER
+from ..core.errors import ExporterContentError
+from ..core.types import EnvironmentVariable
+
+
+@dataclass
+class ToolProcessingResult:
+    """Result from processing tools."""
+
+    content: str = ""
+    builtin_imports: list[str] = field(default_factory=list[str])
+    third_party_imports: list[str] = field(default_factory=list[str])
+    environment_variables: list[EnvironmentVariable] = field(
+        default_factory=list[EnvironmentVariable]
+    )
+
+
+class ToolProcessor:
+    """Processor for tool content generation."""
+
+    def __init__(
+        self,
+        flow_name: str,
+        tools: list[WaldiezTool],
+        tool_names: dict[str, str],
+        output_dir: Optional[Path] = None,
+    ):
+        """Initialize the tool processor.
+
+        Parameters
+        ----------
+        flow_name : str
+            The name of the flow.
+        tools : list[WaldiezTool]
+            The tools to process.
+        tool_names : dict[str, str]
+            Mapping of tool IDs to names.
+        output_dir : Optional[Path], optional
+            Output directory for generated files, by default None
+        """
+        self.flow_name = flow_name
+        self.tools = tools
+        self.tool_names = tool_names
+        self.output_dir = output_dir
+
+    def process(self) -> ToolProcessingResult:
+        """Process all tools and return consolidated result.
+
+        Returns
+        -------
+        ToolProcessingResult
+            The processed result containing tool content,
+            imports, and environment variables.
+        """
+        result = ToolProcessingResult()
+
+        # Separate shared and regular tools
+        shared_tools = [tool for tool in self.tools if tool.is_shared]
+        regular_tools = [tool for tool in self.tools if not tool.is_shared]
+
+        # Process shared tools first (they need to be available to other tools)
+        for tool in shared_tools:
+            self._process_single_tool(tool, result)
+
+        # Then regular tools
+        for tool in regular_tools:
+            self._process_single_tool(tool, result)
+
+        # Clean up and finalize result
+        self._finalize_result(result)
+
+        return result
+
+    def _process_single_tool(
+        self, tool: WaldiezTool, result: ToolProcessingResult
+    ) -> None:
+        """Process a single tool and add to result.
+
+        Parameters
+        ----------
+        tool : WaldiezTool
+            The tool to process.
+        result : ToolProcessingResult
+            The result to add processed content to.
+        """
+        # Get tool content
+        tool_content = tool.get_content()
+        if tool_content:  # pragma: no branch
+            # Add interop conversion if needed
+            if tool.is_interop:
+                tool_content += self._get_interop_conversion(tool)
+
+            result.content += tool_content + "\n\n"
+
+        # Get imports
+        builtin_imports, third_party_imports = tool.get_imports()
+        if builtin_imports:
+            result.builtin_imports.extend(builtin_imports)
+        if third_party_imports:
+            result.third_party_imports.extend(third_party_imports)
+
+        # Handle secrets
+        if tool.secrets:
+            self._process_tool_secrets(tool, result)
+
+    def _get_interop_conversion(self, tool: WaldiezTool) -> str:
+        """Get interop conversion code for a tool.
+
+        Parameters
+        ----------
+        tool : WaldiezTool
+            The tool that needs interop conversion.
+
+        Returns
+        -------
+        str
+            The interop conversion code.
+        """
+        tool_name = self.tool_names[tool.id]
+        return f"""
+ag2_{tool_name}_interop = Interoperability()
+ag2_{tool_name} = ag2_{tool_name}_interop.convert_tool(
+    tool={tool_name},
+    type="{tool.tool_type}"
+)"""
+
+    def _process_tool_secrets(
+        self, tool: WaldiezTool, result: ToolProcessingResult
+    ) -> None:
+        """Process tool secrets and add to result.
+
+        Parameters
+        ----------
+        tool : WaldiezTool
+            The tool with secrets.
+        result : ToolProcessingResult
+            The result to add secrets to.
+        """
+        tool_name = self.tool_names[tool.id]
+
+        # Add to environment variables
+        for key, value in tool.secrets.items():
+            result.environment_variables.append(
+                EnvironmentVariable(
+                    name=key,
+                    value=value,
+                    description=f"Secret for tool '{tool_name}'",
+                )
+            )
+
+        # Write secrets file if output directory provided
+        if self.output_dir:
+            self._write_secrets_file(tool, tool_name)
+
+    def _write_secrets_file(self, tool: WaldiezTool, tool_name: str) -> None:
+        """Write tool secrets to a Python file.
+
+        Parameters
+        ----------
+        tool : WaldiezTool
+            The tool with secrets.
+        tool_name : str
+            The name of the tool.
+        """
+        if not self.output_dir or not tool.secrets:  # pragma: no cover
+            return
+
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+        secrets_file = (
+            self.output_dir / f"{self.flow_name}_{tool_name}_secrets.py"
+        )
+        # pylint: disable=too-many-try-statements
+        try:
+            with secrets_file.open("w", encoding="utf-8", newline="\n") as f:
+                f.write(
+                    f'''{FILE_HEADER}
+# flake8: noqa: E501
+# pylint: disable=line-too-long
+"""Secrets for the tool: {tool_name}."""
+
+'''
+                )
+                f.write("import os\n\n")
+                for key, value in tool.secrets.items():
+                    f.write(f'os.environ["{key}"] = "{value}"\n')
+        except Exception as exc:  # pragma: no cover
+            raise ExporterContentError(
+                f"Failed to write secrets file for tool '{tool_name}': {exc}"
+            ) from exc
+
+    def _finalize_result(self, result: ToolProcessingResult) -> None:
+        """Finalize the processing result.
+
+        Parameters
+        ----------
+        result : ToolProcessingResult
+            The result to finalize.
+        """
+        # Clean up content - remove excessive newlines
+        result.content = result.content.replace("\n\n\n", "\n\n").strip()
+
+        # Sort and deduplicate imports
+        result.builtin_imports = self._sort_imports(result.builtin_imports)
+        result.third_party_imports = self._sort_imports(
+            result.third_party_imports
+        )
+
+    # pylint: disable=no-self-use
+    def _sort_imports(self, imports: list[str]) -> list[str]:
+        """Sort imports: 'import' statements first, then 'from' statements.
+
+        Parameters
+        ----------
+        imports : list[str]
+            The import statements to sort.
+
+        Returns
+        -------
+        list[str]
+            The sorted import statements.
+        """
+        if not imports:
+            return []
+
+        # Remove duplicates
+        unique_imports = list(set(imports))
+
+        # Separate import types
+        import_statements = [
+            imp for imp in unique_imports if imp.startswith("import ")
+        ]
+        from_statements = [
+            imp for imp in unique_imports if imp.startswith("from ")
+        ]
+
+        # Sort each type
+        return sorted(import_statements) + sorted(from_statements)

waldiez/exporting/tools/registration.py

@@ -0,0 +1,133 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+# pylint: disable=too-few-public-methods
+"""Tool registration processor."""
+
+import json
+
+from waldiez.models import WaldiezAgent, WaldiezTool
+
+
+class ToolRegistrationProcessor:
+    """Processor for tool registration code."""
+
+    def __init__(
+        self,
+        agents: list[WaldiezAgent],
+        agent_names: dict[str, str],
+        tools: list[WaldiezTool],
+        tool_names: dict[str, str],
+    ):
+        """Initialize the tool registration processor.
+
+        Parameters
+        ----------
+        agents : list[WaldiezAgent]
+            The agents that use tools.
+        agent_names : dict[str, str]
+            Mapping of agent IDs to names.
+        tools : list[WaldiezTool]
+            The available tools.
+        tool_names : dict[str, str]
+            Mapping of tool IDs to names.
+        """
+        self.agents = agents
+        self.agent_names = agent_names
+        self.tools = tools
+        self.tool_names = tool_names
+
+    def process(self) -> str:
+        """Process tool registrations for all agents.
+
+        Returns
+        -------
+        str
+            The generated tool registration code for all agents.
+        """
+        registrations: list[str] = []
+
+        for agent in self.agents:
+            agent_registration = self._process_agent_registrations(agent)
+            if agent_registration:
+                registrations.append(agent_registration)
+
+        return "\n\n".join(registrations) if registrations else ""
+
+    def _process_agent_registrations(self, agent: WaldiezAgent) -> str:
+        """Process tool registrations for a single agent.
+
+        Parameters
+        ----------
+        agent : WaldiezAgent
+            The agent to process tool registrations for.
+
+        Returns
+        -------
+        str
+            The tool registration code for this agent.
+        """
+        if not agent.data.tools or agent.is_group_member:
+            # if group member, it's a handoff
+            return ""
+
+        registrations: list[str] = []
+        agent_name = self.agent_names[agent.id]
+
+        for tool_link in agent.data.tools:
+            # Find the actual tool
+            tool = next((t for t in self.tools if t.id == tool_link.id), None)
+            if not tool:  # pragma: no cover
+                continue
+
+            tool_name = self.tool_names[tool_link.id]
+
+            # Use converted name for interop tools
+            if tool.is_interop:
+                tool_name = f"ag2_{tool_name}"
+
+            executor_name = self.agent_names[tool_link.executor_id]
+            description = tool.description or f"Description of {tool_name}"
+
+            registration = self._create_registration(
+                caller_name=agent_name,
+                executor_name=executor_name,
+                tool_name=tool_name,
+                description=description,
+            )
+            registrations.append(registration)
+
+        return "\n".join(registrations) if registrations else ""
+
+    # pylint: disable=no-self-use
+    def _create_registration(
+        self,
+        caller_name: str,
+        executor_name: str,
+        tool_name: str,
+        description: str,
+    ) -> str:
+        """Create a single tool registration statement.
+
+        Parameters
+        ----------
+        caller_name : str
+            The name of the agent calling the tool.
+        executor_name : str
+            The name of the agent executing the tool.
+        tool_name : str
+            The name of the tool.
+        description : str
+            The description of the tool.
+
+        Returns
+        -------
+        str
+            The tool registration code.
+        """
+        return f"""register_function(
+    {tool_name},
+    caller={caller_name},
+    executor={executor_name},
+    name="{tool_name}",
+    description={json.dumps(description)},
+)"""

waldiez/io/__init__.py

@@ -0,0 +1,128 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+
+# flake8: noqa: F401
+# pylint: disable=unused-import,too-few-public-methods
+
+"""IOSTream extensions.
+
+Let's keep the redis and websockets imports optional,
+and have them in the optional requirements in the package.
+"""
+
+from typing import Any
+
+from .models import (
+    AudioContent,
+    AudioMediaContent,
+    FileContent,
+    FileMediaContent,
+    ImageContent,
+    ImageMediaContent,
+    ImageUrlMediaContent,
+    MediaContent,
+    PrintMessage,
+    TextMediaContent,
+    UserInputData,
+    UserInputRequest,
+    UserResponse,
+    VideoContent,
+    VideoMediaContent,
+)
+from .structured import StructuredIOStream
+from .utils import MediaType, MessageType
+
+try:
+    from .redis import RedisIOStream  # type: ignore[no-redef,unused-ignore]
+except ImportError:  # pragma: no cover
+
+    class RedisIOStream:  # type: ignore[no-redef,unused-ignore]
+        """Dummy class for RedisIOStream."""
+
+        def __init__(self, *args: Any, **kwargs: Any) -> None:
+            """Initialize the RedisIOStream.
+
+            Parameters
+            ----------
+            args : tuple
+                Positional arguments.
+            kwargs : dict
+                Keyword arguments.
+            """
+            raise ImportError(
+                "RedisIOStream is not available. "
+                "Please install the required package."
+            )
+
+
+try:
+    from .ws import (
+        AsyncWebsocketsIOStream,  # type: ignore[no-redef,unused-ignore]
+    )
+except ImportError:  # pragma: no cover
+
+    class AsyncWebsocketsIOStream:  # type: ignore[no-redef,unused-ignore]
+        """Dummy class for AsyncWebsocketsIOStream just for the linters."""
+
+        def __init__(self, *args: Any, **kwargs: Any) -> None:
+            """Initialize the AsyncWebsocketsIOStream.
+
+            Parameters
+            ----------
+            args : tuple
+                Positional arguments.
+            kwargs : dict
+                Keyword arguments.
+            """
+            raise ImportError(
+                "AsyncWebsocketsIOStream is not available. "
+                "Please install the required package."
+            )
+
+
+try:
+    from .mqtt import MqttIOStream  # type: ignore[no-redef,unused-ignore]
+except ImportError:  # pragma: no cover
+
+    class MqttIOStream:  # type: ignore[no-redef,unused-ignore]
+        """Dummy class for MqttIOStream."""
+
+        def __init__(self, *args: Any, **kwargs: Any) -> None:
+            """Initialize the MqttIOStream.
+
+            Parameters
+            ----------
+            args : tuple
+                Positional arguments.
+            kwargs : dict
+                Keyword arguments.
+            """
+            raise ImportError(
+                "MqttIOStream is not available. "
+                "Please install the required package."
+            )
+
+
+__all__ = [
+    "AsyncWebsocketsIOStream",
+    "StructuredIOStream",
+    "RedisIOStream",
+    "MqttIOStream",
+    "UserInputData",
+    "UserResponse",
+    "UserInputRequest",
+    "PrintMessage",
+    "MessageType",
+    "MediaType",
+    "MediaContent",
+    "TextMediaContent",
+    "ImageMediaContent",
+    "ImageUrlMediaContent",
+    "ImageContent",
+    "FileMediaContent",
+    "FileContent",
+    "AudioMediaContent",
+    "AudioContent",
+    "VideoMediaContent",
+    "VideoContent",
+]