gini-toolkit 6.0.1.dev0__py3-none-any.whl

gini/ui/process_tree.py

@@ -0,0 +1,130 @@
+"""Live process tree for the Machine Lab — the process hierarchy as a tree, not a flat table.
+
+Built from each process's parent link (ppid, from gini_dump). fork() adds a child, exec() relabels,
+exit() shows a zombie, wait() reaps it, and an exiting parent's children re-parent to init — all
+visible as the tree changes. State is colour-coded; the running process(es) are highlighted; user
+processes get a kill affordance. Driven entirely by the live serial dump (no gdb).
+"""
+from __future__ import annotations
+
+from PySide6.QtCore import Qt, Signal
+from PySide6.QtGui import QColor, QFont
+from PySide6.QtWidgets import QHeaderView, QPushButton, QTreeWidget, QTreeWidgetItem
+
+from ..domain.xv6 import build_process_tree
+from .theme import ThemeManager
+from .theme.manager import scale_css as _scss
+
+_STATE_ACCENT = {"running": "green", "runnable": "amber", "sleeping": "slate",
+                 "zombie": "red", "used": "slate", "unused": "slate"}
+
+
+class ProcessTree(QTreeWidget):
+    """A QTreeWidget rendering of the process hierarchy. `kill_requested(pid)` fires when the
+    user clicks a process's kill affordance (never shown for init/sh)."""
+
+    kill_requested = Signal(int)
+
+    def __init__(self, theme: ThemeManager) -> None:
+        super().__init__()
+        self.theme = theme
+        self._live = False
+        self._killing: set = set()      # pids with a kill in flight -> show a pending state
+        self.setColumnCount(4)
+        self.setHeaderLabels(["process", "pid", "state", ""])
+        self.setRootIsDecorated(True)
+        self.setIndentation(16)
+        self.setSelectionMode(QTreeWidget.NoSelection)
+        self.setFocusPolicy(Qt.NoFocus)
+        self.setColumnWidth(1, 48)
+        self.setColumnWidth(3, 84)
+        self.header().setSectionResizeMode(0, QHeaderView.Stretch)
+        t = theme.theme
+        self.setStyleSheet(
+            f"QTreeWidget{{background:{t.panel};color:{t.text};border:none;font-size:12px;"
+            f"outline:none;}}"
+            f"QHeaderView::section{{background:{t.panel2};color:{t.muted};border:none;"
+            "padding:4px;}"
+            f"QTreeWidget::item{{padding:2px 0;}}")
+
+    def set_live(self, live: bool) -> None:
+        self._live = live
+
+    def set_procs(self, procs, running_pids=(), flags=None) -> None:
+        """Rebuild the tree from the current process list. `running_pids` are highlighted; `flags`
+        maps pid -> a short reason string (e.g. 'starving') that badges the process."""
+        t = self.theme.theme
+        running = set(running_pids or [])
+        flags = flags or {}
+        self._killing &= {p.pid for p in procs}   # drop pending marks for procs that are now gone
+        self.clear()
+        items: dict = {}          # pid -> QTreeWidgetItem
+        for node in build_process_tree(procs):
+            p = node.proc
+            parent_item = items.get(p.parent)
+            it = QTreeWidgetItem(parent_item if parent_item is not None else self)
+            it.setText(0, p.name)
+            it.setText(1, str(p.pid))
+            it.setText(2, p.state)
+            color = QColor(t.accent_for(_STATE_ACCENT.get(p.state, "slate")))
+            it.setForeground(2, color)
+            if p.pid in running:
+                it.setForeground(0, color)
+                f = it.font(0); f.setBold(True); it.setFont(0, f)
+            elif p.state == "zombie":
+                for c in (0, 1, 2):
+                    it.setForeground(c, QColor(t.faint))
+            if p.pid in flags:                        # scheduling badge (e.g. starvation)
+                reason = flags[p.pid]
+                it.setText(2, f"{p.state}  ⚠ {reason}")
+                it.setForeground(2, QColor(t.accent_for("red")))
+                it.setToolTip(2, reason)
+            items[p.pid] = it
+            if self._live and p.pid > 2:          # kill affordance (never init/sh)
+                self.setItemWidget(it, 3, self._kill_button(p.pid))
+        self.expandAll()
+
+    def _kill_button(self, pid: int) -> QPushButton:
+        """A proper labelled Kill button (the old bare ✕ was easy to miss), with a persistent
+        'killing…' pending state so the click visibly registers even while the kill lands."""
+        t = self.theme.theme
+        pending = pid in self._killing
+        red = t.accent_for("red")
+        b = QPushButton("killing…" if pending else "Kill")
+        b.setFixedHeight(20)
+        b.setToolTip(f"kill pid {pid}")
+        b.setCursor(Qt.PointingHandCursor)
+        if pending:
+            b.setEnabled(False)
+            b.setStyleSheet(_scss(
+                f"QPushButton{{color:{t.faint};background:transparent;border:1px solid {t.line};"
+                "border-radius:5px;padding:0 8px;font-size:11px;}"))
+        else:
+            b.setStyleSheet(_scss(
+                f"QPushButton{{color:{red};background:transparent;border:1px solid {red};"
+                "border-radius:5px;padding:0 8px;font-size:11px;font-weight:600;}"
+                f"QPushButton:hover{{color:#ffffff;background:{red};}}"))
+            b.clicked.connect(lambda _c=False, p=pid: self._on_kill_clicked(p))
+        return b
+
+    def _on_kill_clicked(self, pid: int) -> None:
+        self._killing.add(pid)                 # mark pending; survives the ~0.5s tree rebuilds
+        it = self._find_item(pid)
+        if it is not None:                     # flip THIS button to the pending state immediately
+            self.setItemWidget(it, 3, self._kill_button(pid))
+        self.kill_requested.emit(pid)
+
+    def _find_item(self, pid: int):
+        def walk(it):
+            if it.text(1) == str(pid):
+                return it
+            for i in range(it.childCount()):
+                r = walk(it.child(i))
+                if r is not None:
+                    return r
+            return None
+        for i in range(self.topLevelItemCount()):
+            r = walk(self.topLevelItem(i))
+            if r is not None:
+                return r
+        return None

gini/ui/reset_dialog.py

@@ -0,0 +1,179 @@
+"""Hardware → Reset a Board: release a board's pairing, over USB.
+
+A claimed board answers only the laptop that owns it and is invisible to every other
+gBuilder. That is what stops thirty laptops in a room from stealing each other's
+hardware — but it means a board claimed by the wrong laptop looks, from the student's
+side, exactly like a board that is simply broken: it powers up, joins the Wi-Fi, and
+never appears on anyone's canvas.
+
+There is deliberately no timed auto-release: a board must never re-open itself while its
+owner is at lunch. Physical possession is the authority instead — and USB *is* what
+physical possession means in software. Hence this dialog: whoever is holding the board
+can always take it back, and nobody else can.
+"""
+from __future__ import annotations
+
+from PySide6.QtCore import QObject, Qt, Signal
+from PySide6.QtWidgets import (
+    QComboBox, QDialog, QDialogButtonBox, QFormLayout, QHBoxLayout, QLabel,
+    QMessageBox, QPushButton, QVBoxLayout,
+)
+
+from ..services import boardsetup as bs
+from .worker_host import WorkerHost
+
+
+def _note(text: str) -> QLabel:
+    lab = QLabel(text)
+    lab.setWordWrap(True)
+    lab.setStyleSheet("color: palette(mid);")
+    return lab
+
+
+class _Scan(QObject):
+    done = Signal(list, list)
+    failed = Signal(str)
+
+    def run(self) -> None:
+        try:
+            boards, others = bs.detect_boards()
+            self.done.emit(boards, others)
+        except Exception as e:
+            self.failed.emit(str(e))
+
+
+class _Unpair(QObject):
+    done = Signal(bool, str)
+
+    def __init__(self, port: str) -> None:
+        super().__init__()
+        self._port = port
+
+    def run(self) -> None:
+        try:
+            with bs.BoardConsole(self._port) as con:
+                if not con.wait_for_prompt():
+                    self.done.emit(False, "the board never reached its prompt — unplug "
+                                          "it, plug it back in, and try again")
+                    return
+                ok, msg = con.unpair()
+                self.done.emit(ok, msg)
+        except Exception as e:
+            self.done.emit(False, str(e))
+
+
+class ResetBoardDialog(WorkerHost, QDialog):
+    """Pick a plugged-in board and release whoever owns it."""
+
+    def __init__(self, parent=None) -> None:
+        super().__init__(parent)
+        self.setWindowTitle("Reset a Board")
+        self.setMinimumWidth(560)
+        self._alive = True
+        self._thread = None
+        self._worker = None
+        self._connections = []
+
+        root = QVBoxLayout(self)
+        root.addWidget(_note(
+            "Releases a board's pairing, so any gBuilder can claim it again.<br><br>"
+            "Use this when a board is online and healthy but never appears on the "
+            "canvas — that usually means another laptop claimed it. Settings, id and "
+            "Wi-Fi are kept; only the pairing is cleared."))
+
+        form = QFormLayout()
+        self.board = QComboBox()
+        row = QHBoxLayout()
+        row.addWidget(self.board, 1)
+        self.rescan = QPushButton("Rescan")
+        self.rescan.clicked.connect(self.scan)
+        row.addWidget(self.rescan)
+        form.addRow("Board", row)
+        self.owner = QLabel("—")
+        form.addRow("Claimed by", self.owner)
+        root.addLayout(form)
+
+        self.status = _note("")
+        root.addWidget(self.status)
+
+        self.buttons = QDialogButtonBox(QDialogButtonBox.Cancel)
+        self.reset_btn = QPushButton("Release")
+        self.reset_btn.setDefault(True)
+        self.buttons.addButton(self.reset_btn, QDialogButtonBox.AcceptRole)
+        self.reset_btn.clicked.connect(self._reset)
+        self.buttons.rejected.connect(self.reject)
+        root.addWidget(self.buttons)
+
+        self.board.currentIndexChanged.connect(self._board_changed)
+        self.scan()
+
+    def scan(self) -> None:
+        self._busy(True, "looking for boards…")
+        self._run(_Scan(), self._scanned)
+
+    def _scanned(self, boards: list, others: list) -> None:
+        if not self._alive:
+            return
+        self._boards = boards
+        self.board.blockSignals(True)
+        self.board.clear()
+        for b in boards:
+            self.board.addItem(f"{b.board_id or '(no id)'} — {b.port}", b.port)
+        self.board.blockSignals(False)
+        self._busy(False, "")
+        if not boards:
+            self.owner.setText("—")
+            self.reset_btn.setEnabled(False)
+            self.status.setText(
+                "No board found. Plug one in with a <b>data</b> USB cable."
+                + (f" ({len(others)} other serial device(s) seen.)" if others else ""))
+            return
+        self._board_changed()
+
+    def _board_changed(self) -> None:
+        if not self._alive or self.board.currentIndex() < 0:
+            return
+        b = self._boards[self.board.currentIndex()]
+        owner = (getattr(b, "owner", "") or "").strip()
+        self.owner.setText(owner or "not claimed")
+        # Releasing an unclaimed board is harmless, so it stays enabled: the point is to
+        # let someone who suspects a stuck claim just try it and see.
+        self.reset_btn.setEnabled(True)
+
+    def _reset(self) -> None:
+        if self.board.currentIndex() < 0:
+            return
+        self._busy(True, "releasing…")
+        self._run(_Unpair(self.board.currentData()), self._done)
+
+    def _done(self, ok: bool, msg: str) -> None:
+        if not self._alive:
+            return
+        self._busy(False, "")
+        if not ok:
+            QMessageBox.warning(self, "Could not release the board", msg)
+            self.status.setText(msg)
+            return
+        QMessageBox.information(self, "Board released", msg)
+        self.accept()
+
+    def _worker_failed(self, message: str) -> None:
+        if self._alive:
+            self._busy(False, "")
+            self.status.setText(message)
+
+    def closeEvent(self, event) -> None:
+        self._detach()
+        super().closeEvent(event)
+
+    def reject(self) -> None:
+        self._detach()
+        super().reject()
+
+    def _busy(self, busy: bool, message: str) -> None:
+        if not self._alive:
+            return
+        self.status.setText(message)
+        self.rescan.setEnabled(not busy)
+        self.reset_btn.setEnabled(not busy)
+        self.setCursor(Qt.WaitCursor if busy else Qt.ArrowCursor)