waldiez 0.2.1__py3-none-any.whl → 0.3.0__py3-none-any.whl

waldiez/__init__.py

@@ -1,3 +1,5 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
 """Waldiez package."""
 
 import logging

waldiez/__main__.py

@@ -1,3 +1,5 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
 """Waldiez entrypoint when called as a module."""
 
 from .cli import app

waldiez/_version.py

@@ -1,3 +1,5 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
 """Version information for Waldiez."""
 
-__version__ = "0.2.1"
+__version__ = "0.3.0"

waldiez/cli.py

@@ -1,6 +1,8 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+# pylint: disable=missing-function-docstring,missing-param-doc,missing-raises-doc  # noqa: E501
 """Command line interface to convert or run a waldiez file."""
 
-# pylint: disable=missing-function-docstring,missing-param-doc,missing-raises-doc  # noqa: E501
 import json
 import logging
 import os
@@ -9,6 +11,7 @@ import warnings
 from pathlib import Path
 from typing import TYPE_CHECKING, Optional
 
+import anyio
 import typer
 from typing_extensions import Annotated
 
@@ -87,6 +90,10 @@ def run(
     ),
 ) -> None:
     """Run a Waldiez flow."""
+    # swarm without a user,
+    # creates a new user (this has a default code execution with docker)
+    # temp (until we handle/detect docker setup)
+    os.environ["AUTOGEN_USE_DOCKER"] = "0"
     output_path = _get_output_path(output, force)
     with file.open("r", encoding="utf-8") as _file:
         try:
@@ -96,14 +103,17 @@ def run(
             raise typer.Exit(code=1) from error
     waldiez = Waldiez.from_dict(data)
     runner = WaldiezRunner(waldiez)
-    results = runner.run(output_path=output_path)
+    if waldiez.is_async:
+        results = anyio.run(runner.a_run, output_path)
+    else:
+        results = runner.run(output_path=output_path)
     logger = _get_logger()
     if isinstance(results, list):
         logger.info("Results:")
         for result in results:
             _log_result(result, logger)
             sep = "-" * 80
-            print(f"\n{sep}\n")
+            print("\n" + f"{sep}" + "\n")
     else:
         _log_result(results, logger)
 

waldiez/cli_extras.py

@@ -1,23 +1,27 @@
-# type: ignore
-# flake8: noqa
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
 # pylint: skip-file
+# type: ignore
 # isort: skip_file
 """Extra typer commands for CLI."""
 
+from typing import Callable
+
 import typer
+from typer.models import CommandInfo
 import subprocess  # nosemgrep # nosec
 
 HAVE_STUDIO = False
 HAVE_JUPYTER = False
 try:
-    from waldiez_studio.cli import app as studio_app
+    from waldiez_studio.cli import run as studio_app
 
     HAVE_STUDIO = True
 except BaseException:
     pass
 
 try:
-    import waldiez_jupyter
+    import waldiez_jupyter  # noqa: F401
 
     HAVE_JUPYTER = True
 except BaseException:
@@ -38,18 +42,17 @@ def add_cli_extras(app: typer.Typer) -> None:
         The app with the extra commands added
     """
     if HAVE_STUDIO:
-        app.add_typer(
-            studio_app,
-            name="studio",
-            help="Start Waldiez Studio.",
-            no_args_is_help=False,
+        app.registered_commands.append(
+            CommandInfo(name="studio", callback=studio_app)
         )
     if HAVE_JUPYTER:
         jupyter_app = get_jupyter_app()
-        app.add_typer(jupyter_app, name="lab")
+        app.registered_commands.append(
+            CommandInfo(name="lab", callback=jupyter_app)
+        )
 
 
-def get_jupyter_app() -> typer.Typer:
+def get_jupyter_app() -> Callable[..., None]:
     """Get the Jupyter Typer app.
 
     Returns
@@ -58,26 +61,22 @@ def get_jupyter_app() -> typer.Typer:
         The Jupyter Typer app
     """
     jupyter_app = typer.Typer(
-        name="lab",
-        help="Start jupyter lab with the waldiez extension.",
+        add_completion=False,
+        no_args_is_help=False,
+        pretty_exceptions_enable=False,
+    )
+
+    @jupyter_app.callback(
+        name="start",
+        help="Start JupyterLab.",
         context_settings={
             "help_option_names": ["-h", "--help"],
             "allow_extra_args": True,
             "ignore_unknown_options": True,
         },
-        add_completion=False,
         no_args_is_help=False,
         invoke_without_command=True,
         add_help_option=True,
-        pretty_exceptions_enable=False,
-        epilog=(
-            "Use `waldiez lab [COMMAND] --help` for command-specific help. "
-        ),
-    )
-
-    @jupyter_app.command(
-        name="start",
-        help="Start JupyterLab.",
     )
     def start(
         port: int = typer.Option(
@@ -92,8 +91,7 @@ def get_jupyter_app() -> typer.Typer:
         ),
         browser: bool = typer.Option(
             False,
-            "--no-browser",
-            help="Don't open the browser.",
+            help="Open the browser after starting JupyterLab.",
         ),
         password: str = typer.Option(
             None,
@@ -111,7 +109,7 @@ def get_jupyter_app() -> typer.Typer:
             "--ServerApp.allow_origin='*'",
             "--ServerApp.disable_check_xsrf=True",
         ]
-        if browser:
+        if not browser:
             command.append("--no-browser")
         if password:
             from jupyter_server.auth import passwd
@@ -120,4 +118,4 @@ def get_jupyter_app() -> typer.Typer:
             command.append(f"--ServerApp.password={hashed_password}")
         subprocess.run(command)
 
-    return jupyter_app
+    return start

waldiez/conflict_checker.py

@@ -1,6 +1,7 @@
-"""Check for conflicts with 'autogen-agentchat' package."""
-
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
 # pylint: disable=line-too-long
+"""Check for conflicts with 'autogen-agentchat' package."""
 
 import sys
 from importlib.metadata import PackageNotFoundError, version
@@ -16,7 +17,7 @@ def check_conflicts() -> None:  # pragma: no cover
             "in the current environment, \n"
             "which conflicts with 'ag2' / 'pyautogen'.\n"
             "Please uninstall 'autogen-agentchat': \n"
-            f"{sys.executable} -m pip uninstall -y autogen-agentchat \n"
+            f"{sys.executable} -m pip uninstall -y autogen-agentchat" + "\n"
             "And install 'pyautogen' (and/or 'waldiez') again: \n"
             f"{sys.executable} -m pip install --force pyautogen waldiez"
         )

waldiez/exporter.py

@@ -1,5 +1,6 @@
-"""Waldiez exporter.
-
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+"""
 The role of the exporter is to export the model's data
 to an autogen's flow with one or more chats.
 
@@ -8,8 +9,8 @@ to trigger the chat(s).
 If additional tools/skills are used,
 they are exported as their `skill_name` in the same directory with
 the `flow.py` file. So the `flow.py` could have entries like:
-`form {skill1_name} import {skill1_name}`
-`form {skill2_name} import {skill2_name}`
+`form {flow_name}_{skill1_name} import {skill1_name}`
+`form {flow_name}_{skill2_name} import {skill2_name}`
 """
 
 # pylint: disable=inconsistent-quotes
@@ -19,16 +20,10 @@ import shutil
 import subprocess
 import sys
 from pathlib import Path
-from typing import Dict, List, Optional, Union
+from typing import List, Optional, Union
 
-from .exporting import comment, export_flow, get_valid_instance_name
-from .models import (
-    Waldiez,
-    WaldiezAgent,
-    WaldiezChat,
-    WaldiezModel,
-    WaldiezSkill,
-)
+from .exporting import FlowExporter
+from .models import Waldiez
 
 
 class WaldiezExporter:
@@ -38,15 +33,6 @@ class WaldiezExporter:
         waldiez (Waldiez): The Waldiez instance.
     """
 
-    _agent_names: Dict[str, str]
-    _model_names: Dict[str, str]
-    _skill_names: Dict[str, str]
-    _chat_names: Dict[str, str]
-    _chats: List[WaldiezChat]
-    _skills: List[WaldiezSkill]
-    _models: List[WaldiezModel]
-    _agents: List[WaldiezAgent]
-
     def __init__(self, waldiez: Waldiez) -> None:
         """Initialize the Waldiez exporter.
 
@@ -54,7 +40,7 @@ class WaldiezExporter:
             waldiez (Waldiez): The Waldiez instance.
         """
         self.waldiez = waldiez
-        self._initialize()
+        # self._initialize()
 
     @classmethod
     def load(cls, file_path: Path) -> "WaldiezExporter":
@@ -73,56 +59,6 @@ class WaldiezExporter:
         waldiez = Waldiez.load(file_path)
         return cls(waldiez)
 
-    def _initialize(
-        self,
-    ) -> None:
-        """Get all the names in the flow.
-
-        We need to make sure that no duplicate names are used,
-        and that the names can be used as python variables.
-        """
-        all_names: Dict[str, str] = {}
-        agent_names: Dict[str, str] = {}
-        model_names: Dict[str, str] = {}
-        skill_names: Dict[str, str] = {}
-        chat_names: Dict[str, str] = {}
-        chats: List[WaldiezChat] = []
-        skills: List[WaldiezSkill] = []
-        models: List[WaldiezModel] = []
-        agents: List[WaldiezAgent] = []
-        for agent in self.waldiez.agents:
-            all_names = get_valid_instance_name(
-                (agent.id, agent.name), all_names, prefix="wa"
-            )
-            agent_names[agent.id] = all_names[agent.id]
-            agents.append(agent)
-        for model in self.waldiez.models:
-            all_names = get_valid_instance_name(
-                (model.id, model.name), all_names, prefix="wm"
-            )
-            model_names[model.id] = all_names[model.id]
-            models.append(model)
-        for skill in self.waldiez.skills:
-            all_names = get_valid_instance_name(
-                (skill.id, skill.name), all_names, prefix="ws"
-            )
-            skill_names[skill.id] = all_names[skill.id]
-            skills.append(skill)
-        for chat in self.waldiez.flow.data.chats:
-            all_names = get_valid_instance_name(
-                (chat.id, chat.name), all_names, prefix="wc"
-            )
-            chat_names[chat.id] = all_names[chat.id]
-            chats.append(chat)
-        self._agent_names = agent_names
-        self._model_names = model_names
-        self._skill_names = skill_names
-        self._chat_names = chat_names
-        self._chats = chats
-        self._skills = skills
-        self._models = models
-        self._agents = agents
-
     def export(self, path: Union[str, Path], force: bool = False) -> None:
         """Export the Waldiez instance.
 
@@ -175,25 +111,17 @@ class WaldiezExporter:
         RuntimeError
             If the notebook could not be generated.
         """
-        content = f"{comment(True)}{self.waldiez.name}" + "\n\n"
-        content += f"{comment(True, 2)}Dependencies" + "\n\n"
-        content += "import sys\n"
-        requirements = " ".join(self.waldiez.requirements)
-        if requirements:
-            content += (
-                f"# !{{sys.executable}} -m pip install -q {requirements}" + "\n"
-            )
-        content += export_flow(
+        # we first create a .py file with the content
+        # and then convert it to a notebook using jupytext
+        exporter = FlowExporter(
             waldiez=self.waldiez,
-            agents=(self._agents, self._agent_names),
-            chats=(self._chats, self._chat_names),
-            models=(self._models, self._model_names),
-            skills=(self._skills, self._skill_names),
             output_dir=path.parent,
-            notebook=True,
+            for_notebook=True,
         )
-        # we first create a .py file with the content
-        # and then convert it to a notebook using jupytext
+        output = exporter.export()
+        content = output["content"]
+        if not content:
+            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)
@@ -226,26 +154,21 @@ class WaldiezExporter:
         ----------
         path : Path
             The path to export to.
+
+        Raises
+        ------
+        RuntimeError
+            If the python script could not be generated.
         """
-        content = "#!/usr/bin/env python\n"
-        content += f'"""{self.waldiez.name}\n\n'
-        content += f"{self.waldiez.description}\n\n"
-        content += f"Tags: {', '.join(self.waldiez.tags)}\n\n"
-        content += f"Requirements: {', '.join(self.waldiez.requirements)}\n\n"
-        content += '"""\n\n'
-        content += "# cspell: disable\n"
-        content += "# flake8: noqa\n\n"
-        content += export_flow(
+        exporter = FlowExporter(
             waldiez=self.waldiez,
-            agents=(self._agents, self._agent_names),
-            chats=(self._chats, self._chat_names),
-            models=(self._models, self._model_names),
-            skills=(self._skills, self._skill_names),
             output_dir=path.parent,
-            notebook=False,
+            for_notebook=False,
         )
-        content += '\n\nif __name__ == "__main__":\n'
-        content += "    print(main())\n"
+        output = exporter.export()
+        content = output["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)
 

waldiez/exporting/__init__.py

@@ -1,14 +1,13 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
 """Tools for exporting agents, models, skills and chats to strings."""
 
-from .flow import export_flow
-from .models import export_models
-from .skills import export_skills
-from .utils import comment, get_valid_instance_name
+from .flow import FlowExporter
+from .models import ModelsExporter
+from .skills import SkillsExporter
 
 __all__ = [
-    "export_flow",
-    "comment",
-    "get_valid_instance_name",
-    "export_models",
-    "export_skills",
+    "FlowExporter",
+    "ModelsExporter",
+    "SkillsExporter",
 ]

waldiez/exporting/agent/__init__.py

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