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

gini/ui/run_button.py

@@ -0,0 +1,183 @@
+"""One morphing circular power button that replaces the separate Run / Stop
+toolbar actions.
+
+States (driven by MainWindow from the real run lifecycle):
+
+  * ready    — green disc, white ▶ glyph. Click launches the topology.
+  * booting  — a progress ring fills clockwise to (containers up / total) as the
+               fabric comes online; a soft core pulses. Click cancels (stops).
+  * running  — accent disc, white ■ stop glyph, a gentle green "alive" breathing
+               ring. Click stops.
+  * stopping — muted disc with an indeterminate rotating arc while it winds down.
+  * error    — red disc, white ▶ (retry), a pulsing red halo.
+
+The widget only *paints* state; MainWindow decides what a click means and calls
+`set_state` / `set_progress` at the right lifecycle points.
+"""
+from __future__ import annotations
+
+import math
+
+from PySide6.QtCore import QRectF, QSize, Qt, QTimer, Signal
+from PySide6.QtGui import QColor, QPainter, QPen, QPolygonF, QRadialGradient
+from PySide6.QtCore import QPointF
+from PySide6.QtWidgets import QWidget
+
+_ANIM_STATES = {"booting", "running", "stopping", "error"}
+
+
+class RunButton(QWidget):
+    clicked = Signal()          # user pressed the button (MainWindow decides run vs stop)
+
+    def __init__(self, theme, parent=None) -> None:
+        super().__init__(parent)
+        self.theme = theme
+        self._state = "ready"
+        self._frac = 0.0           # eased boot-progress fraction actually drawn
+        self._target = 0.0         # up / total
+        self._up = self._total = 0
+        self._phase = 0.0          # animation phase (pulse / spin)
+        self._hover = False
+        self.setFixedSize(40, 34)
+        self.setCursor(Qt.PointingHandCursor)
+        self._refresh_tip()
+        self._timer = QTimer(self)
+        self._timer.setInterval(33)
+        self._timer.timeout.connect(self._tick)
+
+    # -- state in --------------------------------------------------------------
+    def set_state(self, state: str) -> None:
+        if state not in ("ready", "booting", "running", "stopping", "error"):
+            return
+        self._state = state
+        if state == "ready":
+            self._target = self._frac = 0.0
+            self._up = self._total = 0
+        elif state == "running":
+            self._target = 1.0
+        if state in _ANIM_STATES and not self._timer.isActive():
+            self._timer.start()
+        elif state not in _ANIM_STATES and self._timer.isActive():
+            self._timer.stop(); self._phase = 0.0
+        self._refresh_tip()
+        self.update()
+
+    def set_progress(self, up: int, total: int) -> None:
+        self._up, self._total = int(up), int(total)
+        self._target = (up / total) if total else 0.0
+        self._refresh_tip()
+        self.update()
+
+    def state(self) -> str:
+        return self._state
+
+    def _refresh_tip(self) -> None:
+        tip = {
+            "ready": "Run — launch this topology on Docker",
+            "booting": (f"Starting… {self._up}/{self._total} containers up"
+                        if self._total else "Starting the topology…"),
+            "running": "Running — click to stop",
+            "stopping": "Stopping…",
+            "error": "Run failed — click to try again",
+        }[self._state]
+        self.setToolTip(tip)
+
+    # -- animation -------------------------------------------------------------
+    def _tick(self) -> None:
+        self._phase = (self._phase + 0.12) % (math.tau)
+        # ease the drawn fraction toward the real target so the ring glides
+        self._frac += (self._target - self._frac) * 0.25
+        self.update()
+
+    # -- theme hook (called by MainWindow on theme change) ---------------------
+    def refresh_theme(self) -> None:
+        self.update()
+
+    # -- input -----------------------------------------------------------------
+    def enterEvent(self, _e) -> None:
+        self._hover = True; self.update()
+
+    def leaveEvent(self, _e) -> None:
+        self._hover = False; self.update()
+
+    def mouseReleaseEvent(self, e) -> None:
+        if e.button() == Qt.LeftButton and self.rect().contains(e.position().toPoint()):
+            self.clicked.emit()
+        super().mouseReleaseEvent(e)
+
+    def sizeHint(self) -> QSize:
+        return QSize(40, 34)
+
+    # -- paint -----------------------------------------------------------------
+    def _disc_color(self) -> QColor:
+        t = self.theme.theme
+        return {
+            "ready": QColor(t.success),
+            "booting": QColor(t.success).darker(155),   # dim so the progress ring pops
+            "running": QColor(t.accent),
+            "stopping": QColor(t.muted),
+            "error": QColor(t.danger),
+        }[self._state]
+
+    def paintEvent(self, _e) -> None:
+        t = self.theme.theme
+        p = QPainter(self)
+        p.setRenderHint(QPainter.Antialiasing, True)
+        w, h = self.width(), self.height()
+        cx, cy = w / 2.0, h / 2.0
+        r = min(w, h) / 2.0 - 4.0
+        disc = self._disc_color()
+
+        # ambient halo: hover on any state, plus the pulsing error / alive glow
+        halo = 0.0
+        if self._state == "error":
+            halo = 0.55 + 0.45 * math.sin(self._phase * 2)
+        elif self._state == "running":
+            halo = 0.25 + 0.20 * math.sin(self._phase)
+        elif self._hover:
+            halo = 0.5
+        if halo > 0.01:
+            glow_col = QColor(t.success) if self._state == "running" else disc
+            grad = QRadialGradient(cx, cy, r + 6)
+            gc = QColor(glow_col); gc.setAlpha(int(120 * halo))
+            grad.setColorAt(0.55, gc)
+            grad.setColorAt(1.0, QColor(gc.red(), gc.green(), gc.blue(), 0))
+            p.setPen(Qt.NoPen); p.setBrush(grad)
+            p.drawEllipse(QRectF(cx - r - 6, cy - r - 6, 2 * (r + 6), 2 * (r + 6)))
+
+        # the disc
+        core = QColor(disc)
+        if self._state == "booting":                     # subtle breathing core
+            core = core.lighter(int(108 + 8 * math.sin(self._phase * 2)))
+        p.setPen(QPen(disc.darker(135), 1.2))
+        p.setBrush(core)
+        p.drawEllipse(QRectF(cx - r, cy - r, 2 * r, 2 * r))
+
+        # rings
+        ring_rect = QRectF(cx - r + 3, cy - r + 3, 2 * (r - 3), 2 * (r - 3))
+        if self._state == "booting":
+            track = QPen(QColor(255, 255, 255, 85), 3.6); track.setCapStyle(Qt.RoundCap)
+            p.setPen(track); p.setBrush(Qt.NoBrush)
+            p.drawArc(ring_rect, 0, 360 * 16)
+            arc = QPen(QColor(255, 255, 255, 255), 3.6); arc.setCapStyle(Qt.RoundCap)
+            p.setPen(arc)
+            p.drawArc(ring_rect, 90 * 16, -int(self._frac * 360) * 16)
+        elif self._state == "stopping":                  # indeterminate spinner
+            arc = QPen(QColor(255, 255, 255, 210), 3); arc.setCapStyle(Qt.RoundCap)
+            p.setPen(arc); p.setBrush(Qt.NoBrush)
+            start = int(-math.degrees(self._phase * 2.4)) * 16
+            p.drawArc(ring_rect, start, 110 * 16)
+
+        # glyph
+        p.setPen(Qt.NoPen); p.setBrush(QColor("#ffffff"))
+        if self._state in ("running", "stopping"):
+            s = r * 0.62
+            p.drawRoundedRect(QRectF(cx - s / 2, cy - s / 2, s, s), 2, 2)
+        elif self._state in ("ready", "error"):
+            tri = QPolygonF([
+                QPointF(cx - r * 0.26, cy - r * 0.42),
+                QPointF(cx - r * 0.26, cy + r * 0.42),
+                QPointF(cx + r * 0.46, cy),
+            ])
+            p.drawPolygon(tri)
+        p.end()

gini/ui/settings_dialog.py

@@ -0,0 +1,234 @@
+"""Settings dialog — organized into tabs (Appearance, Networking, GINI AI, Naming,
+Pricing, Help). Edits the live Settings; the caller applies + persists the result."""
+from __future__ import annotations
+
+from PySide6.QtGui import QDoubleValidator
+from PySide6.QtWidgets import (
+    QCheckBox, QComboBox, QDialog, QDialogButtonBox, QFormLayout, QLabel, QLineEdit,
+    QTabWidget, QVBoxLayout, QWidget,
+)
+
+_THEMES = ("Dark", "Light", "GINI Brand", "High Contrast", "Sand", "Blue", "Green")
+_TEXT_SIZES = ("Normal", "Large", "Extra Large")
+
+
+def _page(tabs: QTabWidget, title: str) -> QFormLayout:
+    """Add a tab whose body is a QFormLayout, and return that form."""
+    w = QWidget()
+    lay = QVBoxLayout(w)
+    form = QFormLayout()
+    lay.addLayout(form)
+    lay.addStretch(1)
+    tabs.addTab(w, title)
+    return form
+
+
+def _note(text: str) -> QLabel:
+    lbl = QLabel(text)
+    lbl.setObjectName("Faint")
+    lbl.setWordWrap(True)
+    return lbl
+
+
+class SettingsDialog(QDialog):
+    """Edits the live Settings; the caller applies + persists the returned values."""
+
+    def __init__(self, parent, settings) -> None:
+        super().__init__(parent)
+        self.setWindowTitle("GINI Settings")
+        self.setMinimumWidth(480)
+        root = QVBoxLayout(self)
+        tabs = QTabWidget()
+        root.addWidget(tabs)
+
+        # --- Appearance --------------------------------------------------- #
+        appf = _page(tabs, "Appearance")
+        self.theme = QComboBox(); self.theme.addItems(_THEMES)
+        # Select the CURRENT theme by matching the list itself. This used to use a hand-written
+        # {name: index} map that only covered the first four themes — so Sand/Blue/Green fell through
+        # to index 0 and the dialog silently reported "Dark". Saving Settings for ANY reason (e.g.
+        # editing your Teaching Center credentials) then wrote Dark back and stole your theme.
+        # Deriving the index from _THEMES means the two can never drift apart again.
+        cur = (settings.theme or "Dark").strip().lower()
+        cur = {"brand": "gini brand"}.get(cur, cur)          # tolerate the old short alias
+        names = [t.lower() for t in _THEMES]
+        self.theme.setCurrentIndex(names.index(cur) if cur in names else 0)
+        appf.addRow("Theme", self.theme)
+        self.text_size = QComboBox(); self.text_size.addItems(_TEXT_SIZES)
+        cur_sz = (getattr(settings, "text_size", "Normal") or "Normal").strip().lower()
+        sizes = [s.lower() for s in _TEXT_SIZES]
+        self.text_size.setCurrentIndex(sizes.index(cur_sz) if cur_sz in sizes else 0)
+        appf.addRow("Text size", self.text_size)
+        appf.addRow("", _note("Scales the whole interface — handy on large or high-resolution "
+                              "displays. Applies instantly."))
+        self.reduced = QCheckBox("Reduce motion / animations")
+        self.reduced.setChecked(settings.reduced_motion)
+        appf.addRow("", self.reduced)
+
+        # --- Networking --------------------------------------------------- #
+        netf = _page(tabs, "Networking")
+        self.auto_internet = QCheckBox("Containers get internet automatically (default eth)")
+        self.auto_internet.setChecked(settings.auto_internet)
+        netf.addRow("", self.auto_internet)
+        netf.addRow("", _note("Off = faithful mode: a machine reaches the internet only via "
+                              "a drawn Internet element, routed through your network."))
+        self.autobuild = QCheckBox("Build missing lab images automatically")
+        self.autobuild.setChecked(bool(getattr(settings, "autobuild_images", False)))
+        netf.addRow("", self.autobuild)
+        netf.addRow("", _note("The gRouter and SDN controller run from images built on this machine. "
+                              "With this on, GINI builds one the first time you Run without it, "
+                              "instead of printing a docker build command and stopping. The first "
+                              "build takes a couple of minutes; after that it's instant."))
+
+        # --- GINI AI ------------------------------------------------------ #
+        aif = _page(tabs, "GINI AI")
+        self.llm_enabled = QCheckBox("Use a local LLM for open-ended questions")
+        self.llm_enabled.setChecked(settings.llm_enabled)
+        aif.addRow("", self.llm_enabled)
+        self.llm_url = QLineEdit(settings.llm_url)
+        self.llm_url.setPlaceholderText("http://localhost:11434")
+        aif.addRow("Server (Ollama)", self.llm_url)
+        self.llm_model = QLineEdit(settings.llm_model)
+        self.llm_model.setPlaceholderText("llama3.1 / gemma / qwen …")
+        aif.addRow("Model", self.llm_model)
+        # editing the server/model is a clear intent to use the LLM — auto-tick the box
+        self.llm_url.textEdited.connect(lambda *_: self.llm_enabled.setChecked(True))
+        self.llm_model.textEdited.connect(lambda *_: self.llm_enabled.setChecked(True))
+        self.llm_think = QCheckBox("Reasoning ('thinking') model")
+        self.llm_think.setChecked(settings.llm_think)
+        aif.addRow("", self.llm_think)
+        aif.addRow("", _note("Without an LLM, GINI still builds, explains, traces paths, "
+                            "and runs Wizard recipes."))
+
+        # --- Naming ------------------------------------------------------- #
+        nf = _page(tabs, "Naming")
+        from ..domain.devices import default_prefix
+        self._prefix_edits = {}
+        for key, label in (("host", "Machine"), ("router", "Router"), ("switch", "Switch"),
+                           ("hub", "Hub"), ("instance", "Instance"), ("container", "Container")):
+            cur = settings.name_prefixes.get(key, default_prefix(key))
+            edit = QLineEdit(cur); edit.setPlaceholderText(default_prefix(key))
+            self._prefix_edits[key] = edit
+            nf.addRow(label, edit)
+        nf.addRow("", _note("e.g. set Machine to “Mach_” for Mach_1, Mach_2, …"))
+
+        # --- Pricing ------------------------------------------------------ #
+        from ..domain.pricing import rate_of
+        prf = _page(tabs, "Pricing")
+        self._price_edits = {}
+        for key, label in (("instance", "Instance (VM)"), ("container", "Container"),
+                           ("host", "Machine"), ("router", "Router"), ("switch", "Switch"),
+                           ("database", "Database"), ("object_store", "Object store"),
+                           ("dashboard", "Dashboards (Grafana)")):
+            edit = QLineEdit(f"{rate_of(key, settings.prices):g}")
+            edit.setValidator(QDoubleValidator(0.0, 100000.0, 2, edit))
+            edit.setPlaceholderText(f"{rate_of(key):g}")
+            self._price_edits[key] = edit
+            prf.addRow(label, edit)
+        prf.addRow("", _note("Toy “cloud bill” shown live in the dashboard while a lab runs. "
+                            "Blank = use the default rate."))
+
+        # --- Teaching Center ---------------------------------------------- #
+        tcf = _page(tabs, "Teaching Center")
+        self.tc_url = QLineEdit(settings.tc_url)
+        self.tc_url.setPlaceholderText("http://localhost:8080")
+        tcf.addRow("Course server", self.tc_url)
+        self.tc_course = QLineEdit(settings.tc_course)
+        self.tc_course.setPlaceholderText("cs4480-fall26")
+        tcf.addRow("Course", self.tc_course)
+        self.tc_student = QLineEdit(settings.tc_student)
+        self.tc_student.setPlaceholderText("your username — e.g. ravi")
+        tcf.addRow("Username", self.tc_student)
+        self.tc_token = QLineEdit(settings.tc_token)
+        self.tc_token.setPlaceholderText("one-time token from your instructor")
+        self.tc_token.setEchoMode(QLineEdit.Password)
+        tcf.addRow("Enrolment token", self.tc_token)
+        self.tc_insecure = QCheckBox("Allow insecure (plain HTTP) connection")
+        self.tc_insecure.setChecked(bool(getattr(settings, "tc_allow_insecure", False)))
+        tcf.addRow("", self.tc_insecure)
+        tcf.addRow("", _note("Your password is never stored — signing in exchanges it for a session. "
+                             "The enrolment token is used ONCE, to claim your account.\n\n"
+                             "GINI refuses to send a password over plain HTTP to a remote server: on "
+                             "shared wifi anyone could read it. Tick the box above only for a demo on "
+                             "a network you trust (localhost is always allowed).\n\n"
+                             "Leave the server blank to work offline — Missions then offers the local "
+                             "practice catalog."))
+
+        # --- Hardware (GINI32 boards) ------------------------------------- #
+        # The one thing a board cannot discover for itself. It is the same network for
+        # every board in a class, so it is entered here once and then written to each
+        # board over USB by Hardware → Set Up a Board.
+        hwf = _page(tabs, "Hardware")
+        self.board_ssid = QLineEdit(getattr(settings, "board_wifi_ssid", "") or "")
+        self.board_ssid.setPlaceholderText("the Wi-Fi this laptop is on — 2.4 GHz")
+        hwf.addRow("Lab Wi-Fi name", self.board_ssid)
+        self.board_pw = QLineEdit(getattr(settings, "board_wifi_password", "") or "")
+        self.board_pw.setEchoMode(QLineEdit.Password)
+        hwf.addRow("Lab Wi-Fi password", self.board_pw)
+        hwf.addRow("", _note(
+            "A GINI32 board joins this network to reach gBuilder, so it must be the SAME "
+            "network this laptop is on. ESP32 radios are 2.4 GHz only — a 5 GHz-only "
+            "network will never be found.\n\n"
+            "Set boards up from Hardware → Set Up a Board with the board plugged in over "
+            "USB. That is the only step that needs a cable; everything afterwards is "
+            "wireless.\n\n"
+            "This password is stored in the config file so boards can be set up without "
+            "retyping it. Use the shared lab network here, not a personal account."))
+
+        # --- Help & Tour -------------------------------------------------- #
+        hf = _page(tabs, "Help")
+        self.show_help = QCheckBox("Show the feature tour (Cue Cards) at launch")
+        self.show_help.setChecked(settings.show_help_on_launch)
+        hf.addRow("", self.show_help)
+        hf.addRow("", _note("Reopen the tour any time from Help → Feature Tour."))
+
+        root.addWidget(_note("Saved to ~/.gini/config.json."))
+        bb = QDialogButtonBox(QDialogButtonBox.Save | QDialogButtonBox.Cancel)
+        bb.accepted.connect(self.accept)
+        bb.rejected.connect(self.reject)
+        root.addWidget(bb)
+
+    def values(self) -> dict:
+        from ..domain.devices import default_prefix
+        from ..domain.pricing import DEFAULT_RATES
+        prefixes = {}
+        for key, edit in self._prefix_edits.items():
+            p = edit.text().strip()
+            if p and p != default_prefix(key):       # only store real overrides
+                prefixes[key] = p
+        prices = {}
+        for key, edit in self._price_edits.items():
+            txt = edit.text().strip()
+            if not txt:
+                continue
+            try:
+                val = round(float(txt), 2)
+            except ValueError:
+                continue
+            if val != DEFAULT_RATES.get(key):        # only store real overrides
+                prices[key] = val
+        return {
+            "theme": self.theme.currentText(),
+            "text_size": self.text_size.currentText(),
+            "reduced_motion": self.reduced.isChecked(),
+            "auto_internet": self.auto_internet.isChecked(),
+            "autobuild_images": self.autobuild.isChecked(),
+            "llm_enabled": self.llm_enabled.isChecked(),
+            "llm_url": self.llm_url.text().strip() or "http://localhost:11434",
+            "llm_model": self.llm_model.text().strip() or "llama3.1",
+            "llm_think": self.llm_think.isChecked(),
+            "name_prefixes": prefixes,
+            "prices": prices,                         # was computed but dropped -> KeyError
+            "show_help_on_launch": self.show_help.isChecked(),
+            "tc_url": self.tc_url.text().strip(),
+            "tc_course": self.tc_course.text().strip(),
+            "tc_student": self.tc_student.text().strip(),
+            "tc_token": self.tc_token.text().strip(),
+            "tc_allow_insecure": self.tc_insecure.isChecked(),
+            # GINI32: the lab Wi-Fi written to boards over USB. Not stripped of case —
+            # SSIDs are case-sensitive — but surrounding whitespace is, because a name
+            # pasted from a slide routinely carries a trailing space and the board would
+            # then hunt forever for a network that does not exist.
+            "board_wifi_ssid": self.board_ssid.text().strip(),
+            "board_wifi_password": self.board_pw.text(),
+        }

gini/ui/signin_dialog.py

@@ -0,0 +1,111 @@
+"""Sign in to the Teaching Center.
+
+Two shapes, because a student's first sign-in is a different act from their tenth:
+
+  * **First time (claim).** The teacher enrolled you and handed you an enrolment token. You supply it
+    once, choose a password, and the token is spent. This is what stops a classmate from claiming
+    your identity: student ids are guessable, so "first password wins" would be an open door.
+  * **Every time after.** Student id + password.
+
+The password is used once, to get a session token, and is never stored. If the course server isn't
+HTTPS and isn't localhost, the client REFUSES to send it (see `teaching_center.refuse_plaintext_
+password`) — and we surface that refusal as an explanation, not a stack trace.
+"""
+from __future__ import annotations
+
+from PySide6.QtCore import Qt
+from PySide6.QtWidgets import (
+    QCheckBox, QDialog, QDialogButtonBox, QFormLayout, QLabel, QLineEdit, QVBoxLayout,
+)
+
+
+class SignInDialog(QDialog):
+    def __init__(self, parent, settings, *, first_time: bool = False) -> None:
+        super().__init__(parent)
+        self.setWindowTitle("Sign in to your course")
+        self.setMinimumWidth(420)
+        self._settings = settings
+        root = QVBoxLayout(self)
+
+        head = QLabel(f"<b>{settings.tc_course or 'your course'}</b> · {settings.tc_url}")
+        head.setTextFormat(Qt.RichText)
+        root.addWidget(head)
+
+        form = QFormLayout()
+        self.student = QLineEdit(settings.tc_student)
+        self.student.setPlaceholderText("your username — e.g. ravi")
+        self.student.setToolTip("The username your instructor gave you (not your school ID).")
+        form.addRow("Username", self.student)
+
+        self.first = QCheckBox("First time — I have an enrolment token")
+        self.first.setChecked(bool(first_time))
+        form.addRow("", self.first)
+
+        self.enrol = QLineEdit(settings.tc_token)
+        self.enrol.setPlaceholderText("the token your instructor gave you")
+        form.addRow("Enrolment token", self.enrol)
+
+        self.password = QLineEdit()
+        self.password.setEchoMode(QLineEdit.Password)
+        self.password.setPlaceholderText("at least 8 characters")
+        form.addRow("Password", self.password)
+
+        self.confirm = QLineEdit()
+        self.confirm.setEchoMode(QLineEdit.Password)
+        form.addRow("Confirm password", self.confirm)
+        root.addLayout(form)
+
+        self.note = QLabel("")
+        self.note.setWordWrap(True)
+        self.note.setObjectName("Faint")
+        root.addWidget(self.note)
+
+        self.bb = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
+        self.bb.button(QDialogButtonBox.Ok).setText("Sign in")
+        self.bb.accepted.connect(self._accept)
+        self.bb.rejected.connect(self.reject)
+        root.addWidget(self.bb)
+
+        self.first.toggled.connect(self._sync)
+        self._sync()
+
+    def _sync(self) -> None:
+        """The claim fields only exist for a claim. A returning student shouldn't be asked to confirm
+        a password they already have."""
+        claiming = self.first.isChecked()
+        for w in (self.enrol, self.confirm):
+            w.setVisible(claiming)
+            lbl = self.layout().itemAt(1).layout().labelForField(w)
+            if lbl is not None:
+                lbl.setVisible(claiming)
+        self.bb.button(QDialogButtonBox.Ok).setText("Set password & sign in" if claiming
+                                                    else "Sign in")
+        self.note.setText(
+            "Your instructor gave you a one-time enrolment token. You'll choose your own password "
+            "now; the token is then spent." if claiming else
+            "Signing in stores a session on this machine — never your password.")
+        self.adjustSize()
+
+    def _error(self, msg: str) -> None:
+        self.note.setText(msg)
+        self.note.setObjectName("")
+        self.note.setStyleSheet("color:#d9534f; font-weight:600;")
+
+    def _accept(self) -> None:
+        if not self.student.text().strip():
+            return self._error("Enter your student id.")
+        pw = self.password.text()
+        if len(pw) < 8:
+            return self._error("Your password must be at least 8 characters.")
+        if self.first.isChecked():
+            if not self.enrol.text().strip():
+                return self._error("Enter the enrolment token your instructor gave you.")
+            if pw != self.confirm.text():
+                return self._error("The two passwords don't match.")
+        self.accept()
+
+    def values(self) -> dict:
+        return {"student": self.student.text().strip(),
+                "password": self.password.text(),
+                "claim": self.first.isChecked(),
+                "enrolment_token": self.enrol.text().strip()}