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

waldiez/running/subprocess_runner/__base__.py

@@ -50,6 +50,10 @@ class BaseSubprocessRunner:
         self.dot_env = dot_env
         self.logger = logger or logging.getLogger(self.__class__.__name__)
         self.waiting_for_input = False
+        breakpoints = kwargs.get("breakpoints", [])
+        if not isinstance(breakpoints, list):
+            breakpoints = []
+        self.breakpoints: list[str] = breakpoints
 
     def build_command(
         self,
@@ -110,6 +114,10 @@ class BaseSubprocessRunner:
         if self.dot_env:
             cmd.extend(["--dot-env", str(self.dot_env)])
 
+        if self.breakpoints:
+            for entry in self.breakpoints:
+                cmd.extend(["--breakpoints", entry])
+        self.logger.debug("Runner command: %s", " ".join(cmd))
         return cmd
 
     def parse_output(
@@ -138,7 +146,7 @@ class BaseSubprocessRunner:
         try:
             data = json.loads(line)
             if isinstance(data, dict):
-                return data  # pyright: ignore
+                return data  # pyright: ignore[reportUnknownVariableType]
         except json.JSONDecodeError:
             return self.create_output_message(stream=stream, content=line)
         return self.create_output_message(
@@ -195,7 +203,7 @@ class BaseSubprocessRunner:
     def create_input_response(
         self,
         response_type: str,
-        user_input: str,
+        user_input: Any,
         request_id: str | None = None,
     ) -> str:
         """Create input response for subprocess.
@@ -204,7 +212,7 @@ class BaseSubprocessRunner:
         ----------
         response_type : str
             Type of the response
-        user_input : str
+        user_input : Any
             User's input response
         request_id : str | None
             Request ID from the input request
@@ -214,15 +222,12 @@ class BaseSubprocessRunner:
         str
             JSON-formatted response
         """
-        response = {
-            "type": response_type,
-            "data": user_input,
-        }
+        response: dict[str, Any] = {"type": response_type, "data": user_input}
 
         if request_id:
             response["request_id"] = request_id
 
-        return json.dumps(response) + "\n"
+        return json.dumps(response, default=str, ensure_ascii=False) + "\n"
 
     def create_output_message(
         self, content: str, stream: str = "stdout", msg_type: str = "output"

waldiez/running/subprocess_runner/_async_runner.py

@@ -10,8 +10,9 @@ import logging
 
 # noinspection PyProtectedMember
 from asyncio.subprocess import Process as AsyncProcess
+from collections.abc import Coroutine
 from pathlib import Path
-from typing import Any, Callable, Coroutine, Literal, Optional
+from typing import Any, Callable, Literal
 
 from .__base__ import BaseSubprocessRunner
 
@@ -57,7 +58,7 @@ class AsyncSubprocessRunner(BaseSubprocessRunner):
         )
         self.on_output = on_output
         self.on_input_request = on_input_request
-        self.process: Optional[AsyncProcess] = None
+        self.process: AsyncProcess | None = None
         self.input_queue: asyncio.Queue[str] = asyncio.Queue()
         self.output_queue: asyncio.Queue[dict[str, Any]] = asyncio.Queue()
         self._monitor_tasks: list[asyncio.Task[Any]] = []
@@ -158,7 +159,8 @@ class AsyncSubprocessRunner(BaseSubprocessRunner):
                     await self.process.wait()
 
             except Exception as e:
-                self.logger.error(f"Error stopping subprocess: {e}")
+                if not isinstance(e, AttributeError):
+                    self.logger.error(f"Error stopping subprocess: {e}")
         self.process = None
 
     async def _start_monitoring(self) -> None:
@@ -311,7 +313,7 @@ class AsyncSubprocessRunner(BaseSubprocessRunner):
                 self.process.stdin.write(response.encode())
                 await self.process.stdin.drain()
 
-            self.logger.debug(f"Sent input response: {user_input}")
+            self.logger.debug(f"Sent {response_type}: {user_input}")
 
         except asyncio.TimeoutError:
             self.logger.warning("Input request timed out")

waldiez/running/subprocess_runner/_sync_runner.py

@@ -93,6 +93,7 @@ class SyncSubprocessRunner(BaseSubprocessRunner):
                 stdin=subprocess.PIPE,
                 stdout=subprocess.PIPE,
                 stderr=subprocess.PIPE,
+                encoding="utf-8",
                 text=True,
                 bufsize=1,  # Line buffered
             )
@@ -175,7 +176,6 @@ class SyncSubprocessRunner(BaseSubprocessRunner):
                     # Use readline with timeout simulation
                     if self.process.stdout.readable():  # pragma: no branch
                         line = self.process.stdout.readline()
-
                         if not line:  # pragma: no cover
                             time.sleep(0.1)
                             continue
@@ -209,7 +209,7 @@ class SyncSubprocessRunner(BaseSubprocessRunner):
                     # Use readline with timeout simulation
                     if self.process.stderr.readable():  # pragma: no branch
                         line = self.process.stderr.readline()
-
+                        self.logger.debug("Stderr line: %s", line)
                         if not line:
                             time.sleep(0.1)
                             continue
@@ -272,9 +272,11 @@ class SyncSubprocessRunner(BaseSubprocessRunner):
         line : str
             Decoded line from stdout
         """
-        # Try to parse as structured JSON first
+        self.logger.debug(f"Stdout line: {line}")
         parsed_data = self.parse_output(line, stream="stdout")
         if not parsed_data:
+            self.logger.debug("Non-structured output, forwarding as is")
+            self.output_queue.put({"type": "print", "data": line}, timeout=1.0)
             return
         if parsed_data.get("type") in ("input_request", "debug_input_request"):
             prompt = parsed_data.get("prompt", "> ")
@@ -317,7 +319,7 @@ class SyncSubprocessRunner(BaseSubprocessRunner):
                 self.process.stdin.write(response)
                 self.process.stdin.flush()
 
-            self.logger.debug(f"Sent input response: {user_input}")
+            self.logger.debug(f"Sent {response_type}: {user_input}")
 
         except queue.Empty:
             self.logger.warning("Input request timed out")
@@ -350,8 +352,9 @@ class SyncSubprocessRunner(BaseSubprocessRunner):
                         f"Thread {thread.name} did not stop gracefully"
                     )
 
+    # pylint: disable=too-complex
     # noinspection TryExceptPass,PyBroadException
-    def _cleanup_process(self) -> None:
+    def _cleanup_process(self) -> None:  # noqa: C901
         """Cleanup process resources."""
         if self.process:
             if self.process.stdin:
@@ -380,7 +383,9 @@ class SyncSubprocessRunner(BaseSubprocessRunner):
                 self.process.kill()
                 self.process.wait()
             except BaseException as e:
-                self.logger.error(f"Error stopping subprocess: {e}")
+                if not isinstance(e, AttributeError):
+                    # already "None"
+                    self.logger.error(f"Error stopping subprocess: {e}")
             finally:
                 self.process = None
 

waldiez/running/subprocess_runner/runner.py

@@ -1,5 +1,7 @@
 # SPDX-License-Identifier: Apache-2.0.
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
+
+# pyright: reportAttributeAccessIssue=false,reportUnknownArgumentType=false
 # flake8: noqa: G004
 """Waldiez subprocess runner that inherits from BaseRunner."""
 
@@ -8,16 +10,17 @@ import re
 from pathlib import Path
 from typing import Any, Callable, Literal
 
+from typing_extensions import override
+
 from waldiez.models import Waldiez
 
 from ..base_runner import WaldiezBaseRunner
+from ..step_by_step.breakpoints_mixin import BreakpointsMixin
 from ._async_runner import AsyncSubprocessRunner
 from ._sync_runner import SyncSubprocessRunner
 
-# TODO: check output directory and return the results from the JSON logs
-# in self._run and self._a_run
-
 
+# noinspection PyUnusedLocal
 class WaldiezSubprocessRunner(WaldiezBaseRunner):
     """Waldiez runner that uses subprocess execution via standalone runners."""
 
@@ -70,6 +73,7 @@ class WaldiezSubprocessRunner(WaldiezBaseRunner):
             dot_env=dot_env,
             **kwargs,
         )
+        self.breakpoints = self._parse_breakpoints(**kwargs)
 
         # Store callbacks
         self.sync_on_output = on_output or self._default_sync_output
@@ -89,6 +93,7 @@ class WaldiezSubprocessRunner(WaldiezBaseRunner):
         mode = kwargs.get("mode", "run")
         if mode not in ["run", "debug"]:
             raise ValueError(f"Invalid mode: {mode}")
+        # noinspection PyTypeChecker
         self.mode: Literal["run", "debug"] = mode
         waldiez_file = kwargs.get("waldiez_file")
         self._waldiez_file = self._ensure_waldiez_file(waldiez_file)
@@ -101,19 +106,30 @@ class WaldiezSubprocessRunner(WaldiezBaseRunner):
             return waldiez_file.resolve()
         file_name = self.waldiez.name
         # sanitize file name
+        # noinspection RegExpRedundantEscape
         file_name = re.sub(r"[^a-zA-Z0-9_\-\.]", "_", file_name)[:30]
         file_name = f"{file_name}.waldiez"
-        with open(file_name, "w", encoding="utf-8") as f:
+        with open(file_name, "w", encoding="utf-8", newline="\n") as f:
             f.write(self.waldiez.model_dump_json())
         return Path(file_name).resolve()
 
+    @staticmethod
+    def _parse_breakpoints(**kwargs: Any) -> list[str]:
+        initial_breakpoints = kwargs.get("breakpoints")
+        if isinstance(initial_breakpoints, (list, set, tuple)):
+            breakpoints = BreakpointsMixin.get_initial_breakpoints(
+                initial_breakpoints
+            )
+            return [str(item) for item in breakpoints]
+        return []
+
     def _default_sync_output(self, data: dict[str, Any]) -> None:
         """Get the default sync output handler."""
         if data.get("type") == "error":
             self.log.error(data.get("data", ""))
         else:
             content = data.get("data", data)
-            self._print(content)
+            self.print(content)
 
     def _default_sync_input_request(self, prompt: str) -> None:
         """Get the default sync input request handler."""
@@ -138,6 +154,7 @@ class WaldiezSubprocessRunner(WaldiezBaseRunner):
             uploads_root=self.uploads_root,
             dot_env=self.dot_env_path,
             logger=self.log,
+            breakpoints=self.breakpoints,
         )
         return self.async_runner
 
@@ -150,9 +167,11 @@ class WaldiezSubprocessRunner(WaldiezBaseRunner):
             uploads_root=self.uploads_root,
             dot_env=self.dot_env_path,
             logger=self.log,
+            breakpoints=self.breakpoints,
         )
         return self.sync_runner
 
+    @override
     def run(
         self,
         output_path: str | Path | None = None,
@@ -217,6 +236,7 @@ class WaldiezSubprocessRunner(WaldiezBaseRunner):
                 return _output_path / f"{filename}.py"
         return self._waldiez_file.with_suffix(".py")
 
+    @override
     def _run(
         self,
         temp_dir: Path,
@@ -239,14 +259,8 @@ class WaldiezSubprocessRunner(WaldiezBaseRunner):
             runner = self._create_sync_subprocess_runner()
 
             # Run subprocess
-            success = runner.run_subprocess(self._waldiez_file, mode=self.mode)
-            return [
-                {
-                    "success": success,
-                    "runner": "sync_subprocess",
-                    "mode": self.mode,
-                }
-            ]
+            runner.run_subprocess(self._waldiez_file, mode=self.mode)
+            return self.read_from_output(output_file.parent)
 
         except Exception as e:
             self.log.error("Error in sync subprocess execution: %s", e)
@@ -258,6 +272,7 @@ class WaldiezSubprocessRunner(WaldiezBaseRunner):
                 }
             ]
 
+    @override
     async def a_run(
         self,
         output_path: str | Path | None = None,
@@ -308,6 +323,7 @@ class WaldiezSubprocessRunner(WaldiezBaseRunner):
             **kwargs,
         )
 
+    @override
     async def _a_run(
         self,
         temp_dir: Path,
@@ -353,17 +369,11 @@ class WaldiezSubprocessRunner(WaldiezBaseRunner):
             runner = self._create_async_subprocess_runner()
 
             # Run subprocess
-            success = await runner.run_subprocess(
+            await runner.run_subprocess(
                 self._waldiez_file,
                 mode=self.mode,
             )
-            return [
-                {
-                    "success": success,
-                    "runner": "async_subprocess",
-                    "mode": self.mode,
-                }
-            ]
+            return await self.a_read_from_output(output_file.parent)
 
         except Exception as e:
             self.log.error("Error in async subprocess execution: %s", e)
@@ -405,6 +415,7 @@ class WaldiezSubprocessRunner(WaldiezBaseRunner):
                 self.sync_runner.provide_user_input, user_input
             )
 
+    @override
     def stop(self) -> None:
         """Stop the workflow execution."""
         super().stop()  # Set the base runner stop flag
@@ -458,10 +469,13 @@ class WaldiezSubprocessRunner(WaldiezBaseRunner):
             self.sync_runner.stop()
         self.sync_runner = None
 
+    @override
     def _after_run(
         self,
         results: list[dict[str, Any]],
+        error: BaseException | None,
         output_file: Path,
+        waldiez_file: Path,
         uploads_root: Path | None,
         temp_dir: Path,
         skip_mmd: bool,
@@ -472,9 +486,13 @@ class WaldiezSubprocessRunner(WaldiezBaseRunner):
         Parameters
         ----------
         results : list[dict[str, Any]]
-            Results from the workflow execution
+            Results from the workflow execution.
+        error : BaseException | None
+            Optional error during the run.
         output_file : Path
             Output file path
+        waldiez_file : Path
+            The waldiez file used/dumped for the run.
         uploads_root : Path | None
             Uploads root directory
         temp_dir : Path
@@ -487,10 +505,13 @@ class WaldiezSubprocessRunner(WaldiezBaseRunner):
         # Cleanup subprocess runners
         self._cleanup_subprocess_runners()
 
+    @override
     async def _a_after_run(
         self,
         results: list[dict[str, Any]],
+        error: BaseException | None,
         output_file: Path,
+        waldiez_file: Path,
         uploads_root: Path | None,
         temp_dir: Path,
         skip_mmd: bool,
@@ -501,9 +522,13 @@ class WaldiezSubprocessRunner(WaldiezBaseRunner):
         Parameters
         ----------
         results : list[dict[str, Any]]
-            Results from the workflow execution
+            Results from the workflow execution.
+        error : BaseException | None
+            Optional error during the run.
         output_file : Path
             Output file path
+        waldiez_file : Path
+            The waldiez file used/dumped for the run.
         uploads_root : Path | None
             Uploads root directory
         temp_dir : Path

waldiez/running/timeline_processor.py

@@ -93,7 +93,7 @@ class TimelineProcessor:
         bool
             True if the value is missing, NaN, or empty; False otherwise.
         """
-        if pd.isna(value):  # pyright: ignore
+        if pd.isna(value):
             return True
         if isinstance(value, str) and (
             value.strip() == "" or value.lower() == "nan"

waldiez/utils/__init__.py

@@ -3,9 +3,11 @@
 """Utils to call on init."""
 
 from .conflict_checker import check_conflicts
+from .python_manager import PythonManager
 from .version import get_waldiez_version
 
 __all__ = [
     "check_conflicts",
     "get_waldiez_version",
+    "PythonManager",
 ]

waldiez/utils/conflict_checker.py

@@ -15,16 +15,16 @@ __waldiez_checked_conflicts = False
 def _check_autogen_agentchat() -> None:  # pragma: no cover
     try:
         version("autogen-agentchat")
-        print(
+        msg = (
             "Conflict detected: 'autogen-agentchat' is installed "
             "in the current environment, \n"
             "which conflicts with 'ag2'.\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 'ag2' (and/or 'waldiez') again: \n"
-            f"{sys.executable} -m pip install --force ag2 waldiez",
-            file=sys.stderr,
+            f"{sys.executable} -m pip install --force ag2 waldiez"
         )
+        print(msg, file=sys.stderr)
         sys.exit(1)
     except PackageNotFoundError:
         pass