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

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,invalid-name
+# 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
@@ -9,14 +14,34 @@ import threading
 import time
 from pathlib import Path
 from types import TracebackType
-from typing import Any, Callable
-
-from watchdog.events import FileSystemEvent, FileSystemEventHandler
-from watchdog.observers import Observer
+from typing import Any, Callable, final
+
+from typing_extensions import override
+
+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:
+    _msg = (  # pylint: disable=invalid-name
+        "The 'watchdog' package is required for auto-reload functionality. "
+        "Please install it using 'pip install watchdog'."
+    )
+    raise ImportError(_msg) from exc
 
 logger = logging.getLogger(__name__)
+fsevents_logger = logging.getLogger("fsevents")
+fsevents_logger.setLevel(logging.WARNING)  # Reduce noise from fsevents
 
 
+@final
 class ReloadHandler(FileSystemEventHandler):
     """Handler for file system events that triggers server reload."""
 
@@ -113,6 +138,7 @@ class ReloadHandler(FileSystemEventHandler):
             else str(event.src_path)
         )
 
+    @override
     def on_modified(self, event: FileSystemEvent) -> None:
         """Handle file modification events.
 
@@ -129,6 +155,7 @@ class ReloadHandler(FileSystemEventHandler):
         logger.info("File changed: %s", src_path)
         self._schedule_restart()
 
+    @override
     def on_created(self, event: FileSystemEvent) -> None:
         """Handle file creation events.
 
@@ -142,6 +169,7 @@ class ReloadHandler(FileSystemEventHandler):
             logger.info("File created: %s", src_path)
             self._schedule_restart()
 
+    @override
     def on_deleted(self, event: FileSystemEvent) -> None:
         """Handle file deletion events.
 
@@ -214,6 +242,7 @@ class ReloadHandler(FileSystemEventHandler):
             os._exit(1)  # nosec
 
 
+@final
 class FileWatcher:
     """File watcher with auto-reload functionality."""
 

waldiez/ws/server.py

@@ -1,5 +1,14 @@
 # SPDX-License-Identifier: Apache-2.0.
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
+
+# pyright: reportMissingImports=false,reportUnknownVariableType=false
+# pyright: reportPossiblyUnboundVariable=false,reportUnknownMemberType=false
+# pyright: reportUnknownParameterType=false,reportUnknownArgumentType=false
+# pyright: reportAttributeAccessIssue=false,reportAny=false
+# pyright: reportConstantRedefinition=false,reportAssignmentType=false
+# pyright: reportImportCycles=false,reportGeneralTypeIssues=false
+# pylint: disable=import-error,line-too-long,invalid-name
+# flake8: noqa: E501
 """WebSocket server implementation for Waldiez."""
 
 import asyncio
@@ -9,25 +18,63 @@ import signal
 import time
 import traceback
 import uuid
+from collections.abc import Sequence
 from pathlib import Path
-from typing import Any, Sequence
-
-import websockets
-from websockets.exceptions import ConnectionClosed, WebSocketException
+from typing import Any, final
 
 from .client_manager import ClientManager
 from .errors import ErrorHandler, MessageParsingError, ServerOverloadError
 from .models import ConnectionNotification
-from .reloader import create_file_watcher
 from .session_manager import SessionManager
 from .utils import get_available_port, is_port_available
 
+HAS_WATCHDOG = False
+try:
+    from .reloader import FileWatcher, create_file_watcher
+
+    HAS_WATCHDOG = True
+except ImportError:
+
+    class FileWatcher:  # type: ignore[no-redef]
+        """Mock fileWatcher for typing."""
+
+        def start(self) -> None:
+            """Start the watcher."""
+
+        def stop(self) -> None:
+            """Stop the watcher."""
+
+    # pylint: disable=missing-param-doc,missing-return-doc
+    def create_file_watcher(*args: Any, **kwargs: Any) -> FileWatcher:  # type: ignore
+        """No file watcher available."""
+        return FileWatcher(*args, **kwargs)
+
+
+HAS_WEBSOCKETS = False
+try:
+    import websockets  # type: ignore[unused-ignore, unused-import, import-not-found, import-untyped]
+    from websockets.exceptions import (  # type: ignore[unused-ignore, unused-import, import-not-found, import-untyped]
+        ConnectionClosed,
+        WebSocketException,
+    )
+
+    HAS_WEBSOCKETS = True
+except ImportError:
+    from ._mock import (  # type: ignore[no-redef, unused-ignore, unused-import, import-not-found, import-untyped]
+        websockets,
+    )
+
+    ConnectionClosed = websockets.ConnectionClosed  # type: ignore[no-redef,unused-ignore,unused-import,import-not-found,import-untyped,misc]
+    WebSocketException = websockets.WebSocketException  # type: ignore[no-redef,unused-ignore,unused-import,import-not-found,import-untyped,misc]
+
+
 logger = logging.getLogger(__name__)
 
 CWD = Path.cwd()
 
 
 # pylint: disable=too-many-instance-attributes
+@final
 class WaldiezWsServer:
     """WebSocket server for Waldiez."""
 
@@ -35,6 +82,7 @@ class WaldiezWsServer:
         self,
         host: str = "localhost",
         port: int = 8765,
+        auto_reload: bool = False,
         workspace_dir: Path = CWD,
         max_clients: int = 1,
         allowed_origins: Sequence[re.Pattern[str]] | None = None,
@@ -48,11 +96,13 @@ class WaldiezWsServer:
             Server host address
         port : int
             Server port
+        auto_reload : bool
+            Enable automatic reloading of the server on code changes
         workspace_dir : Path
             Path to the workspace directory
         max_clients : int
             Maximum number of concurrent clients (default: 1)
-        allowed_origins : list[str] | None
+        allowed_origins : Sequence[re.Pattern[str]] | None
             List of allowed origins for CORS (default: None)
         ping_interval : float | None
             Ping interval in seconds
@@ -69,6 +119,7 @@ class WaldiezWsServer:
         """
         self.host = host
         self.port = port
+        self.auto_reload = auto_reload and HAS_WATCHDOG
         self.workspace_dir = workspace_dir
         self.max_clients = max_clients
         self.allowed_origins = allowed_origins
@@ -148,11 +199,14 @@ class WaldiezWsServer:
             )
 
             # Message handling loop
+            # noinspection PyTypeChecker
             async for raw_message in websocket:
                 try:
                     # Parse message
                     if isinstance(raw_message, bytes):
-                        message_str = raw_message.decode("utf-8")
+                        message_str = raw_message.decode(
+                            "utf-8", errors="replace"
+                        )
                     else:
                         # noinspection PyUnreachableCode
                         message_str = (
@@ -230,7 +284,7 @@ class WaldiezWsServer:
 
         await self.session_manager.start()
         # Check port availability
-        if not is_port_available(self.port):
+        if not self.auto_reload and not is_port_available(self.port):
             logger.warning("Port %d is not available", self.port)
             self.port = get_available_port()
             logger.info("Using port %d", self.port)
@@ -239,6 +293,7 @@ class WaldiezWsServer:
         # pylint: disable=too-many-try-statements,broad-exception-caught
         try:
             # Create server
+            # noinspection PyTypeChecker
             self.server = await websockets.serve(
                 self._handle_client,
                 self.host,
@@ -373,6 +428,52 @@ class WaldiezWsServer:
         return successful
 
 
+def _get_file_watcher(
+    auto_reload: bool, watch_dirs: set[Path] | None
+) -> FileWatcher | None:
+    file_watcher: FileWatcher | None = None
+    if auto_reload and HAS_WATCHDOG:
+        # pylint: disable=import-outside-toplevel,too-many-try-statements
+        try:
+            # Determine watch directories
+            if watch_dirs is None:
+                project_root = Path(__file__).parents[2]
+
+                # Watch the actual waldiez package directory
+                waldiez_dir = project_root / "waldiez"
+                if waldiez_dir.exists():
+                    watch_dirs = {waldiez_dir}
+                    logger.info(
+                        "Auto-reload: watching waldiez package at %s",
+                        waldiez_dir,
+                    )
+                else:
+                    # Fallback: watch current directory
+                    watch_dirs = {Path.cwd()}
+                    logger.warning(
+                        "Auto-reload: fallback to current directory %s",
+                        Path.cwd(),
+                    )
+
+            # Create file watcher with restart callback
+            file_watcher = create_file_watcher(
+                root_dir=Path(__file__).parents[2],
+                additional_dirs=list(watch_dirs),
+                restart_callback=None,
+            )
+            file_watcher.start()
+            logger.info(
+                "Auto-reload enabled for directories: %s",
+                {str(dir_) for dir_ in watch_dirs},
+            )
+
+        except ImportError as e:
+            logger.warning("Auto-reload not available: %s", e)
+        except Exception as e:  # pylint: disable=broad-exception-caught
+            logger.error("Failed to set up auto-reload: %s", e)
+    return file_watcher
+
+
 async def run_server(
     host: str = "localhost",
     port: int = 8765,
@@ -401,6 +502,7 @@ async def run_server(
     server = WaldiezWsServer(
         host=host,
         port=port,
+        auto_reload=auto_reload,
         workspace_dir=workspace_dir,
         **server_kwargs,
     )
@@ -414,52 +516,19 @@ async def run_server(
 
     # Register signal handlers
     loop = asyncio.get_running_loop()
-    for sig in (signal.SIGTERM, signal.SIGINT):
-        # noinspection PyTypeChecker
-        loop.add_signal_handler(sig, signal_handler)
+    try:
+        for sig in (signal.SIGTERM, signal.SIGINT):
+            # noinspection PyTypeChecker
+            loop.add_signal_handler(sig, signal_handler)
+    except NotImplementedError:
+        # Fallback for Windows
+        signal.signal(signal.SIGINT, lambda s, f: signal_handler())
+        signal.signal(signal.SIGTERM, lambda s, f: signal_handler())
 
     # Set up auto-reload if requested
-    file_watcher = None
-    if auto_reload:
-        # pylint: disable=import-outside-toplevel,too-many-try-statements
-        try:
-            # Determine watch directories
-            if watch_dirs is None:
-                project_root = Path(__file__).parents[2]
-
-                # Watch the actual waldiez package directory
-                waldiez_dir = project_root / "waldiez"
-                if waldiez_dir.exists():
-                    watch_dirs = {waldiez_dir}
-                    logger.info(
-                        "Auto-reload: watching waldiez package at %s",
-                        waldiez_dir,
-                    )
-                else:
-                    # Fallback: watch current directory
-                    watch_dirs = {Path.cwd()}
-                    logger.warning(
-                        "Auto-reload: fallback to current directory %s",
-                        Path.cwd(),
-                    )
-
-            # Create file watcher with restart callback
-            file_watcher = create_file_watcher(
-                root_dir=Path(__file__).parents[2],
-                additional_dirs=list(watch_dirs),
-                restart_callback=None,
-            )
-            file_watcher.start()
-            logger.info(
-                "Auto-reload enabled for directories: %s",
-                {str(dir_) for dir_ in watch_dirs},
-            )
-
-        except ImportError as e:
-            logger.warning("Auto-reload not available: %s", e)
-        except Exception as e:  # pylint: disable=broad-exception-caught
-            logger.error("Failed to set up auto-reload: %s", e)
-
+    file_watcher = _get_file_watcher(
+        auto_reload=auto_reload, watch_dirs=watch_dirs
+    )
     try:
         # Start server
         await server.start()

waldiez/ws/session_manager.py

@@ -7,13 +7,14 @@ import logging
 import time
 from collections import defaultdict
 from pathlib import Path
-from typing import Any
+from typing import Any, final
 
 from .models import ExecutionMode, SessionState, WorkflowSession, WorkflowStatus
 from .session_stats import SessionStats
 
 
 # noinspection TryExceptPass,PyBroadException
+@final
 class SessionManager:
     """Manage workflow sessions across WebSocket clients."""
 
@@ -67,7 +68,7 @@ class SessionManager:
         self,
         session_id: str,
         client_id: str,
-        execution_mode: ExecutionMode,
+        mode: ExecutionMode,
         runner: Any = None,
         temp_file: Path | None = None,
         metadata: dict[str, Any] | None = None,
@@ -80,7 +81,7 @@ class SessionManager:
             The ID of the session to create
         client_id : str
             The ID of the client creating the session
-        execution_mode : ExecutionMode
+        mode : ExecutionMode
             The execution mode for the session
         runner : Any, optional
             The runner to use for the session
@@ -103,7 +104,7 @@ class SessionManager:
             session_id=session_id,
             client_id=client_id,
             status=WorkflowStatus.IDLE,
-            execution_mode=execution_mode,
+            mode=mode,
             metadata=metadata or {},
         )
         session = WorkflowSession(
@@ -180,9 +181,7 @@ class SessionManager:
             self._recompute_stats_locked()
             return True
 
-    async def get_session_execution_mode(
-        self, session_id: str
-    ) -> ExecutionMode | None:
+    async def get_session_mode(self, session_id: str) -> ExecutionMode | None:
         """Get the execution mode of a workflow session.
 
         Parameters
@@ -196,8 +195,8 @@ class SessionManager:
             The execution mode of the session, or None if it does not exist
         """
         async with self._lock:
-            s = self._sessions.get(session_id)
-            return s.execution_mode if s else None
+            session = self._sessions.get(session_id)
+            return session.mode if session else None
 
     async def remove_session(self, session_id: str) -> bool:
         """Remove a workflow session by ID.

waldiez/ws/session_stats.py

@@ -65,7 +65,7 @@ class SessionStats(BaseModel):
 
             client_count = self.sessions_by_client.get(state.client_id, 0)
             self.sessions_by_client[state.client_id] = client_count + 1
-            mode_key = state.execution_mode.value
+            mode_key = state.mode.value
             mode_count = self.sessions_by_mode.get(mode_key, 0)
             self.sessions_by_mode[mode_key] = mode_count + 1
             status_key = state.status.value

waldiez/ws/utils.py

@@ -1,5 +1,10 @@
 # SPDX-License-Identifier: Apache-2.0.
 # Copyright (c) 2024 - 2025 Waldiez and contributors.
+# pylint: disable=import-error,line-too-long
+# pyright: reportUnknownMemberType=false,reportUnknownVariableType=false
+# pyright: reportUnknownArgumentType=false,reportAttributeAccessIssue=false
+# pyright: reportGeneralTypeIssues=false,reportAny=false
+# flake8: noqa: E501
 """Utilities for WebSocket server management."""
 
 import asyncio
@@ -9,9 +14,13 @@ import socket
 import time
 from contextlib import closing
 from dataclasses import asdict, dataclass
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, final
+
+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]
 
-import websockets
 
 if TYPE_CHECKING:
     from .server import WaldiezWsServer
@@ -74,6 +83,7 @@ class ServerHealth:
         return my_dict
 
 
+@final
 class HealthChecker:
     """Health checker for WebSocket server."""
 
@@ -184,6 +194,7 @@ class HealthChecker:
 
 
 # noinspection PyBroadException
+@final
 class ConnectionManager:
     """Manages WebSocket connections and provides utilities."""
 
@@ -329,7 +340,10 @@ async def test_server_connection(
     try:
         uri = f"ws://{host}:{port}"
 
-        async with websockets.connect(uri, ping_interval=None) as websocket:
+        async with websockets.connect(
+            uri,
+            ping_interval=None,
+        ) as websocket:
             # Send ping message
             ping_msg = {"action": "ping"}
             await websocket.send(json.dumps(ping_msg))
@@ -350,6 +364,7 @@ async def test_server_connection(
     return result
 
 
+# noinspection PyBroadException
 def is_port_available(port: int) -> bool:
     """Check if the port is available.
 
@@ -363,13 +378,26 @@ def is_port_available(port: int) -> bool:
     bool
         True if port is available
     """
+    # Check IPv4
     try:
         with closing(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as sock:
             sock.bind(("", port))
-            return True
-    except OSError:
+    except BaseException:  # pylint: disable=broad-exception-caught
         return False
 
+    # Check IPv6
+    try:  # pragma: no cover
+        with closing(
+            socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
+        ) as sock:
+            # Disable dual-stack to only check IPv6
+            sock.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, 1)
+            sock.bind(("", port))
+    except BaseException:  # pylint: disable=broad-exception-caught
+        return False
+
+    return True
+
 
 def get_available_port() -> int:
     """Get an available port.