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

waldiez/ws/_file_handler.py

@@ -0,0 +1,199 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+
+"""Files related request handler."""
+
+import json
+import logging
+from pathlib import Path
+from typing import Any
+
+from waldiez.exporter import WaldiezExporter
+from waldiez.models import Waldiez
+
+from .models import (
+    ConvertWorkflowRequest,
+    ConvertWorkflowResponse,
+    SaveFlowRequest,
+    SaveFlowResponse,
+)
+
+
+class FileRequestHandler:
+    """Handles file-related requests."""
+
+    @staticmethod
+    def handle_save_flow_request(
+        msg: SaveFlowRequest,
+        workspace_dir: Path,
+        client_id: str,
+        logger: logging.Logger,
+    ) -> dict[str, Any]:
+        """Handle save flow request.
+
+        Parameters
+        ----------
+        msg : SaveFlowRequest
+            The save flow request message.
+        workspace_dir : Path
+            The workspace directory.
+        client_id : str
+            The client ID.
+        logger : logging.Logger
+            The logger instance.
+
+        Returns
+        -------
+        dict[str, Any]
+            The response dictionary.
+        """
+        filename = msg.filename or f"waldiez_{client_id}.waldiez"
+        try:
+            output_path = resolve_output_path(
+                filename,
+                workspace_dir=workspace_dir,
+                expected_ext="waldiez",
+            )
+        except ValueError as exc:
+            logger.error("Error resolving output path: %s", exc)
+            return SaveFlowResponse.fail(
+                error=f"Invalid output path: {exc}",
+                file_path=filename,
+            ).model_dump(mode="json")
+        # pylint: disable=too-many-try-statements
+        try:
+            if output_path.exists() and not msg.force_overwrite:
+                return SaveFlowResponse.fail(
+                    error=f"File exists: {output_path}",
+                    file_path=str(output_path.relative_to(workspace_dir)),
+                ).model_dump(mode="json")
+
+            # Parent dir already created by resolve_output_path
+            output_path.write_text(msg.flow_data, encoding="utf-8")
+
+            return SaveFlowResponse.ok(
+                file_path=str(output_path.relative_to(workspace_dir))
+            ).model_dump(mode="json")
+        except Exception as e:  # pylint: disable=broad-exception-caught
+            logger.error("Error saving flow: %s", e)
+            return SaveFlowResponse.fail(error=str(e)).model_dump(mode="json")
+
+    @staticmethod
+    def handle_convert_workflow_request(
+        msg: ConvertWorkflowRequest,
+        client_id: str,
+        workspace_dir: Path,
+        logger: logging.Logger,
+    ) -> dict[str, Any]:
+        """Handle a convert workflow request.
+
+        Parameters
+        ----------
+        msg : ConvertWorkflowRequest
+            The convert workflow request message.
+        client_id : str
+            The client ID.
+        workspace_dir : Path
+            The workspace directory.
+        logger : logging.Logger
+            The logger instance.
+
+        Returns
+        -------
+        dict[str, Any]
+            The response dictionary.
+        """
+        target_format = (msg.target_format or "").strip().lower()
+        if target_format not in {"py", "ipynb"}:
+            return ConvertWorkflowResponse.fail(
+                error=f"Unsupported target format: {target_format}",
+                target_format=target_format,
+            ).model_dump(mode="json")
+
+        try:
+            waldiez_data = Waldiez.from_dict(json.loads(msg.flow_data))
+        except Exception as e:  # pylint: disable=broad-exception-caught
+            return ConvertWorkflowResponse.fail(
+                error=f"Invalid flow_data: {e}",
+                target_format=target_format,
+            ).model_dump(mode="json")
+
+        try:
+            # Use normalized target_format for default name
+            filename = msg.output_path or f"waldiez_{client_id}.{target_format}"
+            output_path = resolve_output_path(
+                filename,
+                workspace_dir=workspace_dir,
+                expected_ext=target_format,
+            )
+        except ValueError as exc:
+            logger.error("Error resolving output path: %s", exc)
+            return ConvertWorkflowResponse.fail(
+                error=f"Invalid output path: {exc}",
+                target_format=target_format,
+            ).model_dump(mode="json")
+
+        try:
+            exporter = WaldiezExporter(waldiez_data)
+            exporter.export(path=output_path, force=True, structured_io=True)
+
+            return ConvertWorkflowResponse.ok(
+                target_format=target_format,
+                output_path=str(output_path.relative_to(workspace_dir)),
+            ).model_dump(mode="json")
+        except Exception as e:  # pylint: disable=broad-exception-caught
+            logger.error("Error converting workflow: %s", e)
+            return ConvertWorkflowResponse.fail(
+                error=str(e), target_format=target_format
+            ).model_dump(mode="json")
+
+
+def resolve_output_path(
+    filename: str,
+    workspace_dir: Path,
+    expected_ext: str | None = None,
+) -> Path:
+    """
+    Resolve output path inside the workspace.
+
+    Parameters
+    ----------
+    filename : str
+        Provided filename (may be relative or absolute).
+    workspace_dir : Path
+        The workspace directory to resolve the output path against.
+    expected_ext : str | None
+        If provided, ensure the filename ends with this extension.
+
+    Returns
+    -------
+    Path
+        Resolved absolute path, with parent directories created.
+
+    Raises
+    ------
+    ValueError
+        If the output path is outside the workspace.
+    """
+    # Normalize workspace_dir to an absolute path
+    workspace_dir = workspace_dir.resolve()
+
+    output_path = Path(filename)
+    if not output_path.is_absolute():
+        output_path = workspace_dir / output_path
+
+    if expected_ext and output_path.suffix != f".{expected_ext}":
+        output_path = output_path.with_suffix(f".{expected_ext}")
+
+    output_path = output_path.resolve()
+
+    # Ensure output_path is a subpath of workspace_dir
+    try:
+        output_path.relative_to(workspace_dir)
+    except ValueError as exc:
+        raise ValueError(
+            f"Output path {output_path} is outside workspace {workspace_dir}"
+        ) from exc
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    return output_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

@@ -0,0 +1,235 @@
+# SPDX-License-Identifier: Apache-2.0.
+# Copyright (c) 2024 - 2025 Waldiez and contributors.
+# pylint: disable=too-many-locals,unused-import
+"""CLI interface for Waldiez WebSocket server."""
+
+import asyncio
+import logging
+import re
+import sys
+from pathlib import Path
+from typing import Annotated, Any, Optional, Set
+
+import typer
+
+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()
+
+
+def setup_logging(verbose: bool = False) -> None:
+    """Set up logging configuration.
+
+    Parameters
+    ----------
+    verbose : bool
+        Enable verbose logging
+    """
+    level = logging.DEBUG if verbose else logging.INFO
+    format_str = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+
+    logging.basicConfig(
+        level=level,
+        format=format_str,
+        handlers=[logging.StreamHandler(sys.stdout)],
+    )
+
+    # Set websockets logger to WARNING to reduce noise
+    logging.getLogger("websockets").setLevel(logging.WARNING)
+
+
+app = typer.Typer(
+    name="waldiez-ws",
+    help="Waldiez WebSocket server",
+    add_completion=False,
+    context_settings={
+        "help_option_names": ["-h", "--help"],
+        "allow_extra_args": True,
+        "ignore_unknown_options": True,
+    },
+)
+
+
+@app.command()
+def serve(
+    host: Annotated[
+        str, typer.Option(help="Server host address")
+    ] = "localhost",
+    port: Annotated[int, typer.Option(help="Server port")] = 8765,
+    max_clients: Annotated[
+        int,
+        typer.Option(
+            "--max-clients", help="Maximum number of concurrent clients"
+        ),
+    ] = 1,
+    allowed_origins: Annotated[
+        Optional[list[str]],
+        typer.Option(
+            "--allowed-origin",
+            help=(
+                "Allowed origins for CORS (can be used multiple times). "
+                "Supports regex patterns. "
+                "Examples: 'https://example.com', '.*\\.mydomain\\.com'"
+            ),
+        ),
+    ] = None,
+    auto_reload: Annotated[
+        bool,
+        typer.Option(
+            "--auto-reload",
+            help=(
+                "Enable auto-reload on file changes "
+                "(requires: pip install watchdog)"
+            ),
+        ),
+    ] = False,
+    watch_dir: Annotated[
+        Optional[list[Path]],
+        typer.Option(
+            "--watch-dir",
+            help=(
+                "Additional directories to watch for auto-reload "
+                "(can be used multiple times)"
+            ),
+        ),
+    ] = None,
+    workspace_dir: Annotated[
+        Path,
+        typer.Option(
+            "--workspace",
+            help="Path to the workspace directory",
+            resolve_path=True,
+            dir_okay=True,
+            file_okay=False,
+        ),
+    ] = DEFAULT_WORKSPACE_DIR,
+    ping_interval: Annotated[
+        float,
+        typer.Option(
+            "--ping-interval", help="WebSocket ping interval in seconds"
+        ),
+    ] = 20.0,
+    ping_timeout: Annotated[
+        float,
+        typer.Option(
+            "--ping-timeout", help="WebSocket ping timeout in seconds"
+        ),
+    ] = 20.0,
+    max_size: Annotated[
+        int, typer.Option("--max-size", help="Maximum message size in bytes")
+    ] = 8388608,
+    verbose: Annotated[
+        bool, typer.Option("--verbose", "-v", help="Enable verbose logging")
+    ] = False,
+) -> None:
+    """Start Waldiez WebSocket server.
+
+    Parameters
+    ----------
+    host : str
+        Server host address
+    port : int
+        Server port
+    max_clients : int
+        Maximum number of concurrent clients
+    allowed_origins : list[str] | None
+        List of allowed origins for CORS (default: None)
+    auto_reload : bool
+        Enable auto-reload on file changes
+    watch_dir : tuple[Path, ...]
+        Additional directories to watch for auto-reload
+    workspace_dir : Path
+        Path to the workspace directory
+    ping_interval : float
+        WebSocket ping interval in seconds
+    ping_timeout : float
+        WebSocket ping timeout in seconds
+    max_size : int
+        Maximum message size in bytes
+    verbose : bool
+        Enable verbose logging
+    """
+    setup_logging(verbose)
+
+    logger = logging.getLogger(__name__)
+
+    # Convert watch directories to set
+    watch_dirs: Optional[Set[Path]] = None
+    if watch_dir:
+        watch_dirs = set(watch_dir)
+
+    compiled_origins: list[re.Pattern[str]] | None = None
+    if allowed_origins:
+        try:
+            compiled_origins = [
+                re.compile(pattern) for pattern in allowed_origins
+            ]
+        except re.error as e:
+            typer.echo(f"Invalid regex pattern in allowed origins: {e}")
+            sys.exit(1)
+
+    # Server configuration
+    server_config: dict[str, Any] = {
+        "max_clients": max_clients,
+        "allowed_origins": compiled_origins,
+        "ping_interval": ping_interval,
+        "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)
+    logger.info("  Port: %d", port)
+    logger.info("  Max clients: %d", max_clients)
+    logger.info("  Allowed origins: %s", allowed_origins or ["*"])
+    logger.info("  Auto-reload: %s", auto_reload)
+    logger.info("  Workspace directory: %s", workspace_dir)
+
+    if watch_dirs:
+        logger.info("  Watch directories: %s", watch_dirs)
+
+    try:
+        asyncio.run(
+            run_server(
+                host=host,
+                port=port,
+                workspace_dir=workspace_dir,
+                auto_reload=auto_reload,
+                watch_dirs=watch_dirs,
+                **server_config,
+            )
+        )
+    except KeyboardInterrupt:
+        logger.info("Server stopped by user")
+    except Exception as e:  # pylint: disable=broad-exception-caught
+        logger.error("Server error: %s", e)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    app()