wesktop 0.3.2__tar.gz → 0.4.0__tar.gz

wesktop-0.4.0/.rlsbl/changes/.validated

@@ -0,0 +1 @@
+cafbbdcedbfae32677c2f02fd5bddfdd082cc628

wesktop-0.4.0/.rlsbl/changes/0.4.0.jsonl

@@ -0,0 +1,5 @@
+{"commits":["be870a9f1bf8e89d54b819e5bc08191a0e9bc6f5"],"user_facing":true,"description":"**New feature.** `run()` accepts a `js_api` parameter, passed through to pywebview's `create_window()` for exposing Python methods to JavaScript.","type":"feature"}
+{"commits":["6b2f343b0a419b86a68bbe1774243b803ffa7ffc"],"user_facing":false}
+{"commits":["81c19888eb4ab2945245f841802b0a537fd3f90d"],"user_facing":false}
+{"commits":["a9108962c657aec782b52a67fc6a45cd2dfb346f"],"user_facing":true,"description":"**New feature.** `dev()` starts a Vite dev server alongside the wesktop server in a single command, with ViteDevProxy for unified port access and automatic Vite lifecycle management.","type":"feature"}
+{"commits":["e16c8adee976582c1a68d94c16089598eb13ffaf"],"user_facing":false}

wesktop-0.4.0/.rlsbl/changes/0.4.0.md

@@ -0,0 +1,6 @@
+## 0.4.0
+
+### Features
+
+- **New feature.** `run()` accepts a `js_api` parameter, passed through to pywebview's `create_window()` for exposing Python methods to JavaScript.
+- **New feature.** `dev()` starts a Vite dev server alongside the wesktop server in a single command, with ViteDevProxy for unified port access and automatic Vite lifecycle management.

wesktop-0.4.0/.rlsbl/releases/v0.4.0.toml

@@ -0,0 +1,3 @@
+bump = "minor"
+include = ["pypi"]
+exclude = []

{wesktop-0.3.2 → wesktop-0.4.0}/.strictcli/schema.json

@@ -1,6 +1,6 @@
 {
   "name": "wesktop",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "help": "A Python framework for building web-based desktop applications",
   "env_prefix": null,
   "config": true,

{wesktop-0.3.2 → wesktop-0.4.0}/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 # Changelog
 
+## 0.4.0
+
+### Features
+
+- **New feature.** `run()` accepts a `js_api` parameter, passed through to pywebview's `create_window()` for exposing Python methods to JavaScript.
+- **New feature.** `dev()` starts a Vite dev server alongside the wesktop server in a single command, with ViteDevProxy for unified port access and automatic Vite lifecycle management.
+
 ## 0.3.2
 
 ### Features

{wesktop-0.3.2 → wesktop-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wesktop
-Version: 0.3.2
+Version: 0.4.0
 Summary: A Python framework for building web-based desktop applications
 Author-email: smm-h <smmh72@gmail.com>
 License-Expression: MIT

{wesktop-0.3.2 → wesktop-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "wesktop"
-version = "0.3.2"
+version = "0.4.0"
 description = "A Python framework for building web-based desktop applications"
 requires-python = ">=3.11"
 license = "MIT"

{wesktop-0.3.2 → wesktop-0.4.0}/src/wesktop/__init__.py

@@ -192,6 +192,7 @@ __all__ = [
     "status",
     "ServerStatus",
     "run",
+    "dev",
     # features
     "FeatureFlags",
     # audit
@@ -275,6 +276,7 @@ def run(
     name: str = "WESKTOP",
     pre_serve: Callable[[], None] | None = None,
     reload: bool = False,
+    js_api: object | None = None,
 ) -> None:
     """Start server + native desktop window."""
     from wesktop.desktop import run as _run
@@ -291,6 +293,7 @@ def run(
         name=name,
         pre_serve=pre_serve,
         reload=reload,
+        js_api=js_api,
     )
 
 
@@ -332,3 +335,29 @@ def status(pid_path: Path, health_url: str | None = None) -> ServerStatus:
     from wesktop.server import status as _status
 
     return _status(pid_path, health_url=health_url)
+
+
+def dev(
+    target: str | Callable,
+    *,
+    vite_command: str = "npm run dev",
+    vite_port: int = 5173,
+    host: str | None = None,
+    port: int | None = None,
+    pid_path: Path | None = None,
+    name: str = "WESKTOP",
+    pre_serve: Callable[[], None] | None = None,
+) -> None:
+    """Development mode: Vite + server. See :func:`wesktop.dev.dev`."""
+    from wesktop.dev import dev as _dev
+
+    _dev(
+        target,
+        vite_command=vite_command,
+        vite_port=vite_port,
+        host=host,
+        port=port,
+        pid_path=pid_path,
+        name=name,
+        pre_serve=pre_serve,
+    )

{wesktop-0.3.2 → wesktop-0.4.0}/src/wesktop/desktop.py

@@ -19,6 +19,7 @@ def run(
     name: str = "WESKTOP",
     pre_serve: Callable[[], None] | None = None,
     reload: bool = False,
+    js_api: object | None = None,
 ) -> None:
     """Start server + open native desktop window. Blocks until window closes."""
     from wesktop.server import serve
@@ -42,6 +43,7 @@ def run(
         url=url,
         width=width,
         height=height,
+        js_api=js_api,
     )
 
     webview.start(icon=icon)

wesktop-0.4.0/src/wesktop/dev.py

@@ -0,0 +1,95 @@
+"""Development mode: Vite + wesktop server in a single command."""
+
+from __future__ import annotations
+
+import importlib
+import logging
+import socket
+import subprocess
+import time
+from pathlib import Path
+from typing import Callable
+
+logger = logging.getLogger(__name__)
+
+
+def dev(
+    target: str | Callable,
+    *,
+    vite_command: str = "npm run dev",
+    vite_port: int = 5173,
+    host: str | None = None,
+    port: int | None = None,
+    pid_path: Path | None = None,
+    name: str = "WESKTOP",
+    pre_serve: Callable[[], None] | None = None,
+) -> None:
+    """Start Vite dev server + wesktop ASGI server for development.
+
+    Spawns Vite as a subprocess, waits for it to be ready, then starts
+    the wesktop server with ViteDevProxy middleware. All frontend
+    requests are proxied to Vite (with HMR), API requests are handled
+    by the wesktop router. Kills Vite on shutdown.
+    """
+    from wesktop.middleware import ViteDevProxy
+    from wesktop.server import serve
+
+    # Resolve the target to a callable ASGI app
+    if isinstance(target, str):
+        module_path, attr = target.rsplit(":", 1)
+        module = importlib.import_module(module_path)
+        app = getattr(module, attr)
+    else:
+        app = target
+
+    # Wrap with ViteDevProxy
+    wrapped = ViteDevProxy(app, vite_port=vite_port)
+
+    # Spawn Vite
+    logger.info("Starting Vite dev server: %s", vite_command)
+    vite_proc = subprocess.Popen(
+        vite_command,
+        shell=True,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.PIPE,
+    )
+
+    # Wait for Vite to be ready
+    deadline = time.monotonic() + 15  # 15s timeout
+    ready = False
+    while time.monotonic() < deadline:
+        try:
+            sock = socket.create_connection(("127.0.0.1", vite_port), timeout=1)
+            sock.close()
+            ready = True
+            break
+        except (ConnectionRefusedError, OSError):
+            if vite_proc.poll() is not None:
+                stderr = vite_proc.stderr.read().decode() if vite_proc.stderr else ""
+                raise RuntimeError(f"Vite process exited with code {vite_proc.returncode}: {stderr}")
+            time.sleep(0.3)
+
+    if not ready:
+        vite_proc.terminate()
+        raise RuntimeError(f"Vite dev server did not start within 15s on port {vite_port}")
+
+    logger.info("Vite ready on port %d", vite_port)
+
+    try:
+        serve(
+            wrapped,
+            foreground=True,
+            host=host,
+            port=port,
+            pid_path=pid_path,
+            name=name,
+            pre_serve=pre_serve,
+        )
+    finally:
+        logger.info("Stopping Vite dev server")
+        vite_proc.terminate()
+        try:
+            vite_proc.wait(timeout=5)
+        except subprocess.TimeoutExpired:
+            vite_proc.kill()
+            vite_proc.wait()

{wesktop-0.3.2 → wesktop-0.4.0}/tests/test_desktop.py

@@ -48,6 +48,7 @@ def test_run_calls_webview(
         url=f"http://127.0.0.1:{port}",
         width=800,
         height=600,
+        js_api=None,
     )
 
     # webview.start() called to enter the event loop with icon=None
@@ -93,6 +94,87 @@ def test_run_without_icon(
     mock_wv_start.assert_called_once_with(icon=None)
 
 
+@patch("webview.start")
+@patch("webview.create_window")
+@patch("wesktop.server.serve")
+def test_run_with_js_api(
+    mock_serve: MagicMock,
+    mock_create_window: MagicMock,
+    mock_wv_start: MagicMock,
+) -> None:
+    """js_api object is forwarded to webview.create_window(js_api=...)."""
+    port = _free_port()
+    mock_serve.return_value = f"http://127.0.0.1:{port}"
+
+    class MyAPI:
+        def greet(self, name: str) -> str:
+            return f"Hello, {name}"
+
+    api = MyAPI()
+
+    from wesktop.desktop import run
+
+    run("myapp:app", host="127.0.0.1", port=port, js_api=api)
+
+    mock_create_window.assert_called_once_with(
+        title="wesktop",
+        url=f"http://127.0.0.1:{port}",
+        width=1280,
+        height=800,
+        js_api=api,
+    )
+
+
+@patch("webview.start")
+@patch("webview.create_window")
+@patch("wesktop.server.serve")
+def test_run_without_js_api(
+    mock_serve: MagicMock,
+    mock_create_window: MagicMock,
+    mock_wv_start: MagicMock,
+) -> None:
+    """When no js_api is provided, webview.create_window(js_api=None) is called."""
+    port = _free_port()
+    mock_serve.return_value = f"http://127.0.0.1:{port}"
+
+    from wesktop.desktop import run
+
+    run("myapp:app", host="127.0.0.1", port=port)
+
+    mock_create_window.assert_called_once_with(
+        title="wesktop",
+        url=f"http://127.0.0.1:{port}",
+        width=1280,
+        height=800,
+        js_api=None,
+    )
+
+
+@patch("webview.start")
+@patch("webview.create_window")
+@patch("wesktop.server.serve")
+def test_run_js_api_via_wrapper(
+    mock_serve: MagicMock,
+    mock_create_window: MagicMock,
+    mock_wv_start: MagicMock,
+) -> None:
+    """js_api passes through the wesktop.run() wrapper to desktop.run()."""
+    port = _free_port()
+    mock_serve.return_value = f"http://127.0.0.1:{port}"
+
+    class BridgeAPI:
+        def ping(self) -> str:
+            return "pong"
+
+    api = BridgeAPI()
+
+    wesktop.run("myapp:app", host="127.0.0.1", port=port, js_api=api)
+
+    mock_create_window.assert_called_once()
+    call_kwargs = mock_create_window.call_args[1]
+    assert call_kwargs["js_api"] is api
+
+
 @patch("wesktop.server.Granian")
 def test_serve_calls_granian(mock_granian_cls: MagicMock) -> None:
     """wesktop.serve() delegates to the server module with correct params."""

wesktop-0.4.0/tests/test_dev.py

@@ -0,0 +1,279 @@
+from __future__ import annotations
+
+import socket
+import subprocess
+from unittest.mock import MagicMock, call, patch
+
+import pytest
+
+
+def _fake_app(scope, receive, send):
+    """Dummy ASGI app for testing."""
+    pass
+
+
+class TestDevSpawnsVite:
+    """dev() spawns a subprocess with the vite_command."""
+
+    @patch("wesktop.server.serve")
+    @patch("socket.create_connection")
+    @patch("subprocess.Popen")
+    def test_spawns_vite_subprocess(
+        self,
+        mock_popen: MagicMock,
+        mock_connect: MagicMock,
+        mock_serve: MagicMock,
+    ) -> None:
+        proc = MagicMock()
+        proc.poll.return_value = None
+        mock_popen.return_value = proc
+
+        # create_connection succeeds immediately (Vite is "ready")
+        mock_sock = MagicMock()
+        mock_connect.return_value = mock_sock
+
+        from wesktop.dev import dev
+
+        dev(_fake_app, host="127.0.0.1", port=8000)
+
+        mock_popen.assert_called_once_with(
+            "npm run dev",
+            shell=True,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.PIPE,
+        )
+
+    @patch("wesktop.server.serve")
+    @patch("socket.create_connection")
+    @patch("subprocess.Popen")
+    def test_custom_vite_command(
+        self,
+        mock_popen: MagicMock,
+        mock_connect: MagicMock,
+        mock_serve: MagicMock,
+    ) -> None:
+        proc = MagicMock()
+        proc.poll.return_value = None
+        mock_popen.return_value = proc
+        mock_connect.return_value = MagicMock()
+
+        from wesktop.dev import dev
+
+        dev(_fake_app, vite_command="pnpm dev", host="127.0.0.1", port=8000)
+
+        mock_popen.assert_called_once_with(
+            "pnpm dev",
+            shell=True,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.PIPE,
+        )
+
+
+class TestDevWrapsWithViteDevProxy:
+    """dev() wraps the app with ViteDevProxy before passing to serve()."""
+
+    @patch("wesktop.server.serve")
+    @patch("socket.create_connection")
+    @patch("subprocess.Popen")
+    def test_wraps_app_with_proxy(
+        self,
+        mock_popen: MagicMock,
+        mock_connect: MagicMock,
+        mock_serve: MagicMock,
+    ) -> None:
+        proc = MagicMock()
+        proc.poll.return_value = None
+        mock_popen.return_value = proc
+        mock_connect.return_value = MagicMock()
+
+        from wesktop.dev import dev
+        from wesktop.middleware import ViteDevProxy
+
+        dev(_fake_app, vite_port=3000, host="127.0.0.1", port=8000)
+
+        # serve() was called with a ViteDevProxy wrapping the original app
+        args, kwargs = mock_serve.call_args
+        wrapped = args[0]
+        assert isinstance(wrapped, ViteDevProxy)
+        assert wrapped.app is _fake_app
+        assert wrapped.vite_port == 3000
+
+
+class TestDevCallsServe:
+    """dev() calls serve() with the wrapped app and foreground=True."""
+
+    @patch("wesktop.server.serve")
+    @patch("socket.create_connection")
+    @patch("subprocess.Popen")
+    def test_calls_serve_foreground(
+        self,
+        mock_popen: MagicMock,
+        mock_connect: MagicMock,
+        mock_serve: MagicMock,
+    ) -> None:
+        proc = MagicMock()
+        proc.poll.return_value = None
+        mock_popen.return_value = proc
+        mock_connect.return_value = MagicMock()
+
+        from wesktop.dev import dev
+
+        dev(_fake_app, host="127.0.0.1", port=9000, name="MYAPP")
+
+        mock_serve.assert_called_once()
+        _, kwargs = mock_serve.call_args
+        assert kwargs["foreground"] is True
+        assert kwargs["host"] == "127.0.0.1"
+        assert kwargs["port"] == 9000
+        assert kwargs["name"] == "MYAPP"
+        assert kwargs["pid_path"] is None
+        assert kwargs["pre_serve"] is None
+
+
+class TestDevTerminatesVite:
+    """dev() terminates the Vite process on shutdown."""
+
+    @patch("wesktop.server.serve")
+    @patch("socket.create_connection")
+    @patch("subprocess.Popen")
+    def test_terminates_vite_on_normal_exit(
+        self,
+        mock_popen: MagicMock,
+        mock_connect: MagicMock,
+        mock_serve: MagicMock,
+    ) -> None:
+        proc = MagicMock()
+        proc.poll.return_value = None
+        mock_popen.return_value = proc
+        mock_connect.return_value = MagicMock()
+
+        from wesktop.dev import dev
+
+        dev(_fake_app, host="127.0.0.1", port=8000)
+
+        proc.terminate.assert_called_once()
+        proc.wait.assert_called_once_with(timeout=5)
+
+    @patch("wesktop.server.serve", side_effect=KeyboardInterrupt)
+    @patch("socket.create_connection")
+    @patch("subprocess.Popen")
+    def test_terminates_vite_on_exception(
+        self,
+        mock_popen: MagicMock,
+        mock_connect: MagicMock,
+        mock_serve: MagicMock,
+    ) -> None:
+        proc = MagicMock()
+        proc.poll.return_value = None
+        mock_popen.return_value = proc
+        mock_connect.return_value = MagicMock()
+
+        from wesktop.dev import dev
+
+        with pytest.raises(KeyboardInterrupt):
+            dev(_fake_app, host="127.0.0.1", port=8000)
+
+        proc.terminate.assert_called_once()
+
+    @patch("wesktop.server.serve")
+    @patch("socket.create_connection")
+    @patch("subprocess.Popen")
+    def test_kills_vite_if_terminate_times_out(
+        self,
+        mock_popen: MagicMock,
+        mock_connect: MagicMock,
+        mock_serve: MagicMock,
+    ) -> None:
+        proc = MagicMock()
+        proc.poll.return_value = None
+        proc.wait.side_effect = [subprocess.TimeoutExpired(cmd="npm", timeout=5), None]
+        mock_popen.return_value = proc
+        mock_connect.return_value = MagicMock()
+
+        from wesktop.dev import dev
+
+        dev(_fake_app, host="127.0.0.1", port=8000)
+
+        proc.terminate.assert_called_once()
+        proc.kill.assert_called_once()
+        # wait called twice: once with timeout (raises), once after kill
+        assert proc.wait.call_count == 2
+
+
+class TestDevViteFailsToStart:
+    """dev() raises RuntimeError if Vite fails to start."""
+
+    @patch("socket.create_connection", side_effect=ConnectionRefusedError)
+    @patch("subprocess.Popen")
+    def test_raises_if_vite_exits_immediately(
+        self,
+        mock_popen: MagicMock,
+        mock_connect: MagicMock,
+    ) -> None:
+        proc = MagicMock()
+        proc.poll.return_value = 1  # process exited
+        proc.returncode = 1
+        proc.stderr = MagicMock()
+        proc.stderr.read.return_value = b"vite: command not found"
+        mock_popen.return_value = proc
+
+        from wesktop.dev import dev
+
+        with pytest.raises(RuntimeError, match="Vite process exited with code 1"):
+            dev(_fake_app, host="127.0.0.1", port=8000)
+
+    @patch("time.monotonic")
+    @patch("time.sleep")
+    @patch("socket.create_connection", side_effect=ConnectionRefusedError)
+    @patch("subprocess.Popen")
+    def test_raises_if_vite_never_ready(
+        self,
+        mock_popen: MagicMock,
+        mock_connect: MagicMock,
+        mock_sleep: MagicMock,
+        mock_monotonic: MagicMock,
+    ) -> None:
+        proc = MagicMock()
+        proc.poll.return_value = None  # process still running but never ready
+        mock_popen.return_value = proc
+
+        # Simulate time passing beyond the 15s deadline
+        mock_monotonic.side_effect = [0.0, 0.0, 16.0]
+
+        from wesktop.dev import dev
+
+        with pytest.raises(RuntimeError, match="did not start within 15s"):
+            dev(_fake_app, host="127.0.0.1", port=8000)
+
+        proc.terminate.assert_called_once()
+
+
+class TestDevStringTarget:
+    """dev() resolves string targets via importlib."""
+
+    @patch("wesktop.server.serve")
+    @patch("socket.create_connection")
+    @patch("subprocess.Popen")
+    def test_resolves_string_target(
+        self,
+        mock_popen: MagicMock,
+        mock_connect: MagicMock,
+        mock_serve: MagicMock,
+    ) -> None:
+        proc = MagicMock()
+        proc.poll.return_value = None
+        mock_popen.return_value = proc
+        mock_connect.return_value = MagicMock()
+
+        from wesktop.dev import dev
+        from wesktop.middleware import ViteDevProxy
+
+        # Use a real importable module:attribute
+        dev("wesktop.asgi:create_app", host="127.0.0.1", port=8000)
+
+        args, kwargs = mock_serve.call_args
+        wrapped = args[0]
+        assert isinstance(wrapped, ViteDevProxy)
+        # The resolved app should be the actual create_app function
+        from wesktop.asgi import create_app
+        assert wrapped.app is create_app

{wesktop-0.3.2 → wesktop-0.4.0}/tests/test_phase4.py

@@ -70,8 +70,13 @@ class TestJWTTokens:
     def test_tampered_token_returns_none(self):
         secret = "test-secret-key-that-is-at-least-thirty-two-bytes-long"
         token = create_token("alice", "admin", secret)
-        # Flip a character in the signature
-        tampered = token[:-1] + ("A" if token[-1] != "A" else "B")
+        # Flip a character in the middle of the signature (not the end,
+        # where base64url padding bits can absorb the change)
+        parts = token.split(".")
+        sig = list(parts[2])
+        mid = len(sig) // 2
+        sig[mid] = "X" if sig[mid] != "X" else "Y"
+        tampered = parts[0] + "." + parts[1] + "." + "".join(sig)
         assert verify_token(tampered, secret) is None
 
     def test_wrong_secret_returns_none(self):

{wesktop-0.3.2 → wesktop-0.4.0}/uv.lock

@@ -826,7 +826,7 @@ wheels = [
 
 [[package]]
 name = "wesktop"
-version = "0.3.2"
+version = "0.4.0"
 source = { editable = "." }
 dependencies = [
     { name = "bcrypt" },

wesktop-0.3.2/.rlsbl/changes/.validated

@@ -1 +0,0 @@
-1cf0504c7c65adf18fb01877fd2cc105334f46f5