pycontrol-gui 3.0.0b2__tar.gz → 3.0.0b4__tar.gz

{pycontrol_gui-3.0.0b2 → pycontrol_gui-3.0.0b4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pycontrol-gui
-Version: 3.0.0b2
+Version: 3.0.0b4
 Summary: Qt desktop frontend for pycontrol-core.
 Author: Karpova Lab contributors
 License: GPL-3.0-or-later
@@ -13,7 +13,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Scientific/Engineering
 Requires-Python: >=3.12
 Requires-Dist: packaging>=24
-Requires-Dist: pycontrol-core<3.1,>=3.0.0b1
+Requires-Dist: pycontrol-core<3.1,>=3.0.0b3
 Requires-Dist: pyqtgraph>=0.13.7
 Requires-Dist: pyside6>=6.8
 Provides-Extra: test

{pycontrol_gui-3.0.0b2 → pycontrol_gui-3.0.0b4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pycontrol-gui"
-version = "3.0.0b2"
+version = "3.0.0b4"
 description = "Qt desktop frontend for pycontrol-core."
 readme = "README.md"
 requires-python = ">=3.12"
@@ -20,7 +20,7 @@ classifiers = [
 ]
 dependencies = [
   "packaging>=24",
-  "pycontrol-core>=3.0.0b1,<3.1",
+  "pycontrol-core>=3.0.0b3,<3.1",
   "PySide6>=6.8",
   "pyqtgraph>=0.13.7",
 ]

{pycontrol_gui-3.0.0b2 → pycontrol_gui-3.0.0b4}/src/pycontrol_gui/session_controller.py

@@ -520,6 +520,7 @@ class SessionController(QObject):
         self._pending_end = None
         self._end_poll.stop()
         self._handled_session_end_signature = signature
+        self._log_run_error(ended)
         self._finish_active_run(ended)
         self.state_changed.emit(session.state)
         self.run_stopped.emit(ended)
@@ -641,6 +642,18 @@ class SessionController(QObject):
         if session.state in (SessionState.CONNECTED, SessionState.READY):
             self._pending_notes.append((note, 0))
 
+    def _log_run_error(self, ended: SessionEnded) -> None:
+        """Persist a board traceback or lost connection to the error log, not just the run's log view."""
+        if not ended.error_message:
+            return
+        run = self._active_run
+        if run is not None:
+            where = f"setup {run.plan.setup_name}, subject {run.plan.subject_id}, port {run.plan.port}"
+        else:
+            where = f"port {self._connected_port}"
+        message = ended.error_message.replace("\r\n", "\n").strip()
+        logger.error("Run on %s (task %s) ended with an error:\n%s", where, self._last_task_name, message)
+
     def _finish_active_run(self, ended: SessionEnded | None = None) -> None:
         """Close and package the run in flight, if any.
 

{pycontrol_gui-3.0.0b2 → pycontrol_gui-3.0.0b4}/src/pycontrol_gui/widgets/experiment_run_view.py

@@ -176,7 +176,6 @@ class ExperimentRunView(QWidget):
         self._persistent_variables_path: Path | None = None
         self._last_summary_dialog: SummaryVariablesDialog | None = None
         self._log_stretch_item: QLayoutItem | None = None
-        self._log_live_updates_enabled = True
         self._experiment_plots_mounted = False
         self._syncing_panel_splitters = False
         self._session_splitter_layout: tuple[str, list[int]] | None = None
@@ -374,7 +373,6 @@ class ExperimentRunView(QWidget):
         self.hardware_test_text.setText(hardware_test_name or "")
         self._fit_header_text_fields()
         self._set_hardware_test_header_visible(hardware_test_name is not None)
-        self._set_log_live_updates_enabled(self._log_live_updates_enabled)
         self._hooks = ExperimentHookSequencer(
             self._hook_dispatcher,
             experiment_name=experiment.name,
@@ -566,10 +564,6 @@ class ExperimentRunView(QWidget):
         )
         self.log_filters_button = self._log_filter_controller.button
         self._log_filter_name_checkboxes = self._log_filter_controller.name_checkboxes
-        self.log_autoscroll_checkbox = QCheckBox("Auto-scroll")
-        self.log_autoscroll_checkbox.setChecked(True)
-        self.log_autoscroll_checkbox.setToolTip("When enabled, all experiment logs follow new entries to the bottom.")
-
         self.logs_visible_checkbox = QCheckBox("Logs")
         self.controls_visible_checkbox = QCheckBox("Controls")
         self.plots_visible_checkbox = QCheckBox("Plots")
@@ -607,7 +601,6 @@ class ExperimentRunView(QWidget):
         logs_layout.setContentsMargins(12, 8, 12, 10)
         logs_layout.setSpacing(8)
         logs_layout.addWidget(self.log_filters_button)
-        logs_layout.addWidget(self.log_autoscroll_checkbox)
         logs_layout.addStretch(1)
 
         self.plot_window_group = QGroupBox("Plot window")
@@ -679,7 +672,6 @@ class ExperimentRunView(QWidget):
         self.cancel_experiment_button.clicked.connect(self._cancel_experiment)
         self.startstopclose_all_button.clicked.connect(self._start_stop_close_all)
         self.hook_message.connect(self._log_hook_message)
-        self.log_autoscroll_checkbox.toggled.connect(self._on_log_live_updates_toggled)
         for name, checkbox in self._pane_visibility_checkboxes.items():
             checkbox.toggled.connect(lambda visible, name=name: self._set_all_session_panes_visible(name, visible))
 
@@ -1040,24 +1032,11 @@ class ExperimentRunView(QWidget):
         )
         self._apply_panel_height_policy()
 
-    def _on_log_live_updates_toggled(self, enabled: bool) -> None:
-        self._set_log_live_updates_enabled(enabled)
-
-    def _set_log_live_updates_enabled(self, enabled: bool) -> None:
-        self._log_live_updates_enabled = enabled
-        self.log_autoscroll_checkbox.blockSignals(True)
-        self.log_autoscroll_checkbox.setChecked(enabled)
-        self.log_autoscroll_checkbox.blockSignals(False)
-        for panel in self._panels.values():
-            panel.set_log_live_updates_enabled(enabled)
-
     def _apply_log_controls_to_panel(self, panel: SubjectRunPanel) -> None:
         self._log_filter_controller.apply_to_log_view(panel.log_view)
-        panel.set_log_live_updates_enabled(self._log_live_updates_enabled)
 
     def _set_log_filter_controls_enabled(self, enabled: bool) -> None:
         self._log_filter_controller.set_enabled(enabled)
-        self.log_autoscroll_checkbox.setEnabled(enabled)
         self.expand_one_at_a_time_checkbox.setEnabled(enabled)
 
     def _add_log_stretch(self) -> None:

{pycontrol_gui-3.0.0b2 → pycontrol_gui-3.0.0b4}/src/pycontrol_gui/widgets/log_view.py

@@ -3,6 +3,8 @@
 from __future__ import annotations
 
 from collections import deque
+from collections.abc import Iterator
+from contextlib import contextmanager
 from dataclasses import dataclass
 
 from PySide6.QtGui import QColor, QPalette, QTextCharFormat, QTextCursor
@@ -68,7 +70,15 @@ class LogView(QPlainTextEdit):
         self._entries: deque[LogEntry] = deque(maxlen=max_entries)
         self._visible_types: set[str] = set(self._FILTERABLE_KINDS)
         self._hidden_names: dict[str, set[str]] = {kind: set() for kind in self._FILTERABLE_KINDS}
-        self._live_updates_enabled = True
+        # Whether the view follows new rows: true while the reader is at the bottom.
+        # Only the reader's own scrolling changes it, so a layout change that
+        # shrinks the view (the plots and status row appearing at run start) or
+        # a deferred scroll-range update cannot leave a following view stranded.
+        self._following = True
+        self._adjusting_scroll = False
+        vbar = self.verticalScrollBar()
+        vbar.valueChanged.connect(self._on_scrolled)
+        vbar.rangeChanged.connect(self._on_scroll_range_changed)
 
     @property
     def entries(self) -> tuple[LogEntry, ...]:
@@ -119,12 +129,11 @@ class LogView(QPlainTextEdit):
         self._hidden_names.setdefault(kind, set()).clear()
         self._rerender_visible_entries()
 
-    def set_live_updates_enabled(self, enabled: bool) -> None:
-        if self._live_updates_enabled == enabled:
-            return
-        self._live_updates_enabled = enabled
-        if enabled:
-            self.moveCursor(QTextCursor.MoveOperation.End)
+    def follow_new_rows(self) -> None:
+        """Jump to the bottom and follow new rows until the reader scrolls up."""
+        self._following = True
+        vbar = self.verticalScrollBar()
+        vbar.setValue(vbar.maximum())
 
     def append_line(self, text: str) -> None:
         self.append_entry(LogEntry(timestamp_ms=None, kind="info", content=text))
@@ -156,22 +165,37 @@ class LogView(QPlainTextEdit):
         fmt.setForeground(self._row_color(entry.kind))
         source_fmt = QTextCharFormat()
         source_fmt.setForeground(self._source_color())
-        if self._live_updates_enabled:
-            cursor = self.textCursor()
+        # Writing through a separate cursor leaves the reader's selection alone.
+        with self._keeping_scroll_position():
+            cursor = QTextCursor(self.document())
             cursor.movePosition(QTextCursor.MoveOperation.End)
             self._insert_row(cursor, entry, row, fmt, source_fmt)
-            self.setTextCursor(cursor)
-            self.moveCursor(QTextCursor.MoveOperation.End)
+
+    @contextmanager
+    def _keeping_scroll_position(self) -> Iterator[None]:
+        """Restore the scroll position after an edit, or stay at the bottom while following."""
+        if self._adjusting_scroll:  # already inside an outer edit, which restores the position
+            yield
             return
         vbar = self.verticalScrollBar()
         hbar = self.horizontalScrollBar()
         vpos = vbar.value()
         hpos = hbar.value()
-        cursor = QTextCursor(self.document())
-        cursor.movePosition(QTextCursor.MoveOperation.End)
-        self._insert_row(cursor, entry, row, fmt, source_fmt)
-        vbar.setValue(vpos)
-        hbar.setValue(hpos)
+        self._adjusting_scroll = True
+        try:
+            yield
+        finally:
+            vbar.setValue(vbar.maximum() if self._following else vpos)
+            hbar.setValue(hpos)
+            self._adjusting_scroll = False
+
+    def _on_scrolled(self, value: int) -> None:
+        if not self._adjusting_scroll:
+            self._following = value >= self.verticalScrollBar().maximum()
+
+    def _on_scroll_range_changed(self, _minimum: int, maximum: int) -> None:
+        if self._following and not self._adjusting_scroll:
+            self.verticalScrollBar().setValue(maximum)
 
     @staticmethod
     def _insert_row(
@@ -184,17 +208,11 @@ class LogView(QPlainTextEdit):
         cursor.insertText("\n", fmt)
 
     def _rerender_visible_entries(self) -> None:
-        vbar = self.verticalScrollBar()
-        hbar = self.horizontalScrollBar()
-        vpos = vbar.value()
-        hpos = hbar.value()
-        super().clear()
-        for entry in self._entries:
-            if self._is_entry_visible(entry):
-                self._append_rendered_entry(entry)
-        if not self._live_updates_enabled:
-            vbar.setValue(vpos)
-            hbar.setValue(hpos)
+        with self._keeping_scroll_position():
+            super().clear()
+            for entry in self._entries:
+                if self._is_entry_visible(entry):
+                    self._append_rendered_entry(entry)
 
     def _row_color(self, kind: str) -> QColor:
         text_color = self.palette().color(QPalette.ColorRole.Text)

{pycontrol_gui-3.0.0b2 → pycontrol_gui-3.0.0b4}/src/pycontrol_gui/widgets/run_task_tab.py

@@ -18,7 +18,6 @@ from PySide6.QtCore import QSize, Qt, QTimer, Signal
 from PySide6.QtGui import QAction, QColor, QFont, QKeySequence, QPalette, QShortcut
 from PySide6.QtWidgets import (
     QAbstractSpinBox,
-    QCheckBox,
     QComboBox,
     QDialog,
     QFileDialog,
@@ -293,13 +292,9 @@ class RunTaskTab(QWidget):
         filters_layout = QHBoxLayout(self.log_filters_bar)
         filters_layout.setContentsMargins(0, 0, 0, 0)
         filters_layout.setSpacing(10)
-        self.log_autoscroll_checkbox = QCheckBox("Auto-scroll")
-        self.log_autoscroll_checkbox.setChecked(True)
-        self.log_autoscroll_checkbox.setToolTip("When enabled, the log view follows new entries to the bottom.")
         self.clear_log_button = QPushButton("Clear log")
         self.clear_log_button.setToolTip("Remove all entries from the log.")
         filters_layout.addWidget(self.log_filters_button)
-        filters_layout.addWidget(self.log_autoscroll_checkbox)
         filters_layout.addStretch(1)
         filters_layout.addWidget(self.clear_log_button)
 
@@ -394,7 +389,6 @@ class RunTaskTab(QWidget):
         self._upload_task_shortcut = QShortcut(QKeySequence(Qt.Key.Key_U), self)
         self._upload_task_shortcut.setContext(Qt.ShortcutContext.WindowShortcut)
         self._upload_task_shortcut.activated.connect(self._on_upload_task_shortcut)
-        self._set_log_live_updates_enabled(True)
         self._set_plot_live_updates_enabled(True)
 
     def _wire_ui(self) -> None:
@@ -414,7 +408,6 @@ class RunTaskTab(QWidget):
         self.view_board_files_action.triggered.connect(self.view_board_files_requested.emit)
         self.unmount_controls_action.triggered.connect(self._unmount_controls_dialog)
         self.mount_controls_action.triggered.connect(self._mount_controls_dialog)
-        self.log_autoscroll_checkbox.toggled.connect(self._on_log_live_updates_toggled)
         self.clear_log_button.clicked.connect(self.log_view.clear)
         self.plot_live_button.toggled.connect(self._on_plot_live_updates_toggled)
         self.task_plot.plotter_changed.connect(self._refresh_plot_live_button_visibility)
@@ -585,6 +578,7 @@ class RunTaskTab(QWidget):
         self._refresh_controls()
 
     def on_session_started(self, ev: SessionStarted) -> None:
+        self.log_view.follow_new_rows()
         self.task_plot.run_start()
         if self.task_status.mode == "default":
             # A task handler's own status stands until it publishes the run's first.
@@ -802,18 +796,9 @@ class RunTaskTab(QWidget):
         self._append_log_entry(kind="info", content=self._RUN_STOP_SEPARATOR)
         self._append_log_entry(kind="info", content="")
 
-    def _on_log_live_updates_toggled(self, enabled: bool) -> None:
-        self._set_log_live_updates_enabled(enabled)
-
     def _on_plot_live_updates_toggled(self, paused: bool) -> None:
         self._set_plot_live_updates_enabled(not paused)
 
-    def _set_log_live_updates_enabled(self, enabled: bool) -> None:
-        self.log_view.set_live_updates_enabled(enabled)
-        self.log_autoscroll_checkbox.blockSignals(True)
-        self.log_autoscroll_checkbox.setChecked(enabled)
-        self.log_autoscroll_checkbox.blockSignals(False)
-
     def _set_plot_live_updates_enabled(self, enabled: bool) -> None:
         self._plot_live_updates_enabled = enabled
         self.plot_live_button.blockSignals(True)

{pycontrol_gui-3.0.0b2 → pycontrol_gui-3.0.0b4}/src/pycontrol_gui/widgets/settings_dialog.py

@@ -42,6 +42,8 @@ from pycontrol_gui.resources import icon
 
 logger = logging.getLogger(__name__)
 
+_STACK_INDEX_ROLE = Qt.ItemDataRole.UserRole + 1
+
 
 @dataclass(frozen=True, slots=True)
 class _BoundSettingSpec:
@@ -53,18 +55,27 @@ class _BoundSettingSpec:
 @dataclass(frozen=True, slots=True)
 class _AddonRow:
     group: QGroupBox
-    list_widget: QListWidget
+    list_widgets: dict[str, QListWidget]
     stack: QStackedWidget
     go_to_file_button: QPushButton
 
 
 @dataclass(frozen=True, slots=True)
 class _AddonSettingsError:
+    category: str
     label: str
     file_path: Path
     message: str
 
 
+_AddonGroup = tuple[str, tuple[str, ...], tuple[AddonSettingSpec, ...], Path | None]
+
+_PLOTTERS = "Plotters"
+_TASK_HANDLERS = "Task Handlers"
+_EXPERIMENT_HANDLERS = "Experiment Handlers"
+_ADDON_CATEGORIES = (_PLOTTERS, _TASK_HANDLERS, _EXPERIMENT_HANDLERS)
+
+
 class SettingsDialog(QDialog):
     """Edit settings stored in the active workspace."""
 
@@ -289,59 +300,109 @@ class SettingsDialog(QDialog):
         layout.setColumnStretch(2, 1)
         return group
 
-    def _build_addon_row(
-        self, title: str, groups: tuple[tuple[str, tuple[str, ...], tuple[AddonSettingSpec, ...], Path | None], ...]
-    ) -> QGroupBox:
+    def _build_addon_row(self, title: str, groups: dict[str, list[_AddonGroup]]) -> QGroupBox:
         group = QGroupBox(title)
         layout = QHBoxLayout(group)
         layout.setSpacing(12)
 
         list_panel = QWidget()
+        list_panel.setMinimumWidth(300)
+        list_panel.setMaximumWidth(420)
         list_layout = QVBoxLayout(list_panel)
         list_layout.setContentsMargins(0, 0, 0, 0)
-        list_widget = QListWidget()
-        list_widget.setMinimumWidth(300)
-        list_widget.setMaximumWidth(420)
-        list_widget.setMinimumHeight(100)
-        list_widget.setSizePolicy(QSizePolicy.Policy.Preferred, QSizePolicy.Policy.Expanding)
+        stack = QStackedWidget()
         go_to_file_button = QPushButton("Go to file")
         go_to_file_button.setFocusPolicy(Qt.FocusPolicy.NoFocus)
-        go_to_file_button.clicked.connect(lambda _checked=False: self._reveal_selected_addon_file(list_widget))
-        stack = QStackedWidget()
+        go_to_file_button.setEnabled(False)
+        list_widgets: dict[str, QListWidget] = {}
 
-        def update_go_to_file_button(row: int) -> None:
-            item = list_widget.item(row)
-            go_to_file_button.setEnabled(bool(item and item.data(Qt.ItemDataRole.UserRole)))
+        def select_item(source: QListWidget, item: QListWidgetItem | None) -> None:
+            if item is None:
+                return
+            for other in list_widgets.values():
+                if other is not source:
+                    other.blockSignals(True)
+                    other.setCurrentRow(-1)
+                    other.clearSelection()
+                    other.blockSignals(False)
+            stack.setCurrentIndex(int(item.data(_STACK_INDEX_ROLE)))
+            go_to_file_button.setEnabled(bool(item.data(Qt.ItemDataRole.UserRole)))
+
+        def selected_item() -> QListWidgetItem | None:
+            return next(
+                (widget.currentItem() for widget in list_widgets.values() if widget.currentItem() is not None), None
+            )
 
-        if groups or self._addon_settings_errors:
-            for group_title, path, specs, file_path in groups:
-                item = QListWidgetItem(self._addon_item_label(path))
-                item.setData(Qt.ItemDataRole.UserRole, "" if file_path is None else str(file_path))
-                list_widget.addItem(item)
-                stack.addWidget(self._build_group(group_title, path, specs, show_title=False))
+        go_to_file_button.clicked.connect(lambda _checked=False: self._reveal_addon_file(selected_item()))
+
+        first_list: QListWidget | None = None
+        for category in _ADDON_CATEGORIES:
+            heading = QLabel(category)
+            font = heading.font()
+            font.setBold(True)
+            heading.setFont(font)
+            list_widget = QListWidget()
+            list_widgets[category] = list_widget
+
+            for group_title, path, specs, file_path in groups.get(category, []):
+                self._add_addon_item(
+                    list_widget,
+                    stack,
+                    self._addon_item_label(path),
+                    file_path,
+                    self._build_group(group_title, path, specs, show_title=False),
+                )
             for error in self._addon_settings_errors:
-                item = QListWidgetItem(f"{error.label} (error)")
-                item.setData(Qt.ItemDataRole.UserRole, str(error.file_path))
-                item.setToolTip(error.message)
-                list_widget.addItem(item)
-                stack.addWidget(self._build_addon_error_widget(error))
-            list_widget.currentRowChanged.connect(stack.setCurrentIndex)
-            list_widget.currentRowChanged.connect(update_go_to_file_button)
-            list_widget.setCurrentRow(0)
-        else:
-            list_widget.setEnabled(False)
-            go_to_file_button.setEnabled(False)
+                if error.category == category:
+                    item = self._add_addon_item(
+                        list_widget,
+                        stack,
+                        f"{error.label} (error)",
+                        error.file_path,
+                        self._build_addon_error_widget(error),
+                    )
+                    item.setToolTip(error.message)
+
+            if list_widget.count():
+                list_widget.currentItemChanged.connect(
+                    lambda item, _previous, source=list_widget: select_item(source, item)
+                )
+                first_list = first_list or list_widget
+            else:
+                placeholder = QListWidgetItem("No configurable files")
+                placeholder.setFlags(Qt.ItemFlag.NoItemFlags)
+                list_widget.addItem(placeholder)
+            list_widget.setFixedHeight(self._list_height(list_widget, min(max(list_widget.count(), 3), 8)))
+
+            list_layout.addWidget(heading)
+            list_layout.addWidget(list_widget)
+
+        if first_list is None:
             placeholder = QLabel("No settings files found.")
             placeholder.setAlignment(Qt.AlignmentFlag.AlignCenter)
             stack.addWidget(placeholder)
+        else:
+            first_list.setCurrentRow(0)
 
-        list_layout.addWidget(list_widget)
         list_layout.addWidget(go_to_file_button)
         layout.addWidget(list_panel)
         layout.addWidget(stack, 1)
-        self._addon_rows[title] = _AddonRow(group, list_widget, stack, go_to_file_button)
+        self._addon_rows[title] = _AddonRow(group, list_widgets, stack, go_to_file_button)
         return group
 
+    def _add_addon_item(
+        self, list_widget: QListWidget, stack: QStackedWidget, label: str, file_path: Path | None, page: QWidget
+    ) -> QListWidgetItem:
+        item = QListWidgetItem(label)
+        item.setData(Qt.ItemDataRole.UserRole, "" if file_path is None else str(file_path))
+        item.setData(_STACK_INDEX_ROLE, stack.addWidget(page))
+        list_widget.addItem(item)
+        return item
+
+    def _list_height(self, list_widget: QListWidget, rows: int) -> int:
+        row_height = list_widget.sizeHintForRow(0) if list_widget.count() else self.fontMetrics().height() + 4
+        return rows * row_height + 2 * list_widget.frameWidth() + 4
+
     def _build_addon_error_widget(self, error: _AddonSettingsError) -> QLabel:
         label = QLabel(
             f"Settings could not be loaded from {error.file_path.name}.\n\n"
@@ -356,13 +417,10 @@ class SettingsDialog(QDialog):
 
     def _addon_item_label(self, path: tuple[str, ...]) -> str:
         if path == ("addons", "plotters", "DefaultPlotter"):
-            return "pycontrol-gui/DefaultPlotter"
-        if len(path) >= 3 and path[0] == "addons":
-            return f"{path[1]}/{path[2]}"
+            return "DefaultPlotter (pycontrol-gui)"
         return path[-1]
 
-    def _reveal_selected_addon_file(self, list_widget: QListWidget) -> None:
-        item = list_widget.currentItem()
+    def _reveal_addon_file(self, item: QListWidgetItem | None) -> None:
         if item is None:
             return
         raw_path = item.data(Qt.ItemDataRole.UserRole)
@@ -405,64 +463,31 @@ class SettingsDialog(QDialog):
         self._group_widgets.append(addon_row)
         self.set_locked(self._locked)
 
-    def _dynamic_addon_groups(
-        self,
-    ) -> tuple[tuple[str, tuple[str, ...], tuple[AddonSettingSpec, ...], Path | None], ...]:
-        groups: list[tuple[str, tuple[str, ...], tuple[AddonSettingSpec, ...], Path | None]] = []
-        groups.append(
-            (
-                "pycontrol-gui / DefaultPlotter",
-                ("addons", "plotters", "DefaultPlotter"),
-                DefaultPlotter.SETTINGS,
-                None,
-            )
+    def _dynamic_addon_groups(self) -> dict[str, list[_AddonGroup]]:
+        default_plotter: _AddonGroup = (
+            "pycontrol-gui / DefaultPlotter",
+            ("addons", "plotters", "DefaultPlotter"),
+            DefaultPlotter.SETTINGS,
+            None,
         )
-        groups.extend(self._plotter_groups())
-        groups.extend(self._task_handler_groups())
-        groups.extend(self._experiment_handler_groups())
-        return tuple(groups)
-
-    def _experiment_handler_groups(self) -> list[tuple[str, tuple[str, ...], tuple[AddonSettingSpec, ...], Path]]:
-        if self._experiment_handlers_dir is None or not self._experiment_handlers_dir.is_dir():
-            return []
-        groups: list[tuple[str, tuple[str, ...], tuple[AddonSettingSpec, ...], Path]] = []
-        for path in sorted(self._experiment_handlers_dir.glob("*.py")):
-            if path.name.startswith("_"):
-                continue
-            specs = self._settings_specs_from_module(path)
-            if specs:
-                groups.append(
-                    (
-                        f"Experiment Handlers / {path.stem}",
-                        ("addons", "experiment_handlers", path.stem),
-                        specs,
-                        path,
-                    )
-                )
-        return groups
-
-    def _plotter_groups(self) -> list[tuple[str, tuple[str, ...], tuple[AddonSettingSpec, ...], Path]]:
-        if self._plotters_dir is None or not self._plotters_dir.is_dir():
-            return []
-        groups: list[tuple[str, tuple[str, ...], tuple[AddonSettingSpec, ...], Path]] = []
-        for path in sorted(self._plotters_dir.glob("*.py")):
-            if path.name.startswith("_"):
-                continue
-            specs = self._settings_specs_from_module(path)
-            if specs:
-                groups.append((f"Task Plotters / {path.stem}", ("addons", "plotters", path.stem), specs, path))
-        return groups
+        return {
+            _PLOTTERS: [default_plotter, *self._addon_file_groups(self._plotters_dir, "plotters", "Task Plotters")],
+            _TASK_HANDLERS: self._addon_file_groups(self._task_handlers_dir, "task_handlers", "Task Handlers"),
+            _EXPERIMENT_HANDLERS: self._addon_file_groups(
+                self._experiment_handlers_dir, "experiment_handlers", "Experiment Handlers"
+            ),
+        }
 
-    def _task_handler_groups(self) -> list[tuple[str, tuple[str, ...], tuple[AddonSettingSpec, ...], Path]]:
-        if self._task_handlers_dir is None or not self._task_handlers_dir.is_dir():
+    def _addon_file_groups(self, directory: Path | None, key: str, title_prefix: str) -> list[_AddonGroup]:
+        if directory is None or not directory.is_dir():
             return []
-        groups: list[tuple[str, tuple[str, ...], tuple[AddonSettingSpec, ...], Path]] = []
-        for path in sorted(self._task_handlers_dir.glob("*.py")):
+        groups: list[_AddonGroup] = []
+        for path in sorted(directory.glob("*.py")):
             if path.name.startswith("_"):
                 continue
             specs = self._settings_specs_from_module(path)
             if specs:
-                groups.append((f"Task Handlers / {path.stem}", ("addons", "task_handlers", path.stem), specs, path))
+                groups.append((f"{title_prefix} / {path.stem}", ("addons", key, path.stem), specs, path))
         return groups
 
     def _settings_specs_from_module(self, path: Path) -> tuple[AddonSettingSpec, ...]:
@@ -504,9 +529,18 @@ class SettingsDialog(QDialog):
 
     def _record_addon_settings_error(self, path: Path, message: str) -> None:
         self._addon_settings_errors.append(
-            _AddonSettingsError(label=f"{path.parent.name}/{path.stem}", file_path=path, message=message)
+            _AddonSettingsError(
+                category=self._addon_category_for_path(path), label=path.stem, file_path=path, message=message
+            )
         )
 
+    def _addon_category_for_path(self, path: Path) -> str:
+        if self._plotters_dir is not None and path.parent == self._plotters_dir:
+            return _PLOTTERS
+        if self._task_handlers_dir is not None and path.parent == self._task_handlers_dir:
+            return _TASK_HANDLERS
+        return _EXPERIMENT_HANDLERS
+
     def _minimum_label_width(self, specs: tuple[AddonSettingSpec, ...]) -> int:
         metrics = self.fontMetrics()
         return max(metrics.horizontalAdvance(spec.title) for spec in specs) + 8