plesty-server 0.2.2__tar.gz → 0.2.4__tar.gz

{plesty_server-0.2.2 → plesty_server-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: plesty-server
-Version: 0.2.2
+Version: 0.2.4
 Summary: The PLESTY bench application: installs, runs and field-tests device servers.
 Project-URL: Homepage, https://gitlab.com/plesty/core/plesty-bench
 Project-URL: Documentation, https://plesty.gitlab.io/core/plesty-bench/
@@ -11,7 +11,7 @@ License-File: LICENSE
 License-File: LICENSES/LGPL-3.0-or-later.txt
 Requires-Python: >=3.12
 Requires-Dist: click>=8.1
-Requires-Dist: plesty-bench==0.2.2
+Requires-Dist: plesty-bench==0.2.4
 Requires-Dist: plesty-lib>=0.3.3
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: pyzmq>=26

{plesty_server-0.2.2 → plesty_server-0.2.4}/plesty/server/assets/console.qss

@@ -112,6 +112,20 @@ QTableWidget::item {
   padding: 4px 8px;
 }
 
+/* Styling ::item at all hands item painting to the stylesheet, and the view's
+   selection-background-color above stops being drawn with it: a selected row
+   then keeps only a sliver of highlight at the edge of each cell. The rule has
+   to be repeated here. :!active keeps the row marked once focus moves on —
+   picking a module in the catalogue and then clicking Install must not look
+   like nothing is picked. */
+QTableWidget::item:selected,
+QTableView::item:selected,
+QTableWidget::item:selected:!active,
+QTableView::item:selected:!active {
+  background: {{selection}};
+  color: {{text_bright}};
+}
+
 /* State chip text colours — the window-chrome language of plesty.net. */
 #stateChip {
   font-size: 12px;
@@ -251,6 +265,28 @@ QCheckBox::indicator:checked {
   border-color: {{cyan}};
 }
 
+/* The radio indicator needs the same treatment as the checkbox: under a
+   stylesheet Windows stops theming it natively, and against the dark
+   background an unstyled indicator is invisible — the "Source — one of"
+   choice then looks unselectable. Round, so it reads as a radio. */
+
+QRadioButton::indicator {
+  width: 14px;
+  height: 14px;
+  border: 1px solid {{line_strong}};
+  border-radius: 8px;
+  background: {{surface2}};
+}
+
+QRadioButton::indicator:checked {
+  background: {{cyan}};
+  border-color: {{cyan}};
+}
+
+QRadioButton::indicator:disabled {
+  border-color: {{line}};
+}
+
 QGroupBox {
   border: 1px solid {{line}};
   border-radius: 8px;

{plesty_server-0.2.2 → plesty_server-0.2.4}/plesty/server/host.py

@@ -22,10 +22,13 @@ Rules of the module:
 from __future__ import annotations
 
 import os
+import shlex
 import signal
 import stat
 import subprocess
 import sys
+import threading
+import time
 from collections.abc import Callable
 from pathlib import Path
 from typing import Any
@@ -63,22 +66,91 @@ def executable(name: str, platform: str = sys.platform) -> str:
     return f"{name}.exe" if windows(platform) else name
 
 
+def split_args(text: str, platform: str = sys.platform) -> list[str]:
+    r"""Split a written command line into arguments the way *platform* reads it.
+
+    POSIX: :func:`shlex.split` — backslash escapes the next character and
+    quotes group; both are removed.
+    Windows: backslash is the path separator and escapes nothing. POSIX
+    splitting eats it silently, so ``--config C:\lab\dev.ini`` arrives as
+    ``C:labdev.ini`` and the device is handed a path that cannot exist. Only
+    quotes group here, and they are stripped as POSIX splitting strips them.
+
+    Args:
+        text: The command line as the fleet file or the console spells it.
+        platform: The host to split for; defaults to this one.
+    """
+    if not windows(platform):
+        return shlex.split(text)
+    lexer = shlex.shlex(text, posix=False)
+    lexer.whitespace_split = True
+    lexer.commenters = ""
+    return [_unquote(token) for token in lexer]
+
+
+def _unquote(token: str) -> str:
+    """Strip one surrounding pair of quotes, as POSIX splitting would."""
+    for quote in ('"', "'"):
+        if len(token) >= 2 and token.startswith(quote) and token.endswith(quote):
+            return token[1:-1]
+    return token
+
+
+def link_or_copy(target: Path, link: Path) -> None:
+    """Make *link* stand in for the file *target*.
+
+    POSIX: a symlink.
+    Windows: creating one needs ``SeCreateSymbolicLinkPrivilege``, held by an
+    elevated shell or a machine in Developer Mode and by neither a bench nor a
+    CI runner — the attempt raises ``WinError 1314``. The file is copied
+    instead, which resolves to the same interpreter or program.
+
+    Args:
+        target: The existing file.
+        link: The path to create.
+    """
+    import shutil
+
+    if windows():  # pragma: no cover — exercised on the Windows CI job
+        shutil.copy2(target, link)
+        return
+    link.symlink_to(target)
+
+
 def remove_tree(path: Path) -> None:
     """Delete a directory tree even when git left read-only files in it.
 
     Windows: :func:`shutil.rmtree` refuses read-only files, and git marks
     everything under ``.git/objects`` read-only — so a checkout could not be
-    uninstalled where a PyPI venv could. The retry clears the bit first.
-    POSIX: the owner may delete read-only files; the retry is never reached.
+    uninstalled where a PyPI venv could. The retry clears the bit first. A
+    file that is *open* elsewhere cannot be deleted at all here, where POSIX
+    unlinks it happily: an antivirus or the search indexer holds one for a
+    moment (the retry waits that out), a running device server holds its own
+    interpreter for as long as it runs (:exc:`PermissionError` reaches the
+    caller, which is the honest answer — the device has to be stopped first).
+    POSIX: the owner may delete read-only and open files; no retry is reached.
     """
     import shutil
 
     shutil.rmtree(path, onexc=_clear_readonly_and_retry)
 
 
+#: Waits between attempts to delete a file another process is holding open.
+_RETRY_DELAYS = (0.1, 0.3, 0.6)
+
+
 def _clear_readonly_and_retry(func: Callable[[str], None], path: str, _exc: BaseException) -> None:
-    os.chmod(path, stat.S_IWRITE)
-    func(path)
+    try:
+        os.chmod(path, stat.S_IWRITE)
+    except OSError:  # gone already, or not ours to change — let *func* say so
+        pass
+    for delay in _RETRY_DELAYS:
+        try:
+            func(path)
+            return
+        except PermissionError:
+            time.sleep(delay)
+    func(path)  # out of patience: raise whatever it raises now
 
 
 # --------------------------------------------------------------------------- #
@@ -108,6 +180,105 @@ def spawn_kwargs(new_group: bool = False) -> dict[str, Any]:
     return {"creationflags": flags}  # pragma: no cover
 
 
+def interruptible_kwargs() -> dict[str, Any]:
+    """:mod:`subprocess` keyword arguments for a child *this* process must be able to stop.
+
+    Windows: ``CREATE_NEW_PROCESS_GROUP`` makes the child the leader of a
+    group that can be sent ``CTRL_BREAK_EVENT``. It deliberately does *not*
+    add ``CREATE_NO_WINDOW``: that would give the child a console of its own,
+    and a console control event cannot cross from one console to another. The
+    child inherits ours instead — already invisible, because the waiter itself
+    was started with ``CREATE_NO_WINDOW`` — so no window appears either way.
+    POSIX: nothing; the child stays in our group and ``send_signal`` reaches it.
+    """
+    if not windows():
+        return {}
+    return {"creationflags": subprocess.CREATE_NEW_PROCESS_GROUP}  # type: ignore[attr-defined]
+
+
+#: How often the Windows waiter looks for the stop file (seconds).
+_STOP_POLL = 0.2
+
+
+def request_stop(pid: int, stop_file: Path) -> None:
+    """Ask the waiter *pid* to shut its command down cleanly.
+
+    POSIX: ``SIGINT``, which the waiter forwards to the command.
+    Windows: no console control event can reach it. The waiter runs on an
+    invisible console of its own and the process asking may have no console at
+    all — ``plesty-server-gui.exe`` is a GUI binary — and
+    ``GenerateConsoleCtrlEvent`` only reaches the caller's own console. It
+    would fail silently and the bench would fall through to killing every
+    device outright, so the waiter watches for *stop_file* instead
+    (:func:`watch_for_stop`) and creating it is the request.
+
+    Args:
+        pid: The waiter that owns the command.
+        stop_file: The file that waiter watches.
+    """
+    if windows():  # pragma: no cover — exercised on the Windows CI job
+        stop_file.parent.mkdir(parents=True, exist_ok=True)
+        stop_file.write_text("stop", encoding="utf-8")
+        return
+    _signal(pid, signal.SIGINT)
+
+
+def watch_for_stop(stop_file: Path, on_stop: Callable[[], None]) -> None:
+    """Call *on_stop* when *stop_file* appears — the Windows half of a clean stop.
+
+    POSIX: returns at once. A stop arrives as a signal there, and the handler
+    :func:`forward_signals` installed does the same work.
+    Windows: starts a daemon thread polling for the file, so the waiter can be
+    asked to stop by a process that shares no console with it.
+
+    Args:
+        stop_file: The file whose appearance means "stop".
+        on_stop: Run once, on the watching thread, when it appears.
+    """
+    if not windows():
+        return
+
+    def poll() -> None:  # pragma: no cover — exercised on the Windows CI job
+        while not stop_file.exists():
+            time.sleep(_STOP_POLL)
+        on_stop()
+
+    threading.Thread(target=poll, daemon=True).start()  # pragma: no cover
+
+
+def stop_signal() -> int:
+    """The signal a clean stop arrives as, for a process that must catch one.
+
+    POSIX: ``SIGINT``.
+    Windows: ``SIGBREAK``. ``CTRL_BREAK_EVENT`` is the only console control
+    event that can be aimed at a single process group — ``CTRL_C_EVENT`` is
+    disabled outright for a group made with ``CREATE_NEW_PROCESS_GROUP`` — so
+    it is what :func:`deliver_stop` sends, and Python delivers it as
+    ``SIGBREAK``. A server that only handles ``SIGINT`` is killed outright
+    here (exit ``0xC000013A``) instead of closing its device.
+    """
+    if windows():  # pragma: no cover — exercised on the Windows CI job
+        return int(signal.SIGBREAK)  # type: ignore[attr-defined]
+    return int(signal.SIGINT)
+
+
+def deliver_stop(child: subprocess.Popen[bytes]) -> None:
+    """Ask *child* to end cleanly, from the process that started it.
+
+    POSIX: ``SIGINT``.
+    Windows: ``CTRL_BREAK_EVENT`` to the group the child leads — it shares
+    this process's console, which is what :func:`interruptible_kwargs` buys.
+    A child that has already gone is not an error.
+    """
+    try:
+        if windows():  # pragma: no cover — exercised on the Windows CI job
+            os.kill(child.pid, signal.CTRL_BREAK_EVENT)  # type: ignore[attr-defined]
+        else:
+            child.send_signal(signal.SIGINT)
+    except OSError:
+        return
+
+
 def detach(run: Callable[[], int], report: Report) -> int:
     r"""Run *run* in a process nobody has to reap, and tell *report* its pid.
 
@@ -215,19 +386,6 @@ def _pid_alive_windows(pid: int) -> bool:  # pragma: no cover — exercised on t
         kernel32.CloseHandle(handle)
 
 
-def interrupt(pid: int) -> None:
-    """Ask *pid* to shut down cleanly.
-
-    POSIX: ``SIGINT`` (a launcher forwards it to its child).
-    Windows: ``CTRL_BREAK_EVENT`` to the process group started with
-    ``CREATE_NEW_PROCESS_GROUP``.
-    """
-    if windows():  # pragma: no cover — exercised on the Windows CI job
-        _signal(pid, signal.CTRL_BREAK_EVENT)  # type: ignore[attr-defined]
-        return
-    _signal(pid, signal.SIGINT)
-
-
 def terminate(pid: int) -> None:
     """Tell *pid* to end (``SIGTERM``). Windows has no equivalent; :func:`kill_tree` is next."""
     if not windows():

{plesty_server-0.2.2 → plesty_server-0.2.4}/plesty/server/model/device.py

@@ -5,14 +5,57 @@
 
 from __future__ import annotations
 
-import shlex
 from collections.abc import Mapping
 from dataclasses import dataclass, field
 from typing import Any
 
+from plesty.server import host
 from plesty.server.model.errors import FleetError
 from plesty.server.model.ports import declares_port, port_from
 
+#: Names Windows keeps for its own devices — reserved with any extension, in
+#: any case, so ``com3`` cannot become ``logs/com3.log``. A fleet has to load
+#: on every bench, so the names are refused everywhere, not only on Windows.
+_RESERVED = frozenset(
+    ["con", "prn", "aux", "nul"]
+    + [f"com{d}" for d in "123456789"]
+    + [f"lpt{d}" for d in "123456789"]
+)
+
+#: A device name becomes a directory, a log file and a state file, so it has to
+#: be a portable file name: no separators, no spaces, no leading dot.
+_NAME_CHARS = frozenset("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789._-")
+
+
+def check_name(name: str) -> None:
+    """Raise :exc:`FleetError` unless *name* is usable as a file name on any bench.
+
+    The name of a device is not only a label: it names its virtual environment,
+    its log, its run directory and its state file. A name that a Windows bench
+    cannot open (``com3``) or that reaches out of its directory (``../x``)
+    would declare fine on a developer machine and fail on the instrument.
+
+    Args:
+        name: The key the fleet file gives the device.
+
+    Raises:
+        FleetError: When the name cannot be a file name everywhere.
+    """
+    if not name:
+        raise FleetError("device name must not be empty")
+    if len(name) > 64:
+        raise FleetError(f"device name {name!r}: longer than 64 characters")
+    bad = sorted(set(name) - _NAME_CHARS)
+    if bad:
+        raise FleetError(
+            f"device name {name!r}: {''.join(bad)!r} not allowed — "
+            "letters, digits, dot, dash and underscore only"
+        )
+    if name[0] in ".-":
+        raise FleetError(f"device name {name!r}: must start with a letter or a digit")
+    if name.split(".")[0].lower() in _RESERVED:
+        raise FleetError(f"device name {name!r}: reserved by Windows for a device file")
+
 
 def module_for(package: str) -> str:
     """The import path served by ``python -m`` for a PLESTY distribution.
@@ -129,13 +172,14 @@ class DeviceSpec:
         Raises:
             FleetError: On unknown keys or wrong value types.
         """
+        check_name(name)
         known = {"package", "version", "git", "ref", "module", "args", "env", "port", "autostart"}
         unknown = set(raw) - known
         if unknown:
             raise FleetError(f"device {name!r}: unknown keys {sorted(unknown)}")
         args = raw.get("args", ())
         if isinstance(args, str):
-            args = shlex.split(args)
+            args = host.split_args(args)
         if not isinstance(args, (list, tuple)):
             raise FleetError(f"device {name!r}: 'args' must be a list or a string")
         env = raw.get("env", {})

{plesty_server-0.2.2 → plesty_server-0.2.4}/plesty/server/model/device_manager.py

@@ -206,7 +206,29 @@ class InstalledPackage:
         """The most recently installed version, or ``None`` when empty."""
         if not self.versions:
             return None
-        return max(self.versions.values(), key=lambda v: v.installed_utc)
+        return max(self.versions.values(), key=install_order)
+
+
+def version_order(version: str) -> tuple[int, ...]:
+    """*version* as numbers, so ``0.10.0`` sorts above ``0.9.0``."""
+    order = []
+    for chunk in version.split("."):
+        digits = "".join(c for c in chunk if c.isdigit())
+        order.append(int(digits) if digits else 0)
+    return tuple(order)
+
+
+def install_order(installed: InstalledVersion) -> tuple[str, tuple[int, ...]]:
+    """Order installs by when they happened, then by version.
+
+    ``installed_utc`` is stamped to the second, so two installs of the same
+    package in one second tie — and a bare ``max``/``sorted`` then falls back
+    to the order the records happened to be read in. That order is the
+    filesystem's, so "the latest version" was whichever the host listed last
+    and differed between a Windows bench and a POSIX machine. The version
+    breaks the tie.
+    """
+    return (installed.installed_utc, version_order(installed.version))
 
 
 class DeviceManager:
@@ -295,7 +317,7 @@ class DeviceManager:
                 installed = self.get(package, path.stem)
                 if installed is not None:
                     versions[installed.slot] = installed
-        ordered = dict(sorted(versions.items(), key=lambda kv: kv[1].installed_utc))
+        ordered = dict(sorted(versions.items(), key=lambda kv: install_order(kv[1])))
         return InstalledPackage(package, ordered)
 
     def list(self) -> list[InstalledPackage]:

{plesty_server-0.2.2 → plesty_server-0.2.4}/plesty/server/presenter/bench.py

@@ -433,6 +433,10 @@ class Bench:
             for spec in self.fleet:
                 if spec.package == package and spec.git and spec.git not in urls:
                     urls.append(spec.git)
+        # A release tag is what the *release* source offers: listing v0.1.0 under
+        # the repository as well says the same install twice, in the form that
+        # needs a clone. What only the repository can give is a branch.
+        refs = [r for r in refs if not release_tag(r)]
         for branch in ("main", "exp"):
             if branch not in refs:
                 refs.append(branch)
@@ -691,10 +695,22 @@ class Bench:
         return statuses
 
     def down(self, names: Sequence[str] | None = None) -> list[str]:
-        """Stop the working fleet (or *names*); returns the names stopped."""
-        targets = list(names) if names else [s.name for s in self.working]
-        for n in targets:
-            self.spec(n)
+        """Stop everything running (or *names*); returns the names stopped.
+
+        ``fleet up`` starts the working fleet, so ``down`` starts there — but a
+        device declared ``autostart: false`` and started by hand is running all
+        the same, and stopping only the working fleet left it up and called the
+        bench down. Anything with a launch record is included.
+        """
+        if names:
+            targets = list(names)
+            for n in targets:
+                self.spec(n)
+        else:
+            working = [s.name for s in self.working]
+            # Names that only have a record are still stoppable: stopping needs
+            # the record, not the declaration.
+            targets = working + [n for n in self.supervisor.known() if n not in working]
         return self.supervisor.stop_all(targets)
 
     def run(
@@ -905,6 +921,11 @@ class Bench:
                 [str(python), str(script), "--help"],
                 capture_output=True,
                 text=True,
+                # A device's help says µm and °C; the host code page on a
+                # Windows bench cannot always decode that, and text=True alone
+                # would raise instead of showing the help.
+                encoding="utf-8",
+                errors="replace",
                 timeout=60,
                 check=False,
                 cwd=script.parent.parent,
@@ -973,6 +994,15 @@ def _example_blocks(template: str) -> dict[str, str]:
     return blocks
 
 
+def release_tag(ref: str) -> bool:
+    """Whether *ref* names a release (``v0.3.1``) rather than a branch.
+
+    Args:
+        ref: A git ref as the inventory or the catalogue reports it.
+    """
+    return len(ref) > 1 and ref[0] == "v" and ref[1].isdigit()
+
+
 def _default_name(package: str) -> str:
     """``plesty-pm100d`` → ``pm100d``: the instance name a fresh install gets."""
     stem = package.strip().lower()

{plesty_server-0.2.2 → plesty_server-0.2.4}/plesty/server/services/installer.py

@@ -54,6 +54,26 @@ Echo = Callable[[str], None]
 Runner = Callable[[list[str], "Echo | None"], "subprocess.CompletedProcess[str]"]
 
 
+def _remove_env(env: Path, package: str) -> None:
+    """Delete the environment of *package*, saying why when the host will not.
+
+    Windows keeps a file open by a running process undeletable, so replacing
+    the environment of a device that is still serving fails there where it
+    succeeds on POSIX. The bare ``PermissionError`` names a file deep inside a
+    venv; this names the device instead.
+
+    Raises:
+        InstallError: When the environment is in use.
+    """
+    try:
+        remove_tree(env)
+    except PermissionError as exc:
+        raise InstallError(
+            f"{package}: its environment is in use and cannot be replaced "
+            f"({exc}) — stop the devices running it first"
+        ) from exc
+
+
 class InstallError(RuntimeError):
     """``uv``/``git`` failed, or the environment is not in the shape expected."""
 
@@ -65,7 +85,17 @@ def default_runner(cmd: list[str], echo: Echo | None = None) -> subprocess.Compl
     the text is returned as well, so a failure still carries its own detail.
     """
     if echo is None:
-        return subprocess.run(cmd, capture_output=True, text=True, check=False, **spawn_kwargs())
+        # encoding: text=True alone decodes with the host locale, which on a
+        # Windows bench is a code page that uv's UTF-8 output can break.
+        return subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            check=False,
+            **spawn_kwargs(),
+        )
     echo(f"$ {' '.join(cmd)}")
     proc = subprocess.Popen(
         cmd,
@@ -188,7 +218,7 @@ class Installer:
         env = self.manager.env_dir(installed)
         removed = env.exists()
         if removed:
-            remove_tree(env)
+            _remove_env(env, installed.package)
         parent = env.parent
         if parent != self.home.packages and parent.is_dir() and not any(parent.iterdir()):
             parent.rmdir()
@@ -213,7 +243,7 @@ class Installer:
             raise InstallError(f"{spec.package} is not present in the venv after install")
         final = self.home.package_dir(spec.package, version)
         if final.exists():
-            remove_tree(final)
+            _remove_env(final, spec.package)
         staging.rename(final)
         return self.manager.record(
             spec.package,

{plesty_server-0.2.2 → plesty_server-0.2.4}/plesty/server/services/launch.py

@@ -33,6 +33,16 @@ from plesty.server import host
 from plesty.server.reexec import launcher_command
 
 
+def stop_file(exit_file: str | os.PathLike[str]) -> Path:
+    """The file that asks the waiter of *exit_file* to stop its command.
+
+    Alongside the exit file, so anything that knows where a command reports
+    its end also knows how to ask it to end (see
+    :func:`plesty.server.host.request_stop`).
+    """
+    return Path(f"{exit_file}.stop")
+
+
 def launch(
     command: Sequence[str],
     cwd: str | os.PathLike[str],
@@ -60,6 +70,8 @@ def launch(
     if not (os.path.exists(executable) or shutil.which(executable)):
         raise OSError(f"cannot launch {executable}: no such executable")
     Path(exit_file).unlink(missing_ok=True)
+    stop = stop_file(exit_file)
+    stop.unlink(missing_ok=True)  # a stale one would stop the new command at once
     Path(log).parent.mkdir(parents=True, exist_ok=True)
     spec = {
         "command": list(command),
@@ -67,6 +79,7 @@ def launch(
         "env": dict(env),
         "log": str(log),
         "exit_file": str(exit_file),
+        "stop_file": str(stop),
         "banner": banner,
     }
     # Read the pid the launcher prints; never wait for the launcher to finish —
@@ -117,13 +130,10 @@ def _wait(spec: dict[str, Any]) -> int:
     """The waiter: run the command, forward the interrupt, record the exit code."""
     holder: dict[str, subprocess.Popen[bytes]] = {}
 
-    def forward(signum: int, _frame: Any) -> None:
+    def forward(_signum: int, _frame: Any) -> None:
         child = holder.get("child")
         if child is not None:
-            try:
-                child.send_signal(signum)
-            except OSError:
-                pass
+            host.deliver_stop(child)
 
     host.forward_signals(forward)
     with open(spec["log"], "ab") as log:
@@ -138,12 +148,15 @@ def _wait(spec: dict[str, Any]) -> int:
                 stdin=subprocess.DEVNULL,
                 stdout=log,
                 stderr=subprocess.STDOUT,
-                **host.spawn_kwargs(),
+                **host.interruptible_kwargs(),
             )
         except OSError as exc:
             log.write(f"=== cannot start: {exc}\n".encode())
             _write_exit(spec["exit_file"], 127)
             return 127
+    # Windows cannot signal us across consoles; the stop file is how a stop
+    # arrives there. Registered once the child exists, so it can be delivered.
+    host.watch_for_stop(Path(spec["stop_file"]), lambda: host.deliver_stop(holder["child"]))
     code = holder["child"].wait()
     stamp = datetime.now(UTC).isoformat(timespec="seconds")
     with open(spec["log"], "ab") as log:

{plesty_server-0.2.2 → plesty_server-0.2.4}/plesty/server/services/supervisor.py

@@ -44,7 +44,7 @@ from plesty.server.model.process import (
     ProcessRecord,
     ProcessStatus,
 )
-from plesty.server.services.launch import launch, read_exit
+from plesty.server.services.launch import launch, read_exit, stop_file
 
 #: Host every probe targets — servers bind ``tcp://*`` on the bench itself.
 PROBE_HOST = "127.0.0.1"
@@ -174,6 +174,7 @@ class Supervisor:
     def _drop_record(self, name: str) -> None:
         self.home.state_file(name).unlink(missing_ok=True)
         self.exit_file(name).unlink(missing_ok=True)
+        stop_file(self.exit_file(name)).unlink(missing_ok=True)
 
     # ── liveness ─────────────────────────────────────────────────────────
 
@@ -370,7 +371,7 @@ class Supervisor:
             self._drop_record(name)
             return False
         wait = self.stop_timeout if timeout is None else timeout
-        host.interrupt(rec.pid)
+        host.request_stop(rec.pid, stop_file(self.exit_file(name)))
         if not self._wait_exit(name, wait):
             host.terminate(rec.pid)
             if not self._wait_exit(name, 3.0):

{plesty_server-0.2.2 → plesty_server-0.2.4}/plesty/server/view/dialogs.py

@@ -15,6 +15,7 @@ from collections.abc import Callable
 from typing import Any
 
 from PySide6.QtCore import Qt, QTimer
+from PySide6.QtGui import QSyntaxHighlighter, QTextCharFormat
 from PySide6.QtWidgets import (
     QCheckBox,
     QComboBox,
@@ -33,10 +34,61 @@ from PySide6.QtWidgets import (
     QWidget,
 )
 
+from plesty.lib.ui.theme import Theme
 from plesty.server.model import DeviceSpec, FieldTestRun, FleetError, Job
 from plesty.server.presenter import Bench, SourceOptions
 
 
+class EnvHighlighter(QSyntaxHighlighter):
+    """Dim what a ``.env`` line does not set: its comments.
+
+    A device ``.env`` is mostly prose — what a key is for, an example address,
+    a value commented out for later — and at the weight of the settings it
+    explains the file reads as a wall of text. Comments are drawn in the muted
+    tone instead, so the eye lands on the ``KEY=VALUE`` lines that act.
+
+    What is dimmed is exactly what :func:`plesty.server.model.parse_env`
+    throws away: a line whose first non-space character is ``#``, and the
+    `` #`` tail of an *unquoted* value. A ``#`` inside a quoted value is part
+    of the value — a password may contain one — and stays at full weight.
+    """
+
+    def __init__(self, document: Any, colour: str) -> None:
+        """Highlight *document*, drawing comments in *colour* (a hex string)."""
+        from PySide6.QtGui import QColor
+
+        super().__init__(document)
+        self._comment = QTextCharFormat()
+        self._comment.setForeground(QColor(colour))
+
+    def highlightBlock(self, text: str) -> None:  # noqa: N802 — Qt's name
+        """Colour the comment part of one line, if it has one."""
+        start = comment_start(text)
+        if start is not None:
+            self.setFormat(start, len(text) - start, self._comment)
+
+
+def comment_start(line: str) -> int | None:
+    """Where the comment of a ``.env`` *line* begins, or ``None`` when it has none.
+
+    Args:
+        line: One line of dotenv text.
+    """
+    stripped = line.lstrip()
+    if not stripped:
+        return None
+    if stripped.startswith("#"):
+        return len(line) - len(stripped)
+    body = stripped[len("export ") :] if stripped.startswith("export ") else stripped
+    if "=" not in body:
+        return None
+    value = body.split("=", 1)[1].strip()
+    if len(value) >= 2 and value[0] == value[-1] and value[0] in "\"'":
+        return None  # quoted: a # in there belongs to the value
+    marker = line.find(" #", line.index("=") + 1)
+    return marker if marker != -1 else None
+
+
 def _form(parent: QWidget | None = None) -> QFormLayout:
     """A form whose fields take the full width (macOS keeps them at size hint otherwise)."""
     form = QFormLayout(parent) if parent is not None else QFormLayout()
@@ -590,6 +642,9 @@ class DeviceConfigDialog(QDialog):
             "KEY=VALUE per line — DEVICE_ADDRESS, credentials, PLESTY_REPORT_ARCHIVE …\n"
             "Read by the device server and the field test; never leaves this bench."
         )
+        # The comments carry the explanations, the KEY=VALUE lines carry the
+        # settings: the muted tone tells them apart at a glance.
+        self.env_highlighter = EnvHighlighter(self.env.document(), Theme.load().color("slate"))
         env_page = QWidget()
         env_layout = QVBoxLayout(env_page)
         note = QLabel(f"{bench.env_file(name)}")

{plesty_server-0.2.2 → plesty_server-0.2.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "plesty-server"
-version = "0.2.2"
+version = "0.2.4"
 license = "LGPL-3.0-or-later"
 license-files = ["LICENSE", "LICENSES/*"]
 description = "The PLESTY bench application: installs, runs and field-tests device servers."
@@ -9,7 +9,7 @@ maintainers = [{ name = "Plesty Development Team", email = "plesty.dev@example.c
 readme = "README.md"
 requires-python = ">=3.12"
 dependencies = [
-  "plesty-bench==0.2.2",
+  "plesty-bench==0.2.4",
   "plesty-lib>=0.3.3",
   "pyyaml>=6.0",
   "pyzmq>=26",