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

gini/ui/author_dialog.py

@@ -0,0 +1,184 @@
+"""Author a fragment — teacher mode.
+
+The composer, built on what already exists: you build the winning arrangement on the real canvas,
+this reads it into candidate objectives (by demonstration), you confirm/prune, optionally add a
+difficulty **fork**, and finalize — which validates and writes the blessed YAML to the user content
+layer (`~/.gini/content/fragments`). "Test" is the same Run/Check students use, so a fragment is
+proven gradable by the real engine before it ships.
+
+Deliberately a dialog over the live canvas rather than a new editor: the canvas IS the board, and the
+mission engine IS the grader. We only add the authoring controls around them.
+"""
+from __future__ import annotations
+
+from PySide6.QtCore import Qt
+from PySide6.QtWidgets import (
+    QCheckBox, QComboBox, QDialog, QDialogButtonBox, QFormLayout, QHBoxLayout, QLabel, QLineEdit,
+    QListWidget, QListWidgetItem, QMessageBox, QPushButton, QVBoxLayout, QWidget,
+)
+
+from ..domain import authoring as _au
+
+
+class AuthorDialog(QDialog):
+    def __init__(self, parent, ctx, *, author: str = "") -> None:
+        super().__init__(parent)
+        self.ctx = ctx
+        self._author = author
+        self._objs: list[dict] = []            # core objectives (dicts)
+        self._fork_objs: list[dict] = []       # objectives on the harder fork (optional)
+        self.setWindowTitle("Author a fragment")
+        self.setMinimumWidth(560)
+
+        root = QVBoxLayout(self)
+        root.addWidget(QLabel("<b>Author a fragment from what you've built on the canvas.</b> "
+                              "Build the winning arrangement, read off the objectives, then finalize.",
+                              wordWrap=True))
+
+        form = QFormLayout()
+        self.fid = QLineEdit(); self.fid.setPlaceholderText("a short id, e.g. private-db-vpc")
+        form.addRow("Fragment id", self.fid)
+        self.teaches = QLineEdit(); self.teaches.setPlaceholderText("concept key, e.g. vpc-networking")
+        form.addRow("Teaches", self.teaches)
+        self.summary = QLineEdit(); self.summary.setPlaceholderText("one line the student sees")
+        form.addRow("Summary", self.summary)
+        self.spirit = QLineEdit()
+        self.spirit.setPlaceholderText("mechanism-free goal (what 'done' means, not how)")
+        form.addRow("Spirit", self.spirit)
+        root.addLayout(form)
+
+        # --- core objectives (derived from the canvas) -----------------------
+        head = QHBoxLayout()
+        head.addWidget(QLabel("<b>Objectives</b> — derived from your canvas:"))
+        head.addStretch(1)
+        derive = QPushButton("⟲ Read from canvas")
+        derive.clicked.connect(self._derive)
+        head.addWidget(derive)
+        root.addLayout(head)
+        self.obj_list = QListWidget()
+        self.obj_list.setMaximumHeight(150)
+        root.addWidget(self.obj_list)
+        rm = QPushButton("Remove selected objective"); rm.clicked.connect(self._remove_obj)
+        root.addWidget(rm)
+
+        # --- fork (optional difficulty branch) -------------------------------
+        self.fork_on = QCheckBox("Add a harder fork (the difficulty knob — earns gold)")
+        self.fork_on.toggled.connect(self._toggle_fork)
+        root.addWidget(self.fork_on)
+        self._fork_box = QWidget(); fb = QVBoxLayout(self._fork_box); fb.setContentsMargins(16, 0, 0, 0)
+        frow = QHBoxLayout()
+        self.fork_label = QLineEdit(); self.fork_label.setPlaceholderText("what the harder way is")
+        frow.addWidget(self.fork_label, 1)
+        self.fork_kind = QComboBox(); self.fork_kind.addItems(["converge", "diverge"])
+        self.fork_kind.setToolTip("converge = a harder way to the SAME goal · diverge = a different path")
+        frow.addWidget(self.fork_kind)
+        fb.addLayout(frow)
+        fhead = QHBoxLayout()
+        fhead.addWidget(QLabel("Fork objectives — build the harder solution, then:"))
+        fhead.addStretch(1)
+        fderive = QPushButton("⟲ Read fork from canvas"); fderive.clicked.connect(self._derive_fork)
+        fhead.addWidget(fderive)
+        fb.addLayout(fhead)
+        self.fork_list = QListWidget(); self.fork_list.setMaximumHeight(100)
+        fb.addWidget(self.fork_list)
+        self._fork_box.setVisible(False)
+        root.addWidget(self._fork_box)
+
+        self.note = QLabel(""); self.note.setWordWrap(True)
+        root.addWidget(self.note)
+
+        bb = QDialogButtonBox()
+        self.test_btn = bb.addButton("Test on canvas", QDialogButtonBox.ActionRole)
+        self.save_btn = bb.addButton("Finalize & save", QDialogButtonBox.AcceptRole)
+        bb.addButton("Cancel", QDialogButtonBox.RejectRole)
+        self.test_btn.clicked.connect(self._test)
+        self.save_btn.clicked.connect(self._finalize)
+        bb.rejected.connect(self.reject)
+        root.addWidget(bb)
+
+    # -- objective derivation ------------------------------------------------ #
+    def _derive(self) -> None:
+        self._objs = _au.derive_objectives(self.ctx.topology)
+        self._render(self.obj_list, self._objs)
+        if not self._objs:
+            self._warn("The canvas is empty — place the winning arrangement first, then read it.")
+        else:
+            self._info(f"Read {len(self._objs)} objective(s). Prune any you don't want to grade.")
+
+    def _derive_fork(self) -> None:
+        # the fork's objectives are whatever is on the canvas NOW that isn't already a core objective
+        core_checks = {o["check"] for o in self._objs}
+        cand = [o for o in _au.derive_objectives(self.ctx.topology) if o["check"] not in core_checks]
+        for o in cand:                          # keep fork objective ids distinct from core
+            o["id"] = "fork-" + o["id"]
+        self._fork_objs = cand
+        self._render(self.fork_list, self._fork_objs)
+        self._info(f"Fork: {len(cand)} objective(s) beyond the core.")
+
+    def _render(self, widget: QListWidget, objs: list[dict]) -> None:
+        widget.clear()
+        for o in objs:
+            it = QListWidgetItem(f"L{o['level']}   {o['say']}   ·   {o['check']}")
+            it.setData(Qt.UserRole, o["id"])
+            widget.addItem(it)
+
+    def _remove_obj(self) -> None:
+        row = self.obj_list.currentRow()
+        if 0 <= row < len(self._objs):
+            del self._objs[row]
+            self._render(self.obj_list, self._objs)
+
+    def _toggle_fork(self, on: bool) -> None:
+        self._fork_box.setVisible(on)
+        self.adjustSize()
+
+    # -- build the dict ------------------------------------------------------ #
+    def _dict(self) -> dict | None:
+        fid = self.fid.text().strip()
+        if not fid:
+            self._warn("Give the fragment an id."); return None
+        if not self._objs:
+            self._warn("Read at least one objective from the canvas."); return None
+        forks = None
+        if self.fork_on.isChecked() and self._fork_objs:
+            forks = [{"id": "hard", "label": self.fork_label.text().strip(),
+                      "difficulty": 2, "kind": self.fork_kind.currentText(),
+                      "objectives": self._fork_objs}]
+        return _au.build_fragment_dict(
+            frag_id=fid, teaches=self.teaches.text().strip(), summary=self.summary.text().strip(),
+            spirit=self.spirit.text().strip(), objectives=self._objs, forks=forks,
+            author=self._author)
+
+    def _test(self) -> None:
+        """Validate structurally, then hand the teacher a real playtest: build the fragment, drop into
+        it as a mission, and use Run/Check. Here we just validate + confirm gradability; the caller
+        launches the live mission."""
+        d = self._dict()
+        if d is None:
+            return
+        problems = _au.validate_dict(d)
+        if problems:
+            self._warn("Not gradable yet: " + "; ".join(problems))
+            return
+        self._info("Valid + gradable. Finalize to save, or keep refining. "
+                   "(Play it as a mission to prove it winnable against real Docker.)")
+
+    def _finalize(self) -> None:
+        d = self._dict()
+        if d is None:
+            return
+        try:
+            path = _au.save_fragment(d)
+        except ValueError as e:
+            self._warn(f"Can't save — not gradable: {e}")
+            return
+        from ..domain import fragments as _frag
+        _frag.reload()                          # pick the new fragment up immediately
+        QMessageBox.information(self, "Saved",
+                                f"Fragment '{d['id']}' saved and loaded.\n\n{path}\n\n"
+                                f"Upload it to the Teaching Center to compose experiments from it.")
+        self.accept()
+
+    # -- notes --------------------------------------------------------------- #
+    def _warn(self, msg): self.note.setText(msg); self.note.setStyleSheet("color:#d9534f;font-weight:600;")
+    def _info(self, msg): self.note.setText(msg); self.note.setStyleSheet("color:#3fb950;")

gini/ui/board_dialog.py

@@ -0,0 +1,247 @@
+"""Hardware → Set Up a Board: give a GINI32 board the lab Wi-Fi, over USB.
+
+This is the only step in the whole GINI32 story that needs a cable, and a student
+does it once per board. Everything the dialog writes is the minimum a board
+cannot work out for itself; its address, gateway, hotspot and subnet all still
+come from the canvas when it checks in.
+
+The serial work happens on a worker thread. Talking to a board takes a couple of
+seconds — it reboots when the port is opened — and freezing the window for that
+long makes a working setup look like a hang.
+"""
+from __future__ import annotations
+
+from PySide6.QtCore import QObject, Qt, Signal
+from PySide6.QtWidgets import (
+    QComboBox, QDialog, QDialogButtonBox, QFormLayout, QHBoxLayout, QLabel,
+    QLineEdit, QMessageBox, QPushButton, QVBoxLayout, QWidget,
+)
+
+from ..services import boardsetup as bs
+from .worker_host import WorkerHost, _LIVE_THREADS       # noqa: F401 (tests inspect it)
+
+
+def _note(text: str) -> QLabel:
+    lab = QLabel(text)
+    lab.setWordWrap(True)
+    lab.setStyleSheet("color: palette(mid);")
+    return lab
+
+
+class _Scan(QObject):
+    """Finds boards on a worker thread (opening a port resets and waits for it)."""
+    done = Signal(list, list)          # [BoardInfo], [PortInfo]
+    failed = Signal(str)
+
+    def run(self) -> None:
+        try:
+            boards, others = bs.detect_boards()
+            self.done.emit(boards, others)
+        except Exception as e:                       # never let a USB oddity kill the UI
+            self.failed.emit(str(e))
+
+
+class _Apply(QObject):
+    """Writes settings to one board, off the GUI thread."""
+    done = Signal(bool, str)
+
+    def __init__(self, port: str, ssid: str, password: str, board_id: str) -> None:
+        super().__init__()
+        self._args = (port, ssid, password, board_id)
+
+    def run(self) -> None:
+        port, ssid, password, board_id = self._args
+        try:
+            with bs.BoardConsole(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.apply(ssid, password, board_id)
+                self.done.emit(ok, msg)
+        except Exception as e:
+            self.done.emit(False, str(e))
+
+
+class BoardSetupDialog(WorkerHost, QDialog):
+    """Pick a plugged-in board, confirm the details, write them."""
+
+    def __init__(self, parent, settings, known_ids: list[str] | None = None) -> None:
+        super().__init__(parent)
+        self.setWindowTitle("Set Up a GINI32 Board")
+        self.setMinimumWidth(560)
+        self._settings = settings
+        self._known_ids = list(known_ids or [])
+        self._boards: list[bs.BoardInfo] = []
+        self._thread: QThread | None = None
+        self._worker: QObject | None = None   # kept alive; see _run()
+        self._connections: list = []          # (signal, slot) pairs cut on close
+        self._alive = True          # cleared on close: workers must stop touching us
+        self.applied_id = ""
+
+        root = QVBoxLayout(self)
+        root.addWidget(_note(
+            "Plug a board into this computer with a USB cable. This is the only step "
+            "that needs a cable — after it, the board works over Wi-Fi."))
+
+        form = QFormLayout()
+        row = QHBoxLayout()
+        self.board = QComboBox()
+        self.board.setMinimumWidth(320)
+        row.addWidget(self.board, 1)
+        self.rescan = QPushButton("Rescan")
+        self.rescan.clicked.connect(self.scan)
+        row.addWidget(self.rescan)
+        holder = QWidget()
+        holder.setLayout(row)
+        form.addRow("Board", holder)
+
+        self.ssid = QLineEdit(getattr(settings, "board_wifi_ssid", "") or "")
+        self.ssid.setPlaceholderText("the Wi-Fi this laptop is on — 2.4 GHz")
+        form.addRow("Lab Wi-Fi name", self.ssid)
+        self.password = QLineEdit(getattr(settings, "board_wifi_password", "") or "")
+        self.password.setEchoMode(QLineEdit.Password)
+        form.addRow("Lab Wi-Fi password", self.password)
+        self.board_id = QLineEdit()
+        self.board_id.setPlaceholderText("gini-1")
+        form.addRow("Name this board", self.board_id)
+        root.addLayout(form)
+
+        self.status = _note("")
+        root.addWidget(self.status)
+        root.addWidget(_note(
+            "The name you give the board is what you type into the GINI32 element's "
+            "BoardID on the canvas — pick something short you can read off a sticker."))
+
+        self.buttons = QDialogButtonBox(QDialogButtonBox.Cancel)
+        self.apply_btn = self.buttons.addButton("Set Up Board",
+                                                QDialogButtonBox.AcceptRole)
+        self.apply_btn.clicked.connect(self._apply)
+        self.buttons.rejected.connect(self.reject)
+        root.addWidget(self.buttons)
+
+        self.board.currentIndexChanged.connect(self._board_changed)
+        self.scan()
+
+    # ---------------------------------------------------------------- scanning
+
+    def scan(self) -> None:
+        self._busy(True, "Looking for boards…")
+        self.board.clear()
+        self._run(_Scan(), self._scanned)
+
+    def _worker_failed(self, message: str) -> None:
+        if self._alive:
+            self._busy(False, f"Could not look for boards: {message}")
+
+    def _scanned(self, boards: list, others: list) -> None:
+        if not self._alive:          # the dialog was closed while we were scanning
+            return
+        self._boards = boards
+        self.board.clear()
+        for b in boards:
+            label = b.board_id or "(unnamed board)"
+            if b.configured:
+                label += f"   — set up for '{b.ssid}'"
+            else:
+                label += "   — not set up yet"
+            self.board.addItem(f"{label}   [{b.port}]", b.port)
+
+        if boards:
+            self._busy(False, f"Found {len(boards)} board"
+                              f"{'s' if len(boards) != 1 else ''}.")
+        elif others:
+            names = ", ".join(o.device for o in others[:3])
+            self._busy(False,
+                       f"Serial devices found ({names}), but none answered as a GINI32 "
+                       f"board. Is the gBridge firmware flashed on it?")
+        else:
+            self._busy(False,
+                       "No board found. Check the cable is plugged in at both ends — "
+                       "and that it is a DATA cable: many USB cables carry power only, "
+                       "which looks exactly like a dead board.")
+        self._board_changed()
+
+    def _board_changed(self) -> None:
+        """Suggest a name that does not collide with one already in use."""
+        b = self._selected()
+        if b is None:
+            return
+        if b.board_id and b.board_id not in ("gini32-1",):   # keep a real, chosen name
+            self.board_id.setText(b.board_id)
+        else:
+            taken = self._known_ids + [x.board_id for x in self._boards
+                                       if x is not b and x.board_id]
+            self.board_id.setText(bs.suggest_board_id(taken))
+        if b.ssid and not self.ssid.text().strip():
+            self.ssid.setText(b.ssid)
+
+    def _selected(self) -> bs.BoardInfo | None:
+        port = self.board.currentData()
+        return next((b for b in self._boards if b.port == port), None)
+
+    # ---------------------------------------------------------------- applying
+
+    def _apply(self) -> None:
+        b = self._selected()
+        if b is None:
+            QMessageBox.information(self, "No board selected",
+                                    "Plug a board in and press Rescan.")
+            return
+        ssid = self.ssid.text().strip()
+        pw = self.password.text()
+        bid = self.board_id.text().strip()
+        if not ssid:
+            QMessageBox.warning(self, "Wi-Fi name needed",
+                                "Enter the name of the Wi-Fi network this laptop is on. "
+                                "The board joins it to reach gBuilder.")
+            return
+        if not bid:
+            QMessageBox.warning(self, "Name needed",
+                                "Give the board a short name — it is how the canvas "
+                                "refers to it.")
+            return
+        self._busy(True, f"Setting up '{bid}'…")
+        self._run(_Apply(b.port, ssid, pw, bid), self._applied)
+
+    def _applied(self, ok: bool, msg: str) -> None:
+        if not self._alive:
+            return
+        self._busy(False, "")
+        if not ok:
+            QMessageBox.warning(self, "Setup failed", msg)
+            return
+        # Remember the lab Wi-Fi so the next board is a single click.
+        try:
+            self._settings.board_wifi_ssid = self.ssid.text().strip()
+            self._settings.board_wifi_password = self.password.text()
+        except Exception:
+            pass
+        self.applied_id = self.board_id.text().strip()
+        QMessageBox.information(
+            self, "Board is set up",
+            f"{msg}.\n\nThe board is restarting and will join the Wi-Fi on its own. "
+            f"You can unplug it now — it only needs power from here on.\n\n"
+            f"Use '{self.applied_id}' as the BoardID on the canvas.")
+        self.accept()
+
+    # ------------------------------------------------------------------- utils
+
+    # _run() and _detach() now come from WorkerHost — one copy of the threading
+    # rules, shared with the flash dialog. See ui/worker_host.py.
+
+    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.apply_btn.setEnabled(not busy)
+        self.setCursor(Qt.WaitCursor if busy else Qt.ArrowCursor)

gini/ui/branding.py

@@ -0,0 +1,21 @@
+"""App branding — the GINI mascot used as the window / taskbar / dock icon."""
+from __future__ import annotations
+
+from functools import lru_cache
+from pathlib import Path
+
+from PySide6.QtGui import QIcon
+
+ASSETS = Path(__file__).parent / "assets"
+APP_ICON_PNG = ASSETS / "app_icon.png"
+APP_ICON_ICNS = ASSETS / "app_icon.icns"
+
+
+def icon_path() -> str:
+    return str(APP_ICON_PNG)
+
+
+@lru_cache(maxsize=1)
+def app_icon() -> QIcon:
+    """The GINI mascot as a QIcon (empty if the asset is missing — never crashes)."""
+    return QIcon(str(APP_ICON_PNG)) if APP_ICON_PNG.exists() else QIcon()