waldiez 0.5.8__py3-none-any.whl → 0.5.10__py3-none-any.whl

waldiez/models/tool/tool.py

@@ -215,24 +215,39 @@ class WaldiezTool(WaldiezBase):
         """Get the secrets (environment variables) of the tool."""
         return self.data.secrets or {}
 
-    def get_content(self) -> str:
+    def get_content(self, runtime_kwargs: dict[str, Any] | None = None) -> str:
         """Get the content of the tool.
 
+        Parameters
+        ----------
+        runtime_kwargs : dict[str, Any] | None, optional
+            Runtime keyword arguments to customize the content generation.
+
         Returns
         -------
         str
             The content of the tool.
         """
         if self.is_predefined:
-            return self._generate_predefined_content()
+            return self._generate_predefined_content(
+                runtime_kwargs=runtime_kwargs
+            )
         if self.is_shared or self.is_interop:
             return self.data.content
         # if custom, only the function content
         return get_function(self.data.content, self.name)
 
-    def _generate_predefined_content(self) -> str:
+    def _generate_predefined_content(
+        self,
+        runtime_kwargs: dict[str, Any] | None = None,
+    ) -> str:
         """Generate the content for a predefined tool.
 
+        Parameters
+        ----------
+        runtime_kwargs : dict[str, Any] | None, optional
+            Runtime keyword arguments to customize the content generation.
+
         Returns
         -------
         str
@@ -241,7 +256,10 @@ class WaldiezTool(WaldiezBase):
         config = get_predefined_tool_config(self.name)
         if not config:
             return ""
-        return config.get_content(self.data.secrets)
+        return config.get_content(
+            self.data.secrets,
+            runtime_kwargs=runtime_kwargs,
+        )
 
     def _validate_interop_tool(self) -> None:
         """Validate the interoperability tool.

waldiez/models/waldiez.py

@@ -39,6 +39,18 @@ class Waldiez:
 
     flow: WaldiezFlow
 
+    @classmethod
+    def default(cls) -> "Waldiez":
+        """Create a default Waldiez instance.
+
+        Returns
+        -------
+        Waldiez
+            The default Waldiez instance.
+        """
+        flow = WaldiezFlow.default()
+        return cls(flow=flow)
+
     @classmethod
     def from_dict(
         cls,

waldiez/runner.py

@@ -5,12 +5,16 @@
 # pylint: disable=too-many-positional-arguments
 """Run a waldiez flow.
 
-The flow is first converted to an autogen flow with agents, chats, and tools.
-We then chown to temporary directory and:
-    either import and call the flow's `main()` (if not isolated),
-    or run the flow in a subprocess (if isolated).
-Before running the flow, any additional environment
-variables specified in the waldiez file are set.
+The flow is first converted to an ag2 flow with agents, chats, and tools.
+We then chown to temporary directory,
+    import and call the flow's `main(on_event)` method.
+The `on_event` method is called with the event emitter,
+    which emits events during the flow execution.
+The flow is run in a temporary directory,
+    and the results are saved to the output file's directory.
+The uploads root directory is used to store any uploaded files
+during the flow execution.
+
 """
 
 from pathlib import Path
@@ -22,13 +26,14 @@ from .models.waldiez import Waldiez
 from .running import (
     WaldiezBaseRunner,
     WaldiezStandardRunner,
+    WaldiezStepByStepRunner,
+    WaldiezSubprocessRunner,
 )
 
 
 def create_runner(
     waldiez: Waldiez,
-    # mode: Literal["standard", "debug"] = "standard",
-    mode: Literal["standard"] = "standard",
+    mode: Literal["standard", "debug", "subprocess"] = "standard",
     output_path: str | Path | None = None,
     uploads_root: str | Path | None = None,
     structured_io: bool = False,
@@ -41,7 +46,7 @@ def create_runner(
     ----------
     waldiez : Waldiez
         The waldiez flow to run.
-    mode : str, optional
+    mode : Literal["standard", "debug"], optional
         Runner mode: "standard", "debug", by default "standard"
     output_path : str | Path | None, optional
         Output path for results, by default None
@@ -66,22 +71,37 @@ def create_runner(
     """
     runners: dict[str, type[WaldiezBaseRunner]] = {
         "standard": WaldiezStandardRunner,
-        # "debug": WaldiezDebugRunner,
+        "debug": WaldiezStepByStepRunner,
+        "subprocess": WaldiezSubprocessRunner,
     }
 
-    if mode not in runners:
+    if mode not in runners:  # pragma: no cover
         available = ", ".join(runners.keys())
         raise ValueError(
             f"Unknown runner mode '{mode}'. Available: {available}"
         )
 
     runner_class = runners[mode]
+    if mode == "subprocess":
+        subprocess_mode = kwargs.pop("subprocess_mode", "run")
+        if subprocess_mode not in ["run", "debug"]:
+            subprocess_mode = "run"
+        return runner_class(
+            waldiez=waldiez,
+            output_path=output_path,
+            uploads_root=uploads_root,
+            structured_io=structured_io,
+            dot_env=dot_env,
+            mode=subprocess_mode,
+            **kwargs,
+        )
     return runner_class(
         waldiez=waldiez,
         output_path=output_path,
         uploads_root=uploads_root,
         structured_io=structured_io,
         dot_env=dot_env,
+        mode=mode,
         **kwargs,
     )
 
@@ -94,8 +114,7 @@ class WaldiezRunner(WaldiezBaseRunner):
     def __init__(
         self,
         waldiez: Waldiez,
-        # mode: Literal["standard", "debug"] = "standard",
-        mode: Literal["standard"] = "standard",
+        mode: Literal["standard", "debug"] = "standard",
         output_path: str | Path | None = None,
         uploads_root: str | Path | None = None,
         structured_io: bool = False,
@@ -131,7 +150,7 @@ class WaldiezRunner(WaldiezBaseRunner):
             **kwargs,
         )
 
-    def __repr__(self) -> str:
+    def __repr__(self) -> str:  # pragma: no cover
         """Get the string representation of the runner.
 
         Returns
@@ -156,7 +175,9 @@ class WaldiezRunner(WaldiezBaseRunner):
         """
         if hasattr(self._runner, name):
             return getattr(self._runner, name)
-        raise AttributeError(f"{type(self).__name__} has no attribute '{name}'")
+        raise AttributeError(
+            f"{type(self).__name__} has no attribute '{name}'"
+        )  # pragma: no cover
 
     def _run(
         self,
@@ -176,26 +197,6 @@ class WaldiezRunner(WaldiezBaseRunner):
             **kwargs,
         )
 
-    def _start(
-        self,
-        temp_dir: Path,
-        output_file: Path,
-        uploads_root: Path | None,
-        skip_mmd: bool,
-        skip_timeline: bool,
-    ) -> None:
-        """Start the workflow in a non-blocking way."""
-        self._runner._start(
-            temp_dir=temp_dir,
-            output_file=output_file,
-            uploads_root=uploads_root,
-            skip_mmd=skip_mmd,
-            skip_timeline=skip_timeline,
-        )
-
-    def _stop(self) -> None:
-        self._runner._stop()
-
     async def _a_run(
         self,
         temp_dir: Path,
@@ -216,25 +217,6 @@ class WaldiezRunner(WaldiezBaseRunner):
             **kwargs,
         )
 
-    async def _a_start(
-        self,
-        temp_dir: Path,
-        output_file: Path,
-        uploads_root: Path | None,
-        skip_mmd: bool,
-        skip_timeline: bool,
-    ) -> None:
-        return await self._runner._a_start(
-            temp_dir=temp_dir,
-            output_file=output_file,
-            uploads_root=uploads_root,
-            skip_mmd=skip_mmd,
-            skip_timeline=skip_timeline,
-        )
-
-    async def _a_stop(self) -> None:
-        return await self._runner._a_stop()
-
     @classmethod
     def load(
         cls,
@@ -299,5 +281,6 @@ class WaldiezRunner(WaldiezBaseRunner):
             uploads_root=uploads_root,
             structured_io=structured_io,
             dot_env=dot_env,
+            waldiez_file=waldiez_file,
             **kwargs,
         )

waldiez/running/__init__.py

@@ -3,9 +3,15 @@
 """Running related functions."""
 
 from .base_runner import WaldiezBaseRunner
+from .exceptions import StopRunningException
 from .standard_runner import WaldiezStandardRunner
+from .step_by_step import WaldiezStepByStepRunner
+from .subprocess_runner import WaldiezSubprocessRunner
 
 __all__ = [
+    "StopRunningException",
     "WaldiezBaseRunner",
     "WaldiezStandardRunner",
+    "WaldiezStepByStepRunner",
+    "WaldiezSubprocessRunner",
 ]