ms-components 0.4.2__tar.gz → 0.4.3__tar.gz

{ms_components-0.4.2 → ms_components-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ms_components
-Version: 0.4.2
+Version: 0.4.3
 Summary: PySide6 UI components for MolSuite: smart table, project browser, job monitor, PyMOL dock, steppers.
 Author: Mario S. Valdés-Tresanco, Mario E. Valdés-Tresanco
 License-Expression: MIT

{ms_components-0.4.2 → ms_components-0.4.3}/src/ms_components/ms_executors.py

@@ -8,7 +8,10 @@ be done now, and says why.
 """
 from __future__ import annotations
 
+import shlex
+import sys
 import threading
+import time
 import types
 from typing import Any, Literal, Union, get_args, get_origin
 
@@ -90,6 +93,44 @@ def _value(editor: QWidget) -> Any:
     return editor.text().strip()
 
 
+_VERSIONS = """import sys, importlib.metadata as m
+print("Python", sys.version.split()[0], "at", sys.prefix)
+for name in sys.argv[1:]:
+    try:
+        print(f"  {name} {m.version(name)}")
+    except m.PackageNotFoundError:
+        print(f"  {name}: not installed")
+"""
+
+
+def describe_host(address: str, env: str = "", packages=(), tools=None) -> str:
+    """What the machine `address` (empty: this one) is and has, in a few lines: its system, CPUs,
+    memory and GPUs, the Python of `env` there with the version of each of `packages`, and whether
+    each of `tools` (name -> path) can be run. One `ssh` call, which raises `HostError` when it does
+    not get in. Blocks: not on the GUI thread."""
+    from ms_env import Host
+
+    tools = tools or {}
+    python = f"{env.rstrip('/')}/bin/python" if env else ("" if address else sys.executable)
+    script = "; ".join([
+        "export LC_ALL=C", "uname -srm", '(. /etc/os-release 2>/dev/null && echo "$PRETTY_NAME")',
+        'echo "CPUs: $(nproc 2>/dev/null || sysctl -n hw.ncpu)"',
+        "awk '/MemTotal/ {printf \"Memory: %.1f GB\\n\", $2/1048576}' /proc/meminfo 2>/dev/null",
+        "(nvidia-smi -L 2>/dev/null || echo 'GPUs: none seen by nvidia-smi')",
+        "echo",
+        *([f"if [ -x {shlex.quote(python)} ]; then {shlex.quote(python)} -c {shlex.quote(_VERSIONS)} "
+           f"{' '.join(map(shlex.quote, packages))}; else echo 'Environment: none at '{shlex.quote(python)}; fi"]
+          if python else ["echo 'Environment: none named; the app prepares one before the first job'"]),
+        *(f"([ -x {shlex.quote(path)} ] && echo '  ✓ {name} '{shlex.quote(path)} || echo '  ✗ {name} not found at '{shlex.quote(path)})"
+          for name, path in tools.items()),
+    ])
+    if tools:
+        script = script.replace("; ([ -x", "; echo 'Tools:'; ([ -x", 1)
+    began = time.monotonic()
+    said = Host(address or None).run(script, timeout=60).decode(errors="replace").strip()
+    return f"Connected to {address or 'this machine'} in {time.monotonic() - began:.1f} s\n\n{said}"
+
+
 class KeptPage(QWidget):
     """The entries kept in `table` (`hosts` or `executors`) and the form of the chosen one.
 
@@ -98,10 +139,15 @@ class KeptPage(QWidget):
     """
 
     changed = Signal()
+    _checked = Signal(str)
 
-    def __init__(self, workspace, table: str, parent: QWidget | None = None):
+    def __init__(self, workspace, table: str, parent: QWidget | None = None, *, packages=("ms_flow", "ms_env"),
+                 default_env: str = ""):
+        """`packages`: whose version "Check connection" reads on a host; `default_env`: the
+        environment the app prepares on a host that names none, under the home there."""
         super().__init__(parent)
         self._workspace, self._table, self._one = workspace, table, table[:-1]
+        self._packages, self._default_env = tuple(packages), default_env
         settings = type(workspace.settings_manager.settings)
         self._model = get_args(settings.model_fields[table].annotation)[1]
         self._editors: dict[str, QWidget] = {}
@@ -130,6 +176,17 @@ class KeptPage(QWidget):
         self.save_button.clicked.connect(self._save)
         foot = QHBoxLayout()
         foot.addWidget(self.said, 1)
+        if table == "hosts":
+            self.check_button = QPushButton("Check connection", self)
+            self.check_button.setToolTip("Log in to it and say what it is and what it has: system, CPUs, GPUs, "
+                                         "the environment of the app and its packages, the tools named.")
+            self.check_button.clicked.connect(self._check)
+            foot.addWidget(self.check_button)
+            self.report = QPlainTextEdit(self)
+            self.report.setReadOnly(True)
+            self.report.setVisible(False)
+            self._right.addWidget(self.report, 8)  # the room the stretch below has while nothing is said
+            self._checked.connect(self._show_report)
         foot.addWidget(self.save_button)
         self._right.addStretch(1)
         self._right.addLayout(foot)
@@ -187,6 +244,8 @@ class KeptPage(QWidget):
             self._only_of_kind()
         self.remove_button.setEnabled(bool(name) and name != "local")
         self.said.setText("")
+        if self._table == "hosts":
+            self.report.setVisible(False)
         self._right.insertWidget(0, body)
 
     def _only_of_kind(self) -> None:
@@ -226,6 +285,28 @@ class KeptPage(QWidget):
         self.said.setText(f"`{name}` is kept.")
         self.changed.emit()
 
+    def _check(self) -> None:
+        """What `describe_host` says of the host as the form has it now, saved or not."""
+        fields = {key: _value(editor) for key, editor in self._editors.items()}
+        address = fields.get("address") or ""
+        env = fields.get("env") or (self._default_env if address else "")
+        self.check_button.setEnabled(False)
+        self._show_report(f"Connecting to {address or 'this machine'}…")
+
+        def work() -> None:
+            try:
+                said = describe_host(address, env, self._packages, fields.get("tools") or {})
+            except Exception as error:  # noqa: BLE001 - said in the page, where it was asked for
+                said = f"Could not check {address or 'this machine'}:\n{str(error).split('` on ', 1)[-1]}"
+            self._checked.emit(said)
+
+        threading.Thread(target=work, name="host-check", daemon=True).start()
+
+    def _show_report(self, text: str) -> None:
+        self.report.setPlainText(text)
+        self.report.setVisible(True)
+        self.check_button.setEnabled(not text.endswith("…"))
+
     def _remove(self) -> None:
         name = self.name.text().strip()
         asked = QMessageBox.question(self, "Remove", f"Remove `{name}` from the {self._table} kept?")
@@ -359,4 +440,4 @@ class ExecutorsPanel(QDialog):
         self.refresh()
 
 
-__all__ = ["ExecutorsPanel", "KeptPage"]
+__all__ = ["ExecutorsPanel", "KeptPage", "describe_host"]

{ms_components-0.4.2 → ms_components-0.4.3}/src/ms_components/ms_monitor/job_cards.py

@@ -7,8 +7,8 @@ panel. The card shows the job-level rollup; unfolded, the tasks in flight under
 """
 from __future__ import annotations
 
-from PySide6.QtCore import Qt, QPoint, QPropertyAnimation, QEasingCurve, Property, Signal
-from PySide6.QtGui import QBrush, QColor, QCursor, QLinearGradient, QPainter
+from PySide6.QtCore import Qt, QPoint, QPointF, QPropertyAnimation, QEasingCurve, Property, Signal
+from PySide6.QtGui import QBrush, QColor, QCursor, QLinearGradient, QPainter, QPalette, QPen
 from PySide6.QtWidgets import (
     QHBoxLayout,
     QLabel,
@@ -164,6 +164,39 @@ class GlowBar(QWidget):
         p.drawRoundedRect(0, 0, fw, h, 3, 3)
 
 
+class _GlyphButton(QPushButton):
+    """A small flat button whose glyph is painted, not a font character: `ⓘ` and `▶` came out
+    in whatever font (or emoji) the system had, ringed twice, and blind to the theme."""
+
+    def __init__(self, glyph: str, tip: str, parent=None):
+        super().__init__(parent)
+        self._glyph = glyph  # "info", or "chevron": right while unchecked, down once checked
+        self.setFixedSize(22, 22)
+        self.setCursor(QCursor(Qt.PointingHandCursor))
+        self.setToolTip(tip)
+        self.setStyleSheet(
+            """QPushButton { background:transparent; border:1px solid transparent; border-radius:4px; }
+            QPushButton:hover, QPushButton:checked { border-color:palette(mid); background:palette(alternate-base); }"""
+        )
+
+    def paintEvent(self, event):
+        super().paintEvent(event)
+        p = QPainter(self)
+        p.setRenderHint(QPainter.Antialiasing)
+        role = QPalette.ColorRole.Highlight if self.underMouse() or self.isChecked() else QPalette.ColorRole.PlaceholderText
+        pen = QPen(self.palette().color(role), 1.6, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin)
+        p.setPen(pen)
+        c = QPointF(self.width() / 2, self.height() / 2)
+        if self._glyph == "info":
+            p.drawEllipse(c, 7, 7)
+            p.drawLine(QPointF(c.x(), c.y() - 0.5), QPointF(c.x(), c.y() + 3.5))
+            p.drawPoint(QPointF(c.x(), c.y() - 3.2))
+        else:
+            d = 3.5
+            points = ((-d / 2, -d), (d / 2, 0), (-d / 2, d)) if not self.isChecked() else ((-d, -d / 2), (0, d / 2), (d, -d / 2))
+            p.drawPolyline([QPointF(c.x() + x, c.y() + y) for x, y in points])
+
+
 _TASKS_SHOWN = 12  # rows under an unfolded job; the rest are counted
 
 
@@ -227,6 +260,7 @@ class JobCard(QWidget):
 
     def _setup_ui(self):
         self.setObjectName("JobCard")
+        self.setAttribute(Qt.WA_StyledBackground, True)  # a plain QWidget paints no QSS background or border
         self.setCursor(QCursor(Qt.PointingHandCursor))
         self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Maximum)
         self._apply_card_style()
@@ -262,28 +296,12 @@ class JobCard(QWidget):
         )
         top.addWidget(self._eta_lbl)
 
-        self._info_btn = QPushButton("ⓘ")
-        self._info_btn.setFixedSize(20, 20)
-        self._info_btn.setCursor(QCursor(Qt.PointingHandCursor))
-        self._info_btn.setStyleSheet(
-            f"""QPushButton {{ background:transparent; color:palette(placeholder-text);
-                border:1px solid palette(mid); border-radius:10px; font-size:11px; }}
-            QPushButton:hover {{ color:palette(highlight); border-color:palette(highlight);
-                background:palette(alternate-base); }}"""
-        )
+        self._info_btn = _GlyphButton("info", "Details of the job")
         self._info_btn.clicked.connect(self._show_info_tooltip)
         top.addWidget(self._info_btn)
 
-        self._toggle = QPushButton("▶")
+        self._toggle = _GlyphButton("chevron", "Show the tasks in flight")
         self._toggle.setCheckable(True)
-        self._toggle.setFixedSize(20, 20)
-        self._toggle.setCursor(QCursor(Qt.PointingHandCursor))
-        self._toggle.setToolTip("Show the tasks in flight")
-        self._toggle.setStyleSheet(
-            f"""QPushButton {{ background:transparent; color:palette(placeholder-text);
-                border:1px solid palette(mid); border-radius:4px; font-size:9px; }}
-            QPushButton:hover {{ color:palette(highlight); border-color:palette(highlight); }}"""
-        )
         self._toggle.toggled.connect(self._on_toggled)
         top.addWidget(self._toggle)
 
@@ -313,7 +331,6 @@ class JobCard(QWidget):
 
     def _on_toggled(self, unfolded: bool):
         self._tasks_wrap.setVisible(unfolded)
-        self._toggle.setText("▼" if unfolded else "▶")
         self._refresh_tasks()
         self.unfolded.emit(self._job.job_id, unfolded)
 
@@ -335,12 +352,16 @@ class JobCard(QWidget):
         self._tasks_note.setVisible(bool(more) or not shown)
 
     def _apply_card_style(self):
-        border = P["accent"] if self._selected else P["border"]
-        self.setStyleSheet(
-            f"""#JobCard {{ background:palette(base); border:1px solid {border};
-                border-radius:8px; }}
-            #JobCard:hover {{ border-color:palette(mid); }}"""
-        )
+        # Selected: tinted with the highlight and ringed by it, which hovering does not undo.
+        if self._selected:
+            tint = QColor(P["accent"])
+            tint.setAlphaF(0.12)
+            rule = f"background:{tint.name(QColor.HexArgb)}; border:2px solid {P['accent']};"
+            hover = ""
+        else:
+            rule = "background:palette(base); border:2px solid palette(mid);"
+            hover = f"#JobCard:hover {{ border-color:{P['accent']}; }}"
+        self.setStyleSheet(f"#JobCard {{ {rule} border-radius:8px; }} {hover}")
 
     def set_selected(self, selected: bool):
         if selected == self._selected:
@@ -369,12 +390,18 @@ class JobCard(QWidget):
         parts = []
         if job.chunks_done:
             parts.append(f"<span style='color:{P['ok']}'>{job.chunks_done:,} ✓</span>")
-        if job.chunks_running:
-            parts.append(f"<span style='color:{P['accent']}'>{job.chunks_running} ⚙</span>")
+        if job.tasks_running:
+            parts.append(f"<span style='color:{P['accent']}'>{job.tasks_running} ⚙</span>")
+        waiting = job.chunks_running - job.tasks_running  # ponytail: packed chunks count here too
+        if waiting > 0:
+            parts.append(f"<span style='color:{P['text_muted']}'>{waiting:,} ⧗</span>")
         if job.chunks_failed:
             parts.append(f"<span style='color:{P['error']}'>{job.chunks_failed:,} ✗</span>")
         total = f"  / {job.chunks_total:,}" if job.chunks_total else ""
         self._counters_lbl.setText("  ·  ".join(parts) + total)
+        self._counters_lbl.setToolTip(
+            "✓ done  ·  ⚙ tasks running now, one worker each  ·  ⧗ chunks taken that do not run: "
+            "carried in a task with others, or done and waiting to be written  ·  ✗ failed")
         if self._toggle.isChecked():
             self._refresh_tasks()
 
@@ -386,7 +413,8 @@ class JobCard(QWidget):
             f"<hr style='border-color:{P['border']}'>"
             f"<b>Key:</b> {j.job_id}<br>"
             f"<b>Chunks:</b> {j.chunks_done:,} ✓ / {total} total<br>"
-            f"<b>Running:</b> {j.chunks_running}  "
+            f"<b>Tasks running:</b> {j.tasks_running} on {j.cpu_used} CPU  "
+            f"<b>Chunks taken:</b> {j.chunks_running:,}<br>"
             f"<b>Failed:</b> {j.chunks_failed:,}  "
             f"<b>Retried:</b> {j.chunks_retried:,}<br>"
             f"<b>Peak memory:</b> {j.peak_mem_mb or '—'} MB<br>"

{ms_components-0.4.2 → ms_components-0.4.3}/src/ms_components/ms_monitor/models.py

@@ -43,7 +43,9 @@ class JobMonitorState:
     chunks_total: int = 0  # 0 while the source of chunks has not said
     chunks_done: int = 0
     chunks_failed: int = 0
-    chunks_running: int = 0
+    chunks_running: int = 0  # taken and not settled: running, carried in a task, or being written
+    tasks_running: int = 0  # what runs now, one worker each; <= chunks_running
+    cpu_used: int = 0  # the CPU tokens those tasks hold
     chunks_retried: int = 0
     peak_mem_mb: int = 0
     throughput_eps: float = 0.0

{ms_components-0.4.2 → ms_components-0.4.3}/src/ms_components/ms_monitor/polling.py

@@ -23,6 +23,9 @@ def job_state(job, now: float) -> JobMonitorState:
         chunks_done=job.chunks_done,
         chunks_failed=job.chunks_failed,
         chunks_running=job.chunks_inflight,
+        # ms_flow < 0.7 does not tell them apart: every chunk in flight reads as running.
+        tasks_running=getattr(job, "tasks_running", job.chunks_inflight),
+        cpu_used=getattr(job, "cpu_used", 0),
         chunks_retried=job.chunks_retried,
         peak_mem_mb=job.peak_mem_mb,
         # ponytail: the mean since the job started, not the rate right now; a rate over the

ms_components-0.4.3/src/ms_components/ms_monitor/resources.py

@@ -0,0 +1,305 @@
+"""What the machines that run jobs are using: CPU, memory and GPU of each host, over the last minutes.
+
+A host is read where it is: this machine with `psutil` (or `/proc`), another one through
+`ms_env.Host` (the system's `ssh`), with one command that prints `/proc/stat`, `/proc/meminfo`
+and `nvidia-smi`. The CPU in use is the change of `/proc/stat` between two reads, so the first
+read of a host shows none. Each host is read in its own thread, only while the panel is shown,
+every `interval` seconds: a few for this machine, more for one over the network, the most for
+the login node of a queue, which is asked through the same `ssh` its jobs are.
+"""
+from __future__ import annotations
+
+import shutil
+import subprocess
+import threading
+import time
+from collections import deque
+from dataclasses import dataclass, field
+
+from PySide6.QtCore import QObject, QPointF, Qt, Signal
+from PySide6.QtGui import QColor, QPainter, QPainterPath, QPalette, QPen
+from PySide6.QtWidgets import QFrame, QGridLayout, QLabel, QScrollArea, QToolTip, QVBoxLayout, QWidget
+
+# Seconds between two reads, by the kind of executor the host is under.
+INTERVALS = {"local": 5, "ray": 15, "queue": 60}
+_HISTORY = 120  # reads kept per host: 10 min of this machine, 30 of one over the network
+
+_GPU_QUERY = "nvidia-smi --query-gpu=utilization.gpu,memory.used,memory.total --format=csv,noheader,nounits"
+_SCRIPT = f"head -1 /proc/stat; grep -E '^(MemTotal|MemAvailable):' /proc/meminfo; {_GPU_QUERY} 2>/dev/null || true"
+
+
+@dataclass(slots=True)
+class Sample:
+    cpu: float | None = None  # percent of all CPUs; None on the first read
+    mem: float = 0.0  # percent
+    mem_used_gb: float = 0.0
+    mem_total_gb: float = 0.0
+    gpus: list[tuple[float, float, float]] = field(default_factory=list)  # (util %, MiB used, MiB total)
+    error: str = ""
+
+
+def parse(text: str, previous: tuple[int, int] | None) -> tuple[Sample, tuple[int, int] | None]:
+    """What `_SCRIPT` printed, and the CPU counters it read (busy, total) for the next read."""
+    sample, ticks, mem = Sample(), None, {}
+    for line in text.splitlines():
+        if line.startswith("cpu "):
+            values = [int(v) for v in line.split()[1:]]
+            idle = values[3] + (values[4] if len(values) > 4 else 0)  # idle + iowait
+            ticks = (sum(values) - idle, sum(values))
+        elif line.startswith(("MemTotal:", "MemAvailable:")):
+            key, value = line.split(":")
+            mem[key] = int(value.split()[0]) / 1024**2  # kB → GB
+        elif line.count(",") == 2:
+            try:
+                sample.gpus.append(tuple(float(v) for v in line.split(",")))
+            except ValueError:
+                pass
+    if ticks and previous and ticks[1] > previous[1]:
+        sample.cpu = 100.0 * (ticks[0] - previous[0]) / (ticks[1] - previous[1])
+    total = mem.get("MemTotal", 0.0)
+    if total:
+        sample.mem_total_gb, sample.mem_used_gb = total, total - mem.get("MemAvailable", total)
+        sample.mem = 100.0 * sample.mem_used_gb / total
+    return sample, ticks
+
+
+def _local_gpus() -> list[tuple[float, float, float]]:
+    if not shutil.which("nvidia-smi"):
+        return []
+    try:
+        out = subprocess.run(_GPU_QUERY.split(), capture_output=True, text=True, timeout=10).stdout
+    except (OSError, subprocess.SubprocessError):
+        return []
+    return parse(out, None)[0].gpus
+
+
+class _Reader:
+    """Reads one host; keeps what the next read needs."""
+
+    def __init__(self, address: str):
+        self.address, self._ticks, self._psutil = address, None, None
+        if not address:
+            try:
+                import psutil
+
+                psutil.cpu_percent(None)  # the first call only starts the count
+                self._psutil = psutil
+            except ImportError:
+                pass
+
+    def read(self) -> Sample:
+        try:
+            if self._psutil is not None:
+                memory = self._psutil.virtual_memory()
+                return Sample(self._psutil.cpu_percent(None), memory.percent, (memory.total - memory.available) / 1024**3,
+                              memory.total / 1024**3, _local_gpus())
+            from ms_env import Host
+
+            text = Host(self.address or None).run(_SCRIPT, timeout=30).decode(errors="replace")
+            sample, self._ticks = parse(text, self._ticks)
+            return sample
+        except Exception as error:  # noqa: BLE001 - shown on the row of the host
+            said = str(error).split("` on ", 1)[-1].strip()  # not the command: where, and what went wrong
+            return Sample(error=said.splitlines()[-1] if said else type(error).__name__)
+
+
+class Sparkline(QWidget):
+    """One measure of one host over time, 0-100 %: the line, the area under it and the value now.
+    Hovering says the value under the pointer and how long ago it was."""
+
+    def __init__(self, title: str, parent=None):
+        super().__init__(parent)
+        self.title, self.values, self.interval, self.note = title, deque(maxlen=_HISTORY), 5, ""
+        self.setMinimumSize(160, 64)
+        self.setMouseTracking(True)
+
+    def push(self, value: float | None, note: str = "") -> None:
+        self.values.append(value)
+        self.note = note
+        self.update()
+
+    def _x(self, index: int) -> float:
+        return self.width() * index / max(1, _HISTORY - 1)
+
+    def paintEvent(self, _):
+        p = QPainter(self)
+        p.setRenderHint(QPainter.Antialiasing)
+        pal = self.palette()
+        w, h, top = self.width(), self.height(), 14
+        p.setPen(QPen(pal.color(QPalette.ColorRole.Mid), 1))
+        p.drawLine(0, h - 1, w, h - 1)  # the 0 %, recessive
+        p.setPen(pal.color(QPalette.ColorRole.PlaceholderText))
+        p.drawText(0, 0, w, top, Qt.AlignLeft | Qt.AlignTop, self.title)
+        now = next((v for v in reversed(self.values) if v is not None), None)
+        p.setPen(pal.color(QPalette.ColorRole.Text))
+        p.drawText(0, 0, w, top, Qt.AlignRight | Qt.AlignTop,
+                   "—" if now is None else f"{now:.0f}%" + (f"  {self.note}" if self.note else ""))
+        start = _HISTORY - len(self.values)
+        points = [QPointF(self._x(start + i), h - 1 - (h - top - 2) * min(100.0, v) / 100.0)
+                  for i, v in enumerate(self.values) if v is not None]
+        if len(points) < 2:
+            return
+        accent = pal.color(QPalette.ColorRole.Highlight)
+        area = QPainterPath(QPointF(points[0].x(), h - 1))
+        for point in points:
+            area.lineTo(point)
+        area.lineTo(QPointF(points[-1].x(), h - 1))
+        fill = QColor(accent)
+        fill.setAlphaF(0.18)
+        p.fillPath(area, fill)
+        p.setPen(QPen(accent, 2, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))
+        p.drawPolyline(points)
+
+    def mouseMoveEvent(self, event):
+        index = round(event.position().x() / max(1.0, self.width()) * (_HISTORY - 1)) - (_HISTORY - len(self.values))
+        if 0 <= index < len(self.values) and self.values[index] is not None:
+            ago = (len(self.values) - 1 - index) * self.interval
+            QToolTip.showText(event.globalPosition().toPoint(),
+                              f"{self.title}: {self.values[index]:.0f}% · {ago}s ago" if ago else f"{self.title}: {self.values[index]:.0f}% · now", self)
+        else:
+            QToolTip.hideText()
+
+
+class _Relay(QObject):
+    sampled = Signal(str, object)  # host key, Sample
+
+
+class _HostRow(QFrame):
+    def __init__(self, name: str, address: str, interval: int, parent=None):
+        super().__init__(parent)
+        self.setObjectName("hostRow")
+        self.setStyleSheet("QFrame#hostRow { background:palette(base); border:1px solid palette(mid); border-radius:8px; }")
+        grid = QGridLayout(self)
+        grid.setContentsMargins(10, 6, 10, 6)
+        title = QLabel(f"<b>{name}</b> <span style='color:palette(placeholder-text)'>"
+                       f"{address or 'this computer'} · every {interval}s</span>", self)
+        grid.addWidget(title, 0, 0)
+        self.said = QLabel(self)
+        self.said.setStyleSheet("color:palette(placeholder-text); font-size:10px;")
+        self.said.setWordWrap(True)
+        self.said.setVisible(False)
+        grid.addWidget(self.said, 1, 0)
+        self.lines = {key: Sparkline(key, self) for key in ("CPU", "Memory", "GPU")}
+        for at, line in enumerate(self.lines.values(), start=2):  # stacked: each its own axis, full width
+            line.interval = interval
+            grid.addWidget(line, at, 0)
+        self.lines["GPU"].setVisible(False)
+
+    def apply(self, sample: Sample) -> None:
+        self.said.setText(sample.error)
+        self.said.setVisible(bool(sample.error))
+        if sample.error:
+            return
+        self.lines["CPU"].push(sample.cpu)
+        self.lines["Memory"].push(sample.mem, f"{sample.mem_used_gb:.1f}/{sample.mem_total_gb:.0f} GB")
+        if sample.gpus:  # ponytail: the mean over the cards; a line per card when one host has several that differ
+            util = sum(g[0] for g in sample.gpus) / len(sample.gpus)
+            used, total = sum(g[1] for g in sample.gpus) / 1024, sum(g[2] for g in sample.gpus) / 1024
+            self.lines["GPU"].setVisible(True)
+            self.lines["GPU"].push(util, f"{len(sample.gpus)}× · {used:.1f}/{total:.0f} GB")
+
+
+class ResourcesPanel(QScrollArea):
+    """The hosts of the executors that are on, under the name of each, read while shown.
+
+    `hosts()` gives `(group, name, address, interval_s)` for each host to read; by default
+    they come from `workspace` (see `workspace_hosts`).
+    """
+
+    def __init__(self, workspace=None, *, hosts=None, parent=None):
+        super().__init__(parent)
+        self.hosts = hosts or (lambda: workspace_hosts(workspace))
+        self._rows: dict[str, _HostRow] = {}
+        self._threads: list[threading.Thread] = []
+        self._stop = threading.Event()
+        self._relay = _Relay(self)
+        self._relay.sampled.connect(self._on_sample)
+        self.setWidgetResizable(True)
+        self.setFrameShape(QFrame.NoFrame)
+
+    def showEvent(self, event):
+        super().showEvent(event)
+        self.start()
+
+    def hideEvent(self, event):
+        self.stop()
+        super().hideEvent(event)
+
+    def start(self) -> None:
+        self.stop()
+        self._stop = stop = threading.Event()
+        body = QWidget()
+        layout = QVBoxLayout(body)
+        layout.setContentsMargins(4, 4, 4, 4)
+        self._rows.clear()
+        try:
+            listed = list(self.hosts())
+        except Exception as error:  # noqa: BLE001
+            listed, failed = [], str(error)
+        else:
+            failed = ""
+        group = None
+        for at, (in_group, name, address, interval) in enumerate(listed):
+            if in_group != group:
+                group = in_group
+                heading = QLabel(f"<b>{group}</b>", body)
+                heading.setStyleSheet("color:palette(placeholder-text); margin-top:6px;")
+                layout.addWidget(heading)
+            key = f"{at}:{name}"
+            self._rows[key] = row = _HostRow(name, address, interval, body)
+            layout.addWidget(row)
+            thread = threading.Thread(target=self._read, args=(key, address, interval, stop),
+                                      name=f"resources-{name}", daemon=True)
+            self._threads.append(thread)
+            thread.start()
+        if not listed:
+            empty = QLabel(failed or "No executor is on.", body)
+            empty.setStyleSheet("color:palette(placeholder-text);")
+            layout.addWidget(empty)
+        layout.addStretch(1)
+        self.setWidget(body)
+
+    def stop(self) -> None:
+        self._stop.set()
+        self._threads.clear()  # daemons: each ends at its next wake-up, an ssh call in flight included
+
+    def _read(self, key: str, address: str, interval: int, stop: threading.Event) -> None:
+        reader = _Reader(address)
+        while not stop.is_set():
+            began = time.monotonic()
+            sample = reader.read()
+            if stop.is_set():
+                return
+            self._relay.sampled.emit(key, sample)
+            stop.wait(max(0.5, interval - (time.monotonic() - began)))
+
+    def _on_sample(self, key: str, sample: Sample) -> None:
+        row = self._rows.get(key)
+        if row is not None:
+            row.apply(sample)
+
+
+def workspace_hosts(workspace) -> list[tuple[str, str, str, int]]:
+    """`(executor, host, address, interval)` for every host of an executor that is on, a host under
+    the first one that has it; this machine always, under `local` when no executor that is on has it."""
+    if workspace is None:
+        return [("local", "local", "", INTERVALS["local"])]
+    kept = workspace.settings_manager.settings.hosts
+    rows, seen = [], set()
+    for executor in workspace.executors():
+        if executor["state"] != "on":
+            continue
+        for name in executor["hosts"]:
+            if name in seen:
+                continue
+            seen.add(name)
+            address = getattr(kept.get(name), "address", "") or ""
+            kind = "local" if not address else executor["kind"]
+            group = f"{executor['name']} ({executor['kind']}{', login node' if kind == 'queue' else ''})"
+            rows.append((group, name, address, INTERVALS.get(kind, INTERVALS["ray"])))
+    if "local" not in seen:
+        rows.insert(0, ("local", "local", "", INTERVALS["local"]))
+    return rows
+
+
+__all__ = ["INTERVALS", "ResourcesPanel", "Sample", "Sparkline", "parse", "workspace_hosts"]