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

waldiez/__init__.py

@@ -5,7 +5,7 @@
 from .exporter import WaldiezExporter
 from .models import Waldiez
 from .runner import WaldiezRunner
-from .utils import check_conflicts, check_flaml_warnings, check_rpds_py
+from .utils import check_conflicts, check_flaml_warnings
 
 # flake8: noqa: F401
 # pylint: disable=import-error,line-too-long
@@ -22,13 +22,13 @@ except ImportError:  # pragma: no cover
     )
     __version__ = "dev"
 
-__WALDIEZ_INITIALIZED = False
+# pylint: disable=invalid-name
+__waldiez_initialized = False
 
-if not __WALDIEZ_INITIALIZED:
-    __WALDIEZ_INITIALIZED = True
+if not __waldiez_initialized:
+    __waldiez_initialized = True
     check_conflicts()
     check_flaml_warnings()
-    check_rpds_py()
 
 __all__ = [
     "Waldiez",

waldiez/_version.py

@@ -5,4 +5,4 @@
 This file is automatically generated by Hatchling.
 Do not edit this file directly.
 """
-__version__ = VERSION = "0.4.7"
+__version__ = VERSION = "0.4.8"

waldiez/cli.py

@@ -5,22 +5,21 @@
 """Command line interface to convert or run a waldiez file."""
 
 import json
-import logging
 import os
-import sys
 from pathlib import Path
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING, Any, Optional, Union
 
 import anyio
 import typer
+from dotenv import load_dotenv
 from typing_extensions import Annotated
 
 # pylint: disable=import-error,line-too-long
 # pyright: reportMissingImports=false
 try:  # pragma: no cover
-    from ._version import (  # type: ignore[unused-ignore, unused-import, import-not-found, import-untyped]  # noqa
-        __version__,
-    )
+    # fmt: off
+    from ._version import __version__ # type: ignore[unused-ignore, unused-import, import-not-found, import-untyped]  # noqa
+    # fmt: on
 except ImportError:  # pragma: no cover
     import warnings
 
@@ -31,6 +30,8 @@ except ImportError:  # pragma: no cover
 
 
 from .exporter import WaldiezExporter
+from .io import StructuredIOStream
+from .logger import get_logger
 from .models import Waldiez
 from .runner import WaldiezRunner
 from .utils import add_cli_extras
@@ -39,6 +40,9 @@ if TYPE_CHECKING:
     from autogen import ChatResult  # type: ignore[import-untyped]
 
 
+load_dotenv()
+LOG = get_logger()
+
 app = typer.Typer(
     name="waldiez",
     help="Handle Waldiez flows.",
@@ -52,7 +56,7 @@ app = typer.Typer(
     invoke_without_command=True,
     add_help_option=True,
     pretty_exceptions_enable=False,
-    epilog=("Use `waldiez [COMMAND] --help` for command-specific help. "),
+    epilog="Use `waldiez [COMMAND] --help` for command-specific help.",
 )
 
 
@@ -95,6 +99,22 @@ def run(
         dir_okay=False,
         resolve_path=True,
     ),
+    uploads_root: Optional[Path] = typer.Option(  # noqa: B008
+        None,
+        help=(
+            "Path to the uploads root directory. "
+            "The directory will contain "
+            "any uploaded files."
+        ),
+        dir_okay=True,
+        resolve_path=True,
+    ),
+    structured: bool = typer.Option(  # noqa: B008
+        False,
+        help=(
+            "If set, running the flow will use structured io stream instead of the default 'input/print' "
+        ),
+    ),
     force: bool = typer.Option(  # noqa: B008
         False,
         help="Override the output file if it already exists.",
@@ -110,28 +130,27 @@ def run(
         except json.decoder.JSONDecodeError as error:
             typer.echo("Invalid .waldiez file. Not a valid json?")
             raise typer.Exit(code=1) from error
-    waldiez = Waldiez.from_dict(data)
-    runner = WaldiezRunner(waldiez)
-    if waldiez.is_async:
-        results = anyio.run(runner.a_run, output_path)
-    else:
-        results = runner.run(output_path=output_path)
-    logger = _get_logger()
+    results = _do_run(
+        data,
+        structured=structured,
+        uploads_root=uploads_root,
+        output_path=output_path,
+    )
     if isinstance(results, list):
-        logger.info("Results:")
+        LOG.info("Results:")
         for result in results:
-            _log_result(result, logger)
+            _log_result(result)
             sep = "-" * 80
             print("\n" + f"{sep}" + "\n")
     elif isinstance(results, dict):
-        logger.info("Results:")
+        LOG.info("Results:")
         for key, result in results.items():
-            logger.info("Order: %s", key)
-            _log_result(result, logger)
+            LOG.info("Order: %s", key)
+            _log_result(result)
             sep = "-" * 80
             print("\n" + f"{sep}" + "\n")
     else:
-        _log_result(results, logger)
+        _log_result(results)
 
 
 @app.command()
@@ -148,24 +167,31 @@ def convert(
             resolve_path=True,
         ),
     ],
-    output: Annotated[
-        Path,
-        typer.Option(
-            ...,
-            help=(
-                "Path to the output file. "
-                "The file extension determines the output format: "
-                "`.py` for Python script, `.ipynb` for Jupyter notebook."
-            ),
-            file_okay=True,
-            dir_okay=False,
-            resolve_path=True,
+    output: Path | None = typer.Option(  # noqa: B008
+        default=None,
+        help=(
+            "Path to the output file. "
+            "The file extension determines the output format: "
+            "`.py` for Python script, `.ipynb` for Jupyter notebook."
+            " If not provided, the output will be saved in the same directory as the input file."
+            " If the file already exists, it will not be overwritten unless --force is used."
         ),
-    ],
+        file_okay=True,
+        dir_okay=False,
+        resolve_path=True,
+    ),
     force: bool = typer.Option(
         False,
         help="Override the output file if it already exists.",
     ),
+    debug: bool = typer.Option(
+        False,
+        "--debug",
+        "-d",
+        help="Enable debug logging.",
+        is_eager=True,
+        rich_help_panel="Debug",
+    ),
 ) -> None:
     """Convert a Waldiez flow to a Python script or a Jupyter notebook."""
     _get_output_path(output, force)
@@ -177,7 +203,11 @@ def convert(
             raise typer.Exit(code=1) from error
     waldiez = Waldiez.from_dict(data)
     exporter = WaldiezExporter(waldiez)
-    exporter.export(output, force=force)
+    if debug:
+        LOG.set_level("DEBUG")
+    if output is None:
+        output = Path(file).with_suffix(".py").resolve()
+    exporter.export(output, force=force, debug=debug)
     generated = str(output).replace(os.getcwd(), ".")
     typer.echo(f"Generated: {generated}")
 
@@ -201,7 +231,46 @@ def check(
     with file.open("r", encoding="utf-8") as _file:
         data = json.load(_file)
     Waldiez.from_dict(data)
-    typer.echo("Waldiez flow is valid.")
+    LOG.success("Waldiez flow seems valid.")
+
+
+def _do_run(
+    data: dict[str, Any],
+    structured: bool,
+    uploads_root: Optional[Path],
+    output_path: Optional[Path],
+) -> Union["ChatResult", list["ChatResult"], dict[int, "ChatResult"]]:
+    """Run the Waldiez flow and get the results."""
+    waldiez = Waldiez.from_dict(data)
+    if structured:
+        stream = StructuredIOStream(uploads_root=uploads_root)
+        with StructuredIOStream.set_default(stream):
+            runner = WaldiezRunner(waldiez)
+            if waldiez.is_async:
+                results = anyio.run(
+                    runner.a_run,
+                    output_path,
+                    uploads_root,
+                )
+            else:
+                results = runner.run(
+                    output_path=output_path,
+                    uploads_root=uploads_root,
+                )
+    else:
+        runner = WaldiezRunner(waldiez)
+        if waldiez.is_async:
+            results = anyio.run(
+                runner.a_run,
+                output_path,
+                uploads_root,
+            )
+        else:
+            results = runner.run(
+                output_path=output_path,
+                uploads_root=uploads_root,
+            )
+    return results
 
 
 def _get_output_path(output: Optional[Path], force: bool) -> Optional[Path]:
@@ -211,53 +280,23 @@ def _get_output_path(output: Optional[Path], force: bool) -> Optional[Path]:
         output.parent.mkdir(parents=True)
     if output is not None and output.exists():
         if force is False:
-            typer.echo("Output file already exists.")
+            LOG.error("Output file already exists.")
             raise typer.Exit(code=1)
         output.unlink()
     return output
 
 
-def _get_logger(level: int = logging.INFO) -> logging.Logger:
-    """Get the logger for the Waldiez package.
-
-    Parameters
-    ----------
-    level : int or str, optional
-        The logging level. Default is logging.INFO.
-
-    Returns
-    -------
-    logging.Logger
-        The logger.
-    """
-    # check if we already have setup a config
-
-    if not logging.getLogger().handlers:
-        logging.basicConfig(
-            level=level,
-            format="%(levelname)s %(message)s",
-            stream=sys.stderr,
-            force=True,
-        )
-    logger = logging.getLogger("waldiez::cli")
-    current_level = logger.getEffectiveLevel()
-    if current_level != level:
-        logger.setLevel(level)
-    return logger
-
-
-def _log_result(result: "ChatResult", logger: logging.Logger) -> None:
+def _log_result(result: "ChatResult") -> None:
     """Log the result of the Waldiez flow."""
-    logger.info("Chat History:\n")
-    logger.info(result.chat_history)
-    logger.info("Summary:\n")
-    logger.info(result.summary)
-    logger.info("Cost:\n")
-    logger.info(result.cost)
+    LOG.info("Chat History:\n")
+    LOG.info(result.chat_history)
+    LOG.info("Summary:\n")
+    LOG.info(result.summary)
+    LOG.info("Cost:\n")
+    LOG.info(result.cost)
 
 
 add_cli_extras(app)
 
 if __name__ == "__main__":
-    _get_logger()
     app()

waldiez/exporter.py

@@ -14,8 +14,11 @@ from pathlib import Path
 from typing import Union
 
 import jupytext  # type: ignore[import-untyped]
+from jupytext.config import (  # type: ignore[import-untyped]
+    JupytextConfiguration,
+)
 
-from .exporting import FlowExporter
+from .exporting import FlowExtras, create_flow_exporter
 from .models import Waldiez
 
 
@@ -27,6 +30,8 @@ class WaldiezExporter:
         waldiez (Waldiez): The Waldiez instance.
     """
 
+    flow_extras: FlowExtras
+
     def __init__(self, waldiez: Waldiez) -> None:
         """Initialize the Waldiez exporter.
 
@@ -54,20 +59,27 @@ class WaldiezExporter:
         waldiez = Waldiez.load(file_path)
         return cls(waldiez)
 
-    def export(self, path: Union[str, Path], force: bool = False) -> None:
+    def export(
+        self,
+        path: Union[str, Path],
+        force: bool = False,
+        debug: bool = False,
+    ) -> None:
         """Export the Waldiez instance.
 
         Parameters
         ----------
         path : Union[str, Path]
             The path to export to.
-        force : bool, optional
+        force : bool, (optional)
             Override the output file if it already exists, by default False.
+        debug : bool, (optional)
+            Whether to enable debug mode, by default False.
 
         Raises
         ------
         FileExistsError
-            If the file already exists and force is False.
+            If the file already exists, and force is False.
         IsADirectoryError
             If the output is a directory.
         ValueError
@@ -85,21 +97,27 @@ class WaldiezExporter:
         path.parent.mkdir(parents=True, exist_ok=True)
         extension = path.suffix
         if extension == ".waldiez":
-            self.to_waldiez(path)
+            self.to_waldiez(path, debug=debug)
         elif extension == ".py":
-            self.to_py(path)
+            self.to_py(path, debug=debug)
         elif extension == ".ipynb":
-            self.to_ipynb(path)
+            self.to_ipynb(path, debug=debug)
         else:
             raise ValueError(f"Invalid extension: {extension}")
 
-    def to_ipynb(self, path: Path) -> None:
+    def to_ipynb(
+        self,
+        path: Path,
+        debug: bool = False,
+    ) -> None:
         """Export flow to jupyter notebook.
 
         Parameters
         ----------
         path : Path
             The path to export to.
+        debug : bool, optional
+            Whether to enable debug mode, by default False.
 
         Raises
         ------
@@ -108,57 +126,81 @@ class WaldiezExporter:
         """
         # we first create a .py file with the content
         # and then convert it to a notebook using jupytext
-        exporter = FlowExporter(
+        exporter = create_flow_exporter(
             waldiez=self.waldiez,
             output_dir=path.parent,
             for_notebook=True,
+            debug=debug,
         )
+        self.flow_extras = exporter.extras
         output = exporter.export()
-        content = output["content"]
-        if not content:
+        content_str = output.main_content
+        if not content_str:
             raise RuntimeError("Could not generate notebook")
         py_path = path.with_suffix(".tmp.py")
         with open(py_path, "w", encoding="utf-8", newline="\n") as f:
-            f.write(content)
+            f.write(content_str)
+        config = JupytextConfiguration(
+            comment_magics=False,
+            hide_notebook_metadata=True,
+            cell_metadata_filter="-all",
+        )
         with open(py_path, "r", encoding="utf-8") as py_out:
-            content = jupytext.read(py_out, fmt="py:light")
+            jp_content = jupytext.read(  # pyright: ignore
+                py_out,
+                fmt="py:percent",
+                config=config,
+            )
         ipynb_path = str(py_path).replace(".tmp.py", ".tmp.ipynb")
-        jupytext.write(content, ipynb_path, fmt="ipynb")
+        jupytext.write(  # pyright: ignore
+            jp_content,
+            ipynb_path,
+            fmt="ipynb",
+            config=config,
+        )
         Path(ipynb_path).rename(ipynb_path.replace(".tmp.ipynb", ".ipynb"))
         py_path.unlink(missing_ok=True)
 
-    def to_py(self, path: Path) -> None:
-        """Export waldiez flow to python script.
+    def to_py(self, path: Path, debug: bool = False) -> None:
+        """Export waldiez flow to a python script.
 
         Parameters
         ----------
         path : Path
             The path to export to.
+        debug : bool, optional
+            Whether to enable debug mode, by default False.
 
         Raises
         ------
         RuntimeError
             If the python script could not be generated.
         """
-        exporter = FlowExporter(
+        exporter = create_flow_exporter(
             waldiez=self.waldiez,
             output_dir=path.parent,
             for_notebook=False,
+            debug=debug,
         )
+        self.flow_extras = exporter.extras
         output = exporter.export()
-        content = output["content"]
+        content = output.main_content
         if not content:
             raise RuntimeError("Could not generate python script")
         with open(path, "w", encoding="utf-8", newline="\n") as file:
             file.write(content)
 
-    def to_waldiez(self, file_path: Path) -> None:
+    def to_waldiez(self, file_path: Path, debug: bool = False) -> None:
         """Export the Waldiez instance.
 
         Parameters
         ----------
         file_path : Path
             The file path.
+        debug : bool, optional
+            Whether to enable debug mode, by default False.
         """
         with open(file_path, "w", encoding="utf-8", newline="\n") as file:
             file.write(self.waldiez.model_dump_json())
+        if debug:
+            print(self.waldiez.model_dump_json(indent=2))

waldiez/exporting/__init__.py

@@ -1,15 +1,34 @@
 # SPDX-License-Identifier: Apache-2.0.
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
-"""Tools for exporting agents, models, skills and chats to strings."""
+"""Tools for exporting agents, models, tools and chats to strings."""
 
-from .agent import AgentExporter
-from .flow import FlowExporter
-from .models import ModelsExporter
-from .skills import SkillsExporter
+from .agent import AgentExporter, create_agent_exporter
+from .chats import ChatsExporter, create_chats_exporter
+from .core.errors import (
+    ExporterContentError,
+    ExporterError,
+    ExporterInitializationError,
+    ExporterValidationError,
+)
+from .core.extras.flow_extras import FlowExtras
+from .flow import FlowExporter, create_flow_exporter
+from .models import ModelsExporter, create_models_exporter
+from .tools import ToolsExporter, create_tools_exporter
 
 __all__ = [
     "AgentExporter",
+    "ChatsExporter",
+    "FlowExtras",
     "FlowExporter",
     "ModelsExporter",
-    "SkillsExporter",
+    "ToolsExporter",
+    "ExporterContentError",
+    "ExporterError",
+    "ExporterInitializationError",
+    "ExporterValidationError",
+    "create_agent_exporter",
+    "create_chats_exporter",
+    "create_flow_exporter",
+    "create_models_exporter",
+    "create_tools_exporter",
 ]

waldiez/exporting/agent/__init__.py

@@ -1,7 +1,11 @@
 # SPDX-License-Identifier: Apache-2.0.
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
-"""Agents exporter."""
+"""Agent exporter."""
 
-from .agent_exporter import AgentExporter
+from .exporter import AgentExporter
+from .factory import create_agent_exporter
 
-__all__ = ["AgentExporter"]
+__all__ = [
+    "AgentExporter",
+    "create_agent_exporter",
+]

waldiez/exporting/agent/code_execution.py

@@ -0,0 +1,114 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+# pylint: disable=too-few-public-methods,no-self-use
+"""Code execution processor for Waldiez agents."""
+
+import json
+
+from waldiez.models import WaldiezAgent, WaldiezAgentCodeExecutionConfig
+
+from ..core import CodeExecutionConfig, ImportPosition, ImportStatement
+
+
+class CodeExecutionProcessor:
+    """Processor for code execution configuration."""
+
+    def __init__(
+        self,
+        agent: WaldiezAgent,
+        agent_name: str,
+        tool_names: dict[str, str],
+    ):
+        self.agent = agent
+        self.agent_name = agent_name
+        self.tool_names = tool_names
+
+    def process(self) -> CodeExecutionConfig:
+        """Process code execution configuration.
+
+        Returns
+        -------
+        CodeExecutionConfig
+            The processed code execution configuration.
+        """
+        if self.agent.data.code_execution_config is False:
+            return CodeExecutionConfig(
+                executor_content="",
+                executor_argument="False",
+                executor_import=None,
+            )
+
+        config = self.agent.data.code_execution_config
+        use_docker = (
+            config.use_docker if config.use_docker is not None else False
+        )
+
+        executor_class = self._get_executor_class_name(use_docker)
+        executor_content = self._build_executor_content(config, use_docker)
+        executor_arg = f'{{"executor": {self.agent_name}_executor}}'
+        executor_import = f"from autogen.coding import {executor_class}"
+
+        return CodeExecutionConfig(
+            executor_content=executor_content,
+            executor_argument=executor_arg,
+            executor_import=ImportStatement(
+                statement=executor_import,
+                position=ImportPosition.THIRD_PARTY,
+            ),
+        )
+
+    def _get_executor_class_name(self, use_docker: bool) -> str:
+        """Get the appropriate executor class name."""
+        return (
+            "DockerCommandLineCodeExecutor"
+            if use_docker
+            else "LocalCommandLineCodeExecutor"
+        )
+
+    def _build_executor_content(
+        self, config: WaldiezAgentCodeExecutionConfig, use_docker: bool
+    ) -> str:
+        """Build the executor content string."""
+        executor_class = self._get_executor_class_name(use_docker)
+        lines = [f"{self.agent_name}_executor = {executor_class}("]
+
+        # Add work directory
+        if config.work_dir:
+            lines.append(f"    work_dir={json.dumps(config.work_dir)},")
+
+        # Add timeout
+        if config.timeout:
+            lines.append(f"    timeout={int(config.timeout)},")
+
+        # Add functions (only for local executor)
+        if not use_docker and config.functions:
+            function_names = self._get_function_names(config.functions)
+            if function_names:
+                function_names_str = ", ".join(function_names)
+                lines.append(f"    functions=[{function_names_str}],")
+
+        lines.append(")")
+        lines.append("")  # Add empty line
+
+        return "\n".join(lines)
+
+    def _get_function_names(self, function_ids: list[str]) -> list[str]:
+        """Get function names from function IDs.
+
+        Parameters
+        ----------
+        function_ids : list[str]
+            List of function IDs to resolve names for.
+
+        Returns
+        -------
+        list[str]
+            List of function names corresponding to the provided IDs.
+        """
+        function_names: list[str] = []
+        for tool_id in function_ids:
+            if tool_id in self.tool_names:
+                tool_name = self.tool_names[tool_id]
+                if tool_name:
+                    function_names.append(tool_name)
+        return function_names