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

waldiez/running/subprocess_runner/__base__.py

@@ -195,7 +195,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 +204,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 +214,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

@@ -311,7 +311,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

@@ -175,7 +175,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 +208,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 +271,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 +318,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")

waldiez/running/subprocess_runner/runner.py

@@ -18,6 +18,7 @@ from ._sync_runner import SyncSubprocessRunner
 # in self._run and self._a_run
 
 
+# noinspection PyUnusedLocal
 class WaldiezSubprocessRunner(WaldiezBaseRunner):
     """Waldiez runner that uses subprocess execution via standalone runners."""
 
@@ -89,6 +90,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,6 +103,7 @@ 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:
@@ -462,6 +465,7 @@ class WaldiezSubprocessRunner(WaldiezBaseRunner):
         self,
         results: list[dict[str, Any]],
         output_file: Path,
+        waldiez_file: Path,
         uploads_root: Path | None,
         temp_dir: Path,
         skip_mmd: bool,
@@ -475,6 +479,8 @@ class WaldiezSubprocessRunner(WaldiezBaseRunner):
             Results from the workflow execution
         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
@@ -491,6 +497,7 @@ class WaldiezSubprocessRunner(WaldiezBaseRunner):
         self,
         results: list[dict[str, Any]],
         output_file: Path,
+        waldiez_file: Path,
         uploads_root: Path | None,
         temp_dir: Path,
         skip_mmd: bool,
@@ -504,6 +511,8 @@ class WaldiezSubprocessRunner(WaldiezBaseRunner):
             Results from the workflow execution
         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/utils.py

@@ -97,6 +97,71 @@ async def a_chdir(to: Union[str, Path]) -> AsyncIterator[None]:
         os.chdir(old_cwd)
 
 
+def get_python_executable() -> str:
+    """Get the appropriate Python executable path.
+
+    For bundled applications, this might be different from sys.executable.
+
+    Returns
+    -------
+    str
+        Path to the Python executable to use for pip operations.
+    """
+    # Check if we're in a bundled application (e.g., PyInstaller)
+    if getattr(sys, "frozen", False):  # pragma: no cover
+        # We're in a bundled app
+        if hasattr(sys, "_MEIPASS"):
+            sys_meipass = getattr(
+                sys, "_MEIPASS", str(Path.home() / ".waldiez" / "bin")
+            )
+            bundled = Path(sys_meipass) / "python"
+            if bundled.exists():
+                return str(bundled)
+    return sys.executable
+
+
+# noinspection TryExceptPass,PyBroadException
+def ensure_pip() -> None:  # pragma: no cover
+    """Make sure `python -m pip` works (bootstrap via ensurepip if needed)."""
+    # pylint: disable=import-outside-toplevel
+    # pylint: disable=unused-import,broad-exception-caught
+    try:
+        import pip  # noqa: F401  # pyright: ignore
+
+        return
+    except Exception:
+        pass
+    try:
+        import ensurepip
+
+        ensurepip.bootstrap(upgrade=True)
+    except Exception:
+        # If bootstrap fails, we'll still attempt `-m pip` and surface errors.
+        pass
+
+
+def get_pip_install_location() -> str | None:
+    """Determine the best location to install packages.
+
+    Returns
+    -------
+    Optional[str]
+        The installation target directory, or None for default.
+    """
+    if getattr(sys, "frozen", False):  # pragma: no cover
+        # For bundled apps, try to install to a user-writable location
+        if hasattr(sys, "_MEIPASS"):
+            app_data = Path.home() / ".waldiez" / "site-packages"
+            app_data.mkdir(parents=True, exist_ok=True)
+            # Add to sys.path if not already there
+            app_data_str = str(app_data)
+            if app_data_str not in sys.path:
+                # after stdlib
+                sys.path.insert(1, app_data_str)
+            return app_data_str
+    return None
+
+
 def strip_ansi(text: str) -> str:
     """Remove ANSI escape sequences from text.
 
@@ -128,7 +193,7 @@ def create_sync_subprocess(setup: ProcessSetup) -> subprocess.Popen[bytes]:
         The created subprocess.
     """
     return subprocess.Popen(
-        [sys.executable, "-u", str(setup.file_path)],
+        [get_python_executable(), "-u", str(setup.file_path)],
         stdout=subprocess.PIPE,
         stderr=subprocess.PIPE,
         stdin=subprocess.PIPE,
@@ -153,7 +218,7 @@ async def create_async_subprocess(setup: ProcessSetup) -> Process:
         The created asynchronous subprocess.
     """
     return await asyncio.create_subprocess_exec(
-        sys.executable,
+        get_python_executable(),
         "-u",
         str(setup.file_path),
         # stdout=asyncio.subprocess.PIPE,
@@ -509,3 +574,52 @@ def _run_in_thread(
 
     # Use cast since we know the result should be T if no exception occurred
     return cast(T, result_container.result)
+
+
+def safe_filename(name: str, ext: str = "") -> str:
+    """
+    Make a safe cross-platform filename from an arbitrary string.
+
+    Parameters
+    ----------
+    name : str
+        The string to turn into a safe filename.
+    ext :  str
+        Optional extension (with or without leading dot).
+
+    Returns
+    -------
+    str
+        A safe filename string.
+    """
+    # Normalize extension
+    # pylint: disable=inconsistent-quotes
+    ext = f".{ext.lstrip('.')}" if ext else ""
+
+    # Forbidden characters on Windows (also bad on Unix)
+    forbidden = r'[<>:"/\\|?*\x00-\x1F]'
+    name = re.sub(forbidden, "_", name)
+
+    # Trim trailing dots/spaces (illegal on Windows)
+    name = name.rstrip(". ")
+
+    # Collapse multiple underscores
+    name = re.sub(r"_+", "_", name)
+
+    # Reserved Windows device names
+    reserved = re.compile(
+        r"^(con|prn|aux|nul|com[1-9]|lpt[1-9])$", re.IGNORECASE
+    )
+    if reserved.match(name):
+        name = f"_{name}"
+
+    # Fallback if empty
+    if not name:
+        name = "file"
+
+    # Ensure length limit (NTFS max filename length = 255 bytes)
+    max_len = 255 - len(ext)
+    if len(name) > max_len:
+        name = name[:max_len]
+
+    return f"{name}{ext}"

waldiez/ws/__init__.py

@@ -18,7 +18,7 @@ from .errors import (
     UnsupportedActionError,
     WaldiezServerError,
 )
-from .server import WaldiezWsServer, run_server
+from .server import HAS_WEBSOCKETS, WaldiezWsServer, run_server
 from .session_manager import SessionManager
 from .utils import (
     ConnectionManager,
@@ -38,13 +38,14 @@ def add_ws_app(app: typer.Typer) -> None:
     app : typer.Typer
         The Typer application instance.
     """
-    app.registered_commands.append(
-        CommandInfo(
-            name="ws",
-            help="Start the Waldiez WebSocket server.",
-            callback=serve,
+    if HAS_WEBSOCKETS:
+        app.registered_commands.append(
+            CommandInfo(
+                name="ws",
+                help="Start the Waldiez WebSocket server.",
+                callback=serve,
+            )
         )
-    )
 
 
 __all__ = [

waldiez/ws/_file_handler.py

@@ -3,8 +3,6 @@
 
 """Files related request handler."""
 
-from __future__ import annotations
-
 import json
 import logging
 from pathlib import Path

waldiez/ws/_mock.py

@@ -0,0 +1,74 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+
+"""Mock websockets for linters."""
+# pylint: disable=invalid-name,line-too-long,unused-argument,too-few-public-methods,no-self-use
+# pylint: disable=missing-class-docstring,missing-function-docstring,missing-return-doc
+# flake8: noqa: E501, D101, D102, D106
+
+from typing import Any  # pragma: no cover
+
+
+# noinspection PyPep8Naming, PyMethodMayBeStatic,PyUnusedLocal
+class websockets:  # pragma: no cover
+    # noinspection PyMethodMayBeStatic
+    class ClientConnection:
+        async def __aenter__(self) -> "websockets.ClientConnection":
+            return self
+
+        async def send(self, data: Any) -> None:
+            pass
+
+        async def close(self) -> None:
+            pass
+
+        async def recv(self) -> str:
+            return ""
+
+    # noinspection PyPep8Naming
+    class exceptions:
+        class ConnectionClosedError(Exception): ...
+
+    class ConnectionClosedOK(Exception): ...
+
+    class Server:
+        def close(self) -> None:
+            pass
+
+        async def wait_closed(self) -> None:
+            pass
+
+    class ServerConnection:
+        remote_address: str
+
+        # noinspection PyPep8Naming
+        class request:
+            headers: dict[str, str]
+
+        async def close(
+            self, code: int = 1000, reason: str = "Normal Closure"
+        ) -> None:
+            pass
+
+        # noinspection PyPep8Naming
+        async def ConnectionClosedOK(self, *args: Any, **kwargs: Any) -> None:
+            pass
+
+        async def send(self, data: Any) -> None:
+            pass
+
+    @staticmethod
+    async def serve(*args: Any, **kwargs: Any) -> "websockets.Server":
+        return websockets.Server()
+
+    @staticmethod
+    async def connect(
+        *args: Any, **kwargs: Any
+    ) -> "websockets.ClientConnection":
+        return websockets.ClientConnection()
+
+    class ConnectionClosed(Exception):
+        pass
+
+    class WebSocketException(Exception):
+        pass

waldiez/ws/cli.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: Apache-2.0.
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
-# pylint: disable=too-many-locals
+# pylint: disable=too-many-locals,unused-import
 """CLI interface for Waldiez WebSocket server."""
 
 import asyncio
@@ -12,7 +12,26 @@ from typing import Annotated, Any, Optional, Set
 
 import typer
 
-from .server import run_server
+HAS_WATCHDOG = False
+try:
+    from .reloader import FileWatcher  # pyright: ignore # noqa: F401
+
+    HAS_WATCHDOG = True  # pyright: ignore
+except ImportError:
+    pass
+
+HAS_WEBSOCKETS = False
+try:
+    from .server import run_server
+
+    HAS_WEBSOCKETS = True  # pyright: ignore
+except ImportError:
+    # pylint: disable=missing-param-doc,missing-raises-doc
+    # noinspection PyUnusedLocal
+    async def run_server(*args: Any, **kwargs: Any) -> None:  # type: ignore
+        """No WebSocket server available."""
+        raise NotImplementedError("WebSocket server is not available.")
+
 
 DEFAULT_WORKSPACE_DIR = Path.cwd()
 
@@ -176,7 +195,12 @@ def serve(
         "ping_timeout": ping_timeout,
         "max_size": max_size,
     }
-
+    if not HAS_WATCHDOG and auto_reload:
+        typer.echo(
+            "Auto-reload requires the 'watchdog' package. "
+            "Please install it with: pip install watchdog"
+        )
+        auto_reload = False
     logger.info("Starting Waldiez WebSocket server...")
     logger.info("Configuration:")
     logger.info("  Host: %s", host)

waldiez/ws/client_manager.py

@@ -1,10 +1,10 @@
 # SPDX-License-Identifier: Apache-2.0.
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
-# pylint: disable=too-many-try-statements,broad-exception-caught
-# pylint: disable=too-complex,too-many-return-statements
+# pylint: disable=too-many-try-statements,broad-exception-caught,line-too-long
+# pylint: disable=too-complex,too-many-return-statements,import-error
 # pyright: reportUnknownMemberType=false,reportAttributeAccessIssue=false
 # pyright: reportUnknownVariableType=false,reportUnknownArgumentType=false
-# pyright: reportAssignmentType=false
+# pyright: reportAssignmentType=false,reportUnknownParameterType=false
 # flake8: noqa: C901
 """WebSocket client manager: bridges WS <-> subprocess runner."""
 
@@ -15,7 +15,11 @@ import time
 from pathlib import Path
 from typing import Any, Callable, Literal
 
-import websockets
+try:
+    import websockets  # type: ignore[unused-ignore, unused-import, import-not-found, import-untyped] # noqa
+except ImportError:  # pragma: no cover
+    from ._mock import websockets  # type: ignore[no-redef,unused-ignore]
+
 
 from waldiez.models import Waldiez
 from waldiez.running.subprocess_runner.runner import WaldiezSubprocessRunner
@@ -67,7 +71,7 @@ class ClientManager:
 
     def __init__(
         self,
-        websocket: websockets.ServerConnection,
+        websocket: websockets.ServerConnection,  # pyright: ignore
         client_id: str,
         session_manager: SessionManager,
         workspace_dir: Path = CWD,
@@ -141,7 +145,10 @@ class ClientManager:
                 data = json.loads(json.dumps(payload, default=str))
             await self.websocket.send(json.dumps(data))
             return True
-        except (websockets.ConnectionClosed, ConnectionResetError) as e:
+        except (
+            websockets.ConnectionClosed,
+            ConnectionResetError,
+        ) as e:  # pyright: ignore
             self.logger.info("Client %s disconnected: %s", self.client_id, e)
             await self.cleanup()
             return False
@@ -383,8 +390,6 @@ class ClientManager:
             ExecutionMode.STEP_BY_STEP,
             session_id=session_id,
         )
-
-        # Persist desired flags (optional)
         sess = await self.session_manager.get_session(session_id)
         if sess:
             sess.state.metadata.update(
@@ -474,17 +479,20 @@ class ClientManager:
                 result="",
                 session_id=msg.session_id,
             ).model_dump(mode="json")
-
-        code = {
-            "": "c",
-            "continue": "c",
-            "step": "s",
-            "run": "r",
-            "quit": "q",
-            "info": "i",
-            "help": "h",
-            "stats": "st",
-        }.get(msg.action)
+        code: str | None
+        if msg.action in {"", "c", "s", "r", "q", "i", "h", "st"}:
+            code = msg.action if msg.action else "c"
+        else:
+            code = {
+                "": "c",
+                "continue": "c",
+                "step": "s",
+                "run": "r",
+                "quit": "q",
+                "info": "i",
+                "help": "h",
+                "stats": "st",
+            }.get(msg.action)
 
         if not code:
             return StepControlResponse.fail(
@@ -596,6 +604,7 @@ class ClientManager:
           - anything else
             -> fallback stdout SubprocessOutputNotification
         """
+        # self.logger.debug("Handling runner output: %s", data)
         try:
             msg_type = str(data.get("type", "")).lower()
             session_id_raw = data.get("session_id")
@@ -606,7 +615,9 @@ class ClientManager:
             )
 
             if msg_type in ("input_request", "debug_input_request"):
-                await self._handle_runner_input_request(session_id, data)
+                await self._handle_runner_input_request(
+                    session_id, data, is_debug=msg_type == "debug_input_request"
+                )
                 return
 
             if msg_type.startswith("debug_"):
@@ -646,7 +657,10 @@ class ClientManager:
             )
 
     async def _handle_runner_input_request(
-        self, session_id: str, data: dict[str, Any]
+        self,
+        session_id: str,
+        data: dict[str, Any],
+        is_debug: bool,
     ) -> None:
         """Handle an input request from the runner."""
         request_id = str(data.get("request_id", ""))
@@ -657,15 +671,17 @@ class ClientManager:
             await self.session_manager.update_session_status(
                 session_id, WorkflowStatus.INPUT_WAITING
             )
-            await self.send_message(
-                UserInputRequestNotification(
-                    session_id=session_id,
-                    request_id=request_id,
-                    prompt=prompt,
-                    password=bool(data.get("password", False)),
-                    timeout=float(data.get("timeout", 120.0)),
-                )
+            notification = UserInputRequestNotification(
+                session_id=session_id,
+                request_id=request_id,
+                prompt=prompt,
+                password=bool(data.get("password", False)),
+                timeout=float(data.get("timeout", 120.0)),
             )
+            msg_dump = notification.model_dump(mode="json", fallback=str)
+            if is_debug:
+                msg_dump["type"] = "debug_input_request"
+            await self.send_message(msg_dump)
 
     # pylint: disable=line-too-long
     async def _handle_runner_debug(

waldiez/ws/models.py

@@ -154,7 +154,24 @@ class StepControlRequest(BaseRequest):
     """Request to control step-by-step execution."""
 
     type: Literal["step_control"] = "step_control"
-    action: Literal["continue", "step", "run", "quit", "info", "help", "stats"]
+    action: Literal[
+        "continue",
+        "step",
+        "run",
+        "quit",
+        "info",
+        "help",
+        "stats",
+        "",
+        "c",
+        "s",
+        "r",
+        "q",
+        "i",
+        "h",
+        "?",
+        "st",
+    ]
     session_id: str
 
 

waldiez/ws/reloader.py

@@ -1,5 +1,10 @@
 # SPDX-License-Identifier: Apache-2.0.
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
+# pylint: disable=line-too-long
+# pyright: reportUnknownVariableType=false,reportConstantRedefinition=false
+# pyright: reportUntypedBaseClass=false,reportUnknownMemberType=false
+# pyright: reportUnknownParameterType=false,reportUnknownArgumentType=false
+# flake8: noqa: E501
 """Auto-reload functionality for development."""
 
 import logging
@@ -11,10 +16,26 @@ from pathlib import Path
 from types import TracebackType
 from typing import Any, Callable
 
-from watchdog.events import FileSystemEvent, FileSystemEventHandler
-from watchdog.observers import Observer
+HAS_WATCHDOG = False
+try:
+    from watchdog.events import (  # type: ignore[unused-ignore,unused-import,import-not-found,import-untyped]
+        FileSystemEvent,
+        FileSystemEventHandler,
+    )
+    from watchdog.observers import (  # type: ignore[unused-ignore,unused-import,import-not-found,import-untyped]
+        Observer,
+    )
+
+    HAS_WATCHDOG = True
+except ImportError as exc:
+    raise ImportError(
+        "The 'watchdog' package is required for auto-reload functionality. "
+        "Please install it using 'pip install watchdog'."
+    ) from exc
 
 logger = logging.getLogger(__name__)
+fsevents_logger = logging.getLogger("fsevents")
+fsevents_logger.setLevel(logging.WARNING)  # Reduce noise from fsevents
 
 
 class ReloadHandler(FileSystemEventHandler):