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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ms_components
-Version: 0.4.2
+Version: 0.5.0
 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
@@ -21,11 +21,11 @@ Requires-Dist: PySide6>=6.5
 Provides-Extra: monitor
 Requires-Dist: pydantic>=2.0; extra == "monitor"
 Provides-Extra: projects
-Requires-Dist: ms_flow>=0.2.0; extra == "projects"
+Requires-Dist: ms_flow>=0.7.1; extra == "projects"
 Provides-Extra: pymol
 Requires-Dist: pymol-open-source>=3.2.0a0; extra == "pymol"
 Provides-Extra: steps
-Requires-Dist: ms_env>=0.2.0; extra == "steps"
+Requires-Dist: ms_env>=0.3.3; extra == "steps"
 Provides-Extra: table
 Requires-Dist: sqlmodel>=0.0.14; extra == "table"
 Provides-Extra: all

{ms_components-0.4.2 → ms_components-0.5.0}/pyproject.toml

@@ -31,9 +31,9 @@ dependencies = [
 
 [project.optional-dependencies]
 monitor = ["pydantic>=2.0"]
-projects = ["ms_flow>=0.2.0"]
+projects = ["ms_flow>=0.7.1"]
 pymol = ["pymol-open-source>=3.2.0a0"]
-steps = ["ms_env>=0.2.0"]
+steps = ["ms_env>=0.3.3"]
 table = ["sqlmodel>=0.0.14"]
 all = ["ms_components[monitor,projects,pymol,steps,table]"]
 # Test + development tooling.

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

@@ -8,7 +8,11 @@ be done now, and says why.
 """
 from __future__ import annotations
 
+import re
+import shlex
+import sys
 import threading
+import time
 import types
 from typing import Any, Literal, Union, get_args, get_origin
 
@@ -27,6 +31,7 @@ from PySide6.QtWidgets import (
     QListWidgetItem,
     QMessageBox,
     QPlainTextEdit,
+    QProgressBar,
     QPushButton,
     QRadioButton,
     QSpinBox,
@@ -35,7 +40,7 @@ from PySide6.QtWidgets import (
 )
 
 
-def _editor(field, value: Any, parent: QWidget, hosts=()) -> QWidget:
+def _editor(field, value: Any, parent: QWidget, names=()) -> QWidget:
     annotation, options = field.annotation, get_args(field.annotation)
     if get_origin(annotation) in (Union, types.UnionType) and options == (bool, type(None)):
         editor = QComboBox(parent)
@@ -45,13 +50,14 @@ def _editor(field, value: Any, parent: QWidget, hosts=()) -> QWidget:
         editor = QComboBox(parent)
         for option in options:
             editor.addItem(str(option), option)
-    elif get_origin(annotation) is list:  # names of hosts: the ones kept, to tick
+    elif list in (get_origin(annotation), *map(get_origin, options)):
+        # `names` to tick: the hosts kept, or the programs of the app; None ticks them all
         editor = QListWidget(parent)
         editor.setMaximumHeight(110)
-        for host in hosts:
-            item = QListWidgetItem("local (this computer)" if host == "local" else host, editor)
-            item.setData(Qt.ItemDataRole.UserRole, host)
-            item.setCheckState(Qt.CheckState.Checked if host in (value or ()) else Qt.CheckState.Unchecked)
+        for name in names:
+            item = QListWidgetItem("local (this computer)" if name == "local" else name, editor)
+            item.setData(Qt.ItemDataRole.UserRole, name)
+            item.setCheckState(Qt.CheckState.Checked if value is None or name in value else Qt.CheckState.Unchecked)
         return editor
     elif get_origin(annotation) is dict:
         editor = QPlainTextEdit("\n".join(f"{key} = {path}" for key, path in (value or {}).items()), parent)
@@ -90,6 +96,93 @@ def _value(editor: QWidget) -> Any:
     return editor.text().strip()
 
 
+class _Steps(QWidget):
+    """How far the preparation of a host got, what it is doing and for how long: moved by the
+    lines `[done/total] what` it says; `[0/0] what` is a wait with no steps to count."""
+
+    _LINE = re.compile(r"\[(\d+)/(\d+)\] (.*)")
+
+    def __init__(self, parent: QWidget) -> None:
+        super().__init__(parent)
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+        self.label = QLabel(self)
+        self.bar = QProgressBar(self)
+        self.bar.setTextVisible(False)
+        layout.addWidget(self.label)
+        layout.addWidget(self.bar)
+        self._what, self._since = "", 0.0
+        self._clock = QTimer(self)  # a step of minutes moves nothing else: the time spent says it is alive
+        self._clock.setInterval(1000)
+        self._clock.timeout.connect(self._tell)
+        self.setVisible(False)
+
+    def take(self, line: str) -> bool:
+        """Whether `line` was one of those, shown here then, not in the log."""
+        found = self._LINE.fullmatch(line)
+        if found:
+            done, total, what = int(found[1]), int(found[2]), found[3]
+            if what != self._what:
+                self._what, self._since = what, time.monotonic()
+            self.bar.setRange(0, total)  # 0 of 0: Qt shows it busy
+            self.bar.setValue(done)
+            self._tell()
+            self.setVisible(True)
+            self._clock.start()
+        return bool(found)
+
+    def full(self) -> bool:
+        return 0 < self.bar.maximum() == self.bar.value()
+
+    def _tell(self) -> None:
+        spent = int(time.monotonic() - self._since)
+        done, total = self.bar.value(), self.bar.maximum()
+        counted = f"  ·  step {done + 1} of {total}" if done < total else ""
+        self.label.setText(f"{self._what}  ·  {spent // 60}:{spent % 60:02d}{counted}")
+
+    def hideEvent(self, event) -> None:
+        self._clock.stop()
+        super().hideEvent(event)
+
+
+_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 +191,17 @@ class KeptPage(QWidget):
     """
 
     changed = Signal()
-
-    def __init__(self, workspace, table: str, parent: QWidget | None = None):
+    _checked = Signal(str)
+    _synced = Signal(str, bool)  # a line said there, and whether it is the last
+
+    def __init__(self, workspace, table: str, parent: QWidget | None = None, *, packages=("ms_flow", "ms_env"),
+                 default_env: str = "", programs=()):
+        """`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;
+        `programs`: the ones it can install there, to tick for each host (none: no choice shown)."""
         super().__init__(parent)
         self._workspace, self._table, self._one = workspace, table, table[:-1]
+        self._packages, self._default_env, self._programs = tuple(packages), default_env, tuple(programs)
         settings = type(workspace.settings_manager.settings)
         self._model = get_args(settings.model_fields[table].annotation)[1]
         self._editors: dict[str, QWidget] = {}
@@ -130,6 +230,25 @@ 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.sync_button = QPushButton("Sync", self)
+            self.sync_button.setToolTip("Install there, or bring up to date, the environment of the app and the "
+                                        "programs ticked, as saved. What is already as it is here is left alone.")
+            self.sync_button.clicked.connect(self._sync)
+            foot.addWidget(self.sync_button)
+            self.steps = _Steps(self)
+            self._right.addWidget(self.steps)
+            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)
+            self._synced.connect(self._sync_said)
         foot.addWidget(self.save_button)
         self._right.addStretch(1)
         self._right.addLayout(foot)
@@ -171,9 +290,12 @@ class KeptPage(QWidget):
         hosts = self._workspace.settings_manager.settings.hosts
         self._editors = {}
         for key, field in self._model.model_fields.items():
-            editor = self._editors[key] = _editor(field, getattr(entry, key, None), body, hosts)
+            names = self._programs if key == "install" else hosts
+            editor = self._editors[key] = _editor(field, getattr(entry, key, None), body, names)
             editor.setToolTip(field.description or "")
             form.addRow(field.title or key.replace("_", " ").capitalize(), editor)
+        if "install" in self._editors:  # this machine has its programs from the app's own settings
+            form.setRowVisible(self._editors["install"], bool(self._programs) and name != "local")
         kind = self._editors.get("kind")
         if name == "local":  # this machine and its pool: what they are is not a choice
             for fixed in ("address", "kind", "hosts"):
@@ -187,6 +309,10 @@ 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.steps.setVisible(False)
+            self.sync_button.setVisible(bool(name) and name != "local" and getattr(self._workspace, "host_env", None) is not None)
         self._right.insertWidget(0, body)
 
     def _only_of_kind(self) -> None:
@@ -226,6 +352,60 @@ 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 _sync(self) -> None:
+        """`Workspace.host_env` for the host as it is saved: what the app prepares there, made as it is here."""
+        name = self.names.currentItem().text()
+        host = self._kept()[name]
+        if host.env:
+            self._show_report(f"`{name}` names its own environment, {host.env}: the app prepares nothing there.")
+            return
+        users = [row["name"] for row in self._workspace.executors()
+                 if row["state"] in ("on", "starting") and name in row["hosts"]]
+        if users:  # what it runs would change under it
+            self._show_report(f"`{name}` is in use by `{users[0]}`, which is active: deactivate it first.")
+            return
+        self.sync_button.setEnabled(False)
+        self._show_report(f"Preparing {host.address}…")
+
+        def work() -> None:
+            try:
+                self._workspace.host_env(host.address, None, lambda line: self._synced.emit(line, False))
+                said = f"\n{name} is ready."
+            except Exception as error:  # noqa: BLE001 - said in the page, where it was asked for
+                said = f"\nCould not prepare {name}:\n{error}"
+            self._synced.emit(said, True)
+
+        threading.Thread(target=work, name="host-sync", daemon=True).start()
+
+    def _sync_said(self, line: str, last: bool) -> None:
+        if not self.steps.take(line):
+            self.report.appendPlainText(line)
+        self.sync_button.setEnabled(last)
+        if last:
+            self.steps.setVisible(False)
+
+    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?")
@@ -259,6 +439,7 @@ class ExecutorsPanel(QDialog):
         self.resize(640, 260)
         self._workspace = workspace
         self._busy: set[str] = set()  # the ones a thread of this panel is starting or stopping
+        self._waiting = ""  # the line the bar shows while they have no steps to count
         self._shown: Any = None
         self._body: QWidget | None = None
         self.buttons: dict[str, QPushButton] = {}
@@ -266,6 +447,8 @@ class ExecutorsPanel(QDialog):
         self.defaults: dict[str, QRadioButton] = {}
 
         self._layout = QVBoxLayout(self)
+        self.steps = _Steps(self)
+        self._layout.addWidget(self.steps)
         self.said = QPlainTextEdit(self)
         self.said.setReadOnly(True)
         self.said.setVisible(False)
@@ -345,18 +528,25 @@ class ExecutorsPanel(QDialog):
                 self.ended.emit(name, "")
 
         self._busy.add(name)
+        self._waiting = f"[0/0] {'stopping' if stop else 'starting'} {name}"
+        self.steps.take(self._waiting)
         self.refresh()
         threading.Thread(target=work, name=f"executor-{name}", daemon=True).start()
 
     def _say(self, text: str) -> None:
+        if self.steps.take(text):
+            if self.steps.full() and self._busy:  # its hosts are ready: it is still starting on them
+                self.steps.take(self._waiting)
+            return
         self.said.setVisible(True)
         self.said.appendPlainText(text)
 
     def _ended(self, name: str, error: str) -> None:
         self._busy.discard(name)
+        self.steps.setVisible(bool(self._busy))
         if error:
             self._say(f"{name}: {error}")
         self.refresh()
 
 
-__all__ = ["ExecutorsPanel", "KeptPage"]
+__all__ = ["ExecutorsPanel", "KeptPage", "describe_host"]

{ms_components-0.4.2 → ms_components-0.5.0}/src/ms_components/ms_monitor/__init__.py

@@ -4,8 +4,10 @@ from importlib import import_module
 
 _LAZY = {
     "FailureState": "models",
-    "JobDetailPanel": "detail_panel",
+    "HostsStrip": "resources",
+    "JobDetail": "detail",
     "JobDetailState": "models",
+    "JobList": "jobs",
     "JobMonitorState": "models",
     "MonitorConfig": "config",
     "MonitorSyncState": "models",

{ms_components-0.4.2 → ms_components-0.5.0}/src/ms_components/ms_monitor/bridge.py

@@ -105,10 +105,12 @@ class MolSuiteMonitorBridge(QObject):
         self._set_sync_state(in_progress=False, last_refresh_at=datetime.now())
         return self._poller.current_snapshot
 
-    def set_unfolded_jobs(self, job_ids) -> None:
-        """The jobs whose tasks in flight the next polls bring (`JobMonitorState.tasks`)."""
-        self._poller.unfolded = frozenset(job_ids)
-        self.request_refresh()
+    def select_job(self, job_id: str | None) -> None:
+        """The job whose tasks in flight and chunk states the next polls bring
+        (`JobMonitorState.tasks`, `JobMonitorState.chunk_states`): one at a time."""
+        if self._poller.selected != job_id:
+            self._poller.selected = job_id
+            self.request_refresh()
 
     def get_job_detail(self, job_id: str | None, *, failure_limit: int = 200) -> JobDetailState | None:
         """The job as last polled plus its failed chunks, read from the project's journal."""