nucleuskit-toolkit 2.2.0__py3-none-any.whl

nucleuskit_toolkit/ui/pages/recording_merge_page.py

@@ -0,0 +1,395 @@
+"""Recording Merger: join up to 5 recordings with null-padded CSV gaps and black-screen video gaps."""
+
+from __future__ import annotations
+
+import queue
+import sys
+import traceback
+from pathlib import Path
+
+from PySide6.QtCore import QObject, QThread, QTimer, Signal, Slot
+from PySide6.QtGui import QTextCursor
+from PySide6.QtWidgets import (
+    QCheckBox,
+    QDoubleSpinBox,
+    QFileDialog,
+    QGroupBox,
+    QHBoxLayout,
+    QLabel,
+    QLineEdit,
+    QMessageBox,
+    QPlainTextEdit,
+    QProgressBar,
+    QPushButton,
+    QSizePolicy,
+    QVBoxLayout,
+    QWidget,
+)
+
+from nucleuskit_toolkit.tools.recording_merger import merge_recordings
+from nucleuskit_toolkit.ui.offline_job import QueueTextWriter
+
+_MAX_RECORDINGS = 5
+
+
+# ── worker ─────────────────────────────────────────────────────────────────────
+
+class _MergeWorker(QObject):
+    finished_ok  = Signal()
+    finished_err = Signal(str)
+
+    def __init__(
+        self,
+        folders: list[str],
+        offsets: list[float],
+        output_dir: str,
+        log_queue: queue.SimpleQueue[str],
+        skip_video: bool = False,
+    ) -> None:
+        super().__init__()
+        self._folders    = folders
+        self._offsets    = offsets
+        self._output_dir = output_dir
+        self._log_queue  = log_queue
+        self._skip_video = skip_video
+
+    @Slot()
+    def run(self) -> None:
+        err: str | None = None
+        writer = QueueTextWriter(self._log_queue)
+        old_out, old_err = sys.stdout, sys.stderr
+        try:
+            sys.stdout = writer
+            sys.stderr = writer
+            merge_recordings(
+                self._folders, self._offsets, self._output_dir,
+                self._log_queue, skip_video=self._skip_video,
+            )
+        except BaseException:
+            err = traceback.format_exc()
+            self._log_queue.put(err)
+        finally:
+            sys.stdout = old_out
+            sys.stderr = old_err
+
+        if err:
+            self.finished_err.emit("Run finished with errors (see log).")
+        else:
+            self.finished_ok.emit()
+
+
+# ── recording row widget ────────────────────────────────────────────────────────
+
+class _RecordingRow(QWidget):
+    """One row: index label | path field | Browse | [Offset label | spin] | [Remove]."""
+
+    path_changed     = Signal()
+    remove_requested = Signal(object)   # emits self
+
+    def __init__(self, index: int, parent: QWidget | None = None) -> None:
+        super().__init__(parent)
+        self._index = index
+
+        self._label = QLabel(f"Recording {index + 1}:")
+        self._label.setFixedWidth(100)
+
+        self._path = QLineEdit()
+        self._path.setPlaceholderText("Recording folder path…")
+        self._path.textChanged.connect(lambda _: self.path_changed.emit())
+
+        self._browse = QPushButton("Browse…")
+        self._browse.clicked.connect(self._browse_clicked)
+
+        self._offset_label = QLabel("Offset:")
+        self._offset = QDoubleSpinBox()
+        self._offset.setRange(0.0, 86_400.0)   # up to 24 h
+        self._offset.setSingleStep(1.0)
+        self._offset.setSuffix(" s")
+        self._offset.setValue(0.0)
+        self._offset.setFixedWidth(110)
+        self._offset.setToolTip("Gap in seconds from the end of the previous recording to the start of this one.")
+
+        self._remove = QPushButton("Remove")
+        self._remove.setProperty("secondary", True)
+        self._remove.clicked.connect(lambda: self.remove_requested.emit(self))
+
+        row = QHBoxLayout(self)
+        row.setContentsMargins(0, 2, 0, 2)
+        row.addWidget(self._label)
+        row.addWidget(self._path, 1)
+        row.addWidget(self._browse)
+        row.addWidget(self._offset_label)
+        row.addWidget(self._offset)
+        row.addWidget(self._remove)
+
+        self._refresh_visibility()
+
+    # ── public ────────────────────────────────────────────────────────────────
+
+    def folder(self) -> str:
+        return self._path.text().strip()
+
+    def offset(self) -> float:
+        return self._offset.value()
+
+    def set_index(self, new_index: int) -> None:
+        self._index = new_index
+        self._label.setText(f"Recording {new_index + 1}:")
+        self._refresh_visibility()
+
+    def set_controls_enabled(self, enabled: bool) -> None:
+        self._path.setEnabled(enabled)
+        self._browse.setEnabled(enabled)
+        self._offset.setEnabled(enabled)
+        self._remove.setEnabled(enabled)
+
+    # ── private ───────────────────────────────────────────────────────────────
+
+    def _refresh_visibility(self) -> None:
+        is_first = self._index == 0
+        self._offset_label.setVisible(not is_first)
+        self._offset.setVisible(not is_first)
+        self._remove.setVisible(not is_first)
+
+    def _browse_clicked(self) -> None:
+        path = QFileDialog.getExistingDirectory(self, "Select recording folder")
+        if path:
+            self._path.setText(path)
+
+
+# ── main page ──────────────────────────────────────────────────────────────────
+
+class RecordingMergePage(QWidget):
+    go_tools_menu      = Signal()
+    processing_changed = Signal(bool)
+
+    def __init__(self, parent: QWidget | None = None) -> None:
+        super().__init__(parent)
+
+        self._log_queue: queue.SimpleQueue[str] = queue.SimpleQueue()
+        self._thread: QThread | None            = None
+        self._worker: _MergeWorker | None       = None
+        self._rows: list[_RecordingRow]         = []
+
+        # ── top bar ───────────────────────────────────────────────────────────
+        self._back = QPushButton("Back")
+        self._back.setProperty("secondary", True)
+        self._back.clicked.connect(self.go_tools_menu.emit)
+
+        top = QHBoxLayout()
+        top.addStretch(1)
+        top.addWidget(self._back)
+
+        # ── recordings group ──────────────────────────────────────────────────
+        self._rows_layout = QVBoxLayout()
+        self._rows_layout.setSpacing(4)
+
+        self._add_btn = QPushButton("+ Add recording")
+        self._add_btn.setSizePolicy(QSizePolicy.Policy.Fixed, QSizePolicy.Policy.Fixed)
+        self._add_btn.clicked.connect(self._add_row)
+
+        rows_inner = QVBoxLayout()
+        rows_inner.addLayout(self._rows_layout)
+        rows_inner.addWidget(self._add_btn)
+
+        recordings_box = QGroupBox("Recordings  (2–5, in order)")
+        recordings_box.setLayout(rows_inner)
+
+        # ── output folder ─────────────────────────────────────────────────────
+        self._output = QLineEdit()
+        self._output.setReadOnly(True)
+        self._output.setPlaceholderText("Set Recording 1 path to auto-generate…")
+
+        out_row = QHBoxLayout()
+        out_row.addWidget(QLabel("Output folder (auto):"))
+        out_row.addWidget(self._output, 1)
+
+        # ── actions ───────────────────────────────────────────────────────────
+        self._skip_video = QCheckBox("Skip video merge")
+        self._skip_video.setToolTip(
+            "When checked, only result CSVs are merged; video files are ignored."
+        )
+
+        self._run = QPushButton("Start Merge")
+        self._run.clicked.connect(self._run_clicked)
+
+        self._progress = QProgressBar()
+        self._progress.setRange(0, 0)
+        self._progress.setVisible(False)
+
+        actions = QHBoxLayout()
+        actions.addWidget(self._skip_video)
+        actions.addStretch(1)
+        actions.addWidget(self._run)
+        actions.addWidget(self._progress, 1)
+
+        # ── log ───────────────────────────────────────────────────────────────
+        self._log = QPlainTextEdit()
+        self._log.setReadOnly(True)
+
+        log_box = QGroupBox("Log")
+        lg = QVBoxLayout(log_box)
+        lg.addWidget(self._log)
+
+        # ── assemble ──────────────────────────────────────────────────────────
+        layout = QVBoxLayout(self)
+        layout.addLayout(top)
+        layout.addWidget(recordings_box)
+        layout.addLayout(out_row)
+        layout.addLayout(actions)
+        layout.addWidget(log_box, 1)
+
+        # seed with two rows so the tool is immediately usable
+        self._add_row()
+        self._add_row()
+
+        self._poll_timer = QTimer(self)
+        self._poll_timer.timeout.connect(self._drain_log_queue)
+        self._poll_timer.start(120)
+
+    # ── row management ────────────────────────────────────────────────────────
+
+    def _add_row(self) -> None:
+        if len(self._rows) >= _MAX_RECORDINGS:
+            return
+        row = _RecordingRow(len(self._rows), self)
+        row.path_changed.connect(self._update_output_folder)
+        row.remove_requested.connect(self._remove_row)
+        self._rows_layout.addWidget(row)
+        self._rows.append(row)
+        self._add_btn.setEnabled(len(self._rows) < _MAX_RECORDINGS)
+
+    def _remove_row(self, row: _RecordingRow) -> None:
+        if row not in self._rows:
+            return
+        self._rows.remove(row)
+        self._rows_layout.removeWidget(row)
+        row.deleteLater()
+        for i, r in enumerate(self._rows):
+            r.set_index(i)
+        self._add_btn.setEnabled(len(self._rows) < _MAX_RECORDINGS)
+        self._update_output_folder()
+
+    def _update_output_folder(self) -> None:
+        if not self._rows:
+            self._output.setText("")
+            return
+        first_path = self._rows[0].folder()
+        if not first_path:
+            self._output.setText("")
+            return
+        names = [Path(r.folder()).name for r in self._rows if r.folder()]
+        merged_name = "merged_" + "_".join(names) if names else "merged_recording"
+        self._output.setText(str(Path(first_path).parent / merged_name))
+
+    # ── validation ────────────────────────────────────────────────────────────
+
+    def _validate(self) -> str | None:
+        if len(self._rows) < 2:
+            return "Add at least 2 recordings to merge."
+
+        for i, row in enumerate(self._rows):
+            f = row.folder()
+            if not f:
+                return f"Recording {i + 1} has no folder selected."
+            p = Path(f)
+            if not p.is_dir():
+                return f"Recording {i + 1}: folder does not exist:\n{f}"
+            if not (p / "results").is_dir() and not (p / "rawData").is_dir():
+                return (
+                    f"Recording {i + 1}: folder does not look like a recording\n"
+                    f"(no 'results/' or 'rawData/' subfolder found):\n{f}"
+                )
+
+        output = self._output.text().strip()
+        if not output:
+            return "Cannot determine output folder. Set Recording 1 path first."
+        if Path(output).exists():
+            return (
+                f"Output folder already exists:\n{output}\n\n"
+                "Remove or rename it before merging."
+            )
+
+        return None
+
+    # ── run ───────────────────────────────────────────────────────────────────
+
+    def _run_clicked(self) -> None:
+        err = self._validate()
+        if err:
+            QMessageBox.warning(self, "Recording Merger", err)
+            return
+        if self._thread is not None and self._thread.isRunning():
+            QMessageBox.information(self, "Busy", "A merge is already in progress.")
+            return
+
+        folders    = [row.folder() for row in self._rows]
+        offsets    = [row.offset() for row in self._rows[1:]]
+        output_dir = self._output.text().strip()
+        skip_video = self._skip_video.isChecked()
+
+        self._set_processing(True)
+        self._insert_log(
+            f"\n--- Starting merge of {len(folders)} recordings ---\n"
+            + "".join(f"  [{i + 1}] {f}\n" for i, f in enumerate(folders))
+            + ("  (video merge skipped)\n" if skip_video else "")
+            + "\n"
+        )
+
+        thread = QThread()
+        worker = _MergeWorker(folders, offsets, output_dir, self._log_queue, skip_video)
+        worker.moveToThread(thread)
+
+        thread.started.connect(worker.run)
+        worker.finished_ok.connect(self._on_finished_ok)
+        worker.finished_err.connect(self._on_finished_err)
+        worker.finished_ok.connect(thread.quit)
+        worker.finished_err.connect(thread.quit)
+        thread.finished.connect(worker.deleteLater)
+        thread.finished.connect(thread.deleteLater)
+        thread.finished.connect(self._clear_thread_ref)
+
+        self._thread = thread
+        self._worker = worker
+        thread.start()
+
+    def _set_processing(self, running: bool) -> None:
+        self._back.setEnabled(not running)
+        self._run.setEnabled(not running)
+        self._add_btn.setEnabled(not running)
+        self._skip_video.setEnabled(not running)
+        self._progress.setVisible(running)
+        for row in self._rows:
+            row.set_controls_enabled(not running)
+        self.processing_changed.emit(running)
+
+    def _clear_thread_ref(self) -> None:
+        self._thread = None
+        self._worker = None
+
+    def _on_finished_ok(self) -> None:
+        self._set_processing(False)
+        QMessageBox.information(
+            self,
+            "Recording Merger",
+            f"Done.\n\nMerged recording saved to:\n{self._output.text()}",
+        )
+
+    def _on_finished_err(self, msg: str) -> None:
+        self._set_processing(False)
+        QMessageBox.critical(self, "Recording Merger", msg)
+
+    # ── log helpers ───────────────────────────────────────────────────────────
+
+    def _insert_log(self, text: str) -> None:
+        self._log.moveCursor(QTextCursor.MoveOperation.End)
+        self._log.insertPlainText(text)
+        sb = self._log.verticalScrollBar()
+        sb.setValue(sb.maximum())
+
+    def _drain_log_queue(self) -> None:
+        try:
+            while True:
+                self._insert_log(self._log_queue.get_nowait())
+        except queue.Empty:
+            pass

nucleuskit_toolkit/ui/pages/revert_original_page.py

@@ -0,0 +1,128 @@
+"""Revert working RMS CSV to the frozen baseline in ``features/emotions/original/``."""
+
+from __future__ import annotations
+
+import os
+
+from PySide6.QtCore import Signal
+from PySide6.QtWidgets import (
+    QFileDialog,
+    QGroupBox,
+    QHBoxLayout,
+    QLabel,
+    QMessageBox,
+    QPlainTextEdit,
+    QPushButton,
+    QVBoxLayout,
+    QWidget,
+)
+from reak_core.tools.rms_ops import (
+    operations_log_path,
+    original_rms_csv,
+    revert_working_to_original,
+)
+
+from nucleuskit_toolkit.ui.offline_job import rms_features_preflight
+
+
+class RevertOriginalPage(QWidget):
+    go_tools_menu = Signal()
+
+    def __init__(self, parent: QWidget | None = None) -> None:
+        super().__init__(parent)
+
+        self._back = QPushButton("Back")
+        self._back.setProperty("secondary", True)
+        self._back.clicked.connect(self.go_tools_menu.emit)
+
+        top = QHBoxLayout()
+        top.addStretch(1)
+        top.addWidget(self._back)
+
+        self._session = QLabel()
+        self._session.setWordWrap(True)
+        self._session.setText("No session selected.")
+
+        self._browse = QPushButton("Select session folder…")
+        self._browse.clicked.connect(self._browse_session)
+
+        self._revert = QPushButton("Revert to original")
+        self._revert.clicked.connect(self._revert_clicked)
+
+        sess_box = QGroupBox("Session")
+        sg = QVBoxLayout(sess_box)
+        sg.addWidget(self._browse)
+        sg.addWidget(self._session)
+
+        self._log = QPlainTextEdit()
+        self._log.setReadOnly(True)
+        self._log.setPlaceholderText("operations.log tail (after revert)…")
+
+        log_box = QGroupBox("Recent operations log")
+        lg = QVBoxLayout(log_box)
+        lg.addWidget(self._log)
+
+        layout = QVBoxLayout(self)
+        layout.addLayout(top)
+        layout.addWidget(sess_box)
+        layout.addWidget(self._revert)
+        layout.addWidget(log_box, 1)
+
+        self._folder: str | None = None
+
+    def _browse_session(self) -> None:
+        path = QFileDialog.getExistingDirectory(self, "Select session folder")
+        if path:
+            self._folder = path
+            self._session.setText(path)
+            self._refresh_log_tail()
+
+    def _refresh_log_tail(self) -> None:
+        if not self._folder:
+            self._log.clear()
+            return
+        log_path = operations_log_path(self._folder)
+        if not os.path.isfile(log_path):
+            self._log.clear()
+            return
+        try:
+            with open(log_path, encoding="utf-8") as fh:
+                lines = fh.readlines()
+            tail = "".join(lines[-80:])
+            self._log.setPlainText(tail)
+        except OSError:
+            self._log.setPlainText("(Could not read log.)")
+
+    def _revert_clicked(self) -> None:
+        if not self._folder:
+            QMessageBox.warning(self, "Session", "Please select a session folder.")
+            return
+        err = rms_features_preflight(self._folder)
+        if err:
+            QMessageBox.warning(self, "Session", err)
+            return
+        ori = original_rms_csv(self._folder)
+        if not ori.is_file():
+            QMessageBox.warning(
+                self,
+                "Revert",
+                f"No frozen baseline found:\n{ori}\n\n"
+                "Run a tool that writes RMS (channel fixer or gain adjustment) first.",
+            )
+            return
+        confirm = QMessageBox.question(
+            self,
+            "Revert to original",
+            "Overwrite features/emotions/rmsSignals.csv with the frozen baseline?",
+            QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
+            QMessageBox.StandardButton.No,
+        )
+        if confirm != QMessageBox.StandardButton.Yes:
+            return
+        try:
+            revert_working_to_original(self._folder)
+        except OSError as e:
+            QMessageBox.critical(self, "Revert", str(e))
+            return
+        self._refresh_log_tail()
+        QMessageBox.information(self, "Revert", "Working RMS file restored from original.")

nucleuskit_toolkit/ui/pages/settings_page.py

@@ -0,0 +1,69 @@
+"""Appearance and other settings."""
+
+from __future__ import annotations
+
+from PySide6.QtCore import QSettings, Signal
+from PySide6.QtWidgets import QComboBox, QHBoxLayout, QVBoxLayout, QWidget
+
+from nucleuskit_toolkit.ui.theme import ThemeMode
+from nucleuskit_toolkit.ui.widgets import Card, SectionHeader, label
+
+ORGANIZATION = "REAK"
+APPLICATION = "NucleusKitToolkit"
+SETTINGS_THEME_KEY = "appearance/theme"
+
+
+def load_theme_setting() -> ThemeMode:
+    s = QSettings(ORGANIZATION, APPLICATION)
+    raw = s.value(SETTINGS_THEME_KEY, "system")
+    if raw in ("light", "dark", "system"):
+        return raw  # type: ignore[return-value]
+    return "system"
+
+
+def save_theme_setting(mode: ThemeMode) -> None:
+    s = QSettings(ORGANIZATION, APPLICATION)
+    s.setValue(SETTINGS_THEME_KEY, mode)
+
+
+class SettingsPage(QWidget):
+    """Theme selection persisted with QSettings."""
+
+    theme_changed = Signal(str)
+
+    def __init__(self, parent: QWidget | None = None) -> None:
+        super().__init__(parent)
+        self._theme_combo = QComboBox()
+        self._theme_combo.addItem("Light", "light")
+        self._theme_combo.addItem("Dark", "dark")
+        self._theme_combo.addItem("System", "system")
+        self._theme_combo.setMinimumWidth(220)
+
+        current = load_theme_setting()
+        idx = max(0, self._theme_combo.findData(current))
+        self._theme_combo.setCurrentIndex(idx)
+
+        appearance = Card()
+        appearance.setMaximumWidth(760)
+        appearance.body.addWidget(SectionHeader("Appearance", "Colours of the application.", icon="settings"))
+        row = QHBoxLayout()
+        text = QVBoxLayout()
+        text.setSpacing(2)
+        text.addWidget(label("Theme", "strong"))
+        text.addWidget(label("System follows the light or dark mode of the operating system.", "hint"))
+        row.addLayout(text, 1)
+        row.addWidget(self._theme_combo)
+        appearance.body.addLayout(row)
+
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.addWidget(appearance)
+        layout.addStretch(1)
+
+        self._theme_combo.currentIndexChanged.connect(self._on_theme_changed)
+
+    def _on_theme_changed(self, _index: int) -> None:
+        mode = self._theme_combo.currentData()
+        if mode:
+            save_theme_setting(mode)
+            self.theme_changed.emit(mode)

nucleuskit_toolkit/ui/pages/tools_menu_page.py

@@ -0,0 +1,42 @@
+"""Auxiliary tools for processed sessions (Channel Fixer, …), shown as a grid of cards."""
+
+from __future__ import annotations
+
+from PySide6.QtCore import Signal
+from PySide6.QtWidgets import QGridLayout, QVBoxLayout, QWidget
+
+from nucleuskit_toolkit.ui.widgets import ChoiceCard
+
+TOOLS = (
+    ("open_channel_fixer", "Channel Fixer", "Repair a single bad RMS channel with the channel-fix model."),
+    ("open_channel_gain", "Channel gain adjustment", "Adjust per-channel RMS gain and zero offset."),
+    ("open_revert_original", "Revert to original", "Restore the RMS features from the frozen baseline."),
+    ("open_ppg_fixer", "PPG Fixer", "Re-run PPG artifact rejection and heart dynamics."),
+    ("open_eeg_regression", "EEG Regression Denoising", "Remove shared muscle noise from the EEG."),
+    ("open_recording_merge", "Recording Merger", "Join up to 5 recordings into one session."),
+)
+
+
+class ToolsMenuPage(QWidget):
+    open_channel_fixer = Signal()
+    open_channel_gain = Signal()
+    open_revert_original = Signal()
+    open_ppg_fixer = Signal()
+    open_eeg_regression = Signal()
+    open_recording_merge = Signal()
+
+    def __init__(self, parent: QWidget | None = None) -> None:
+        super().__init__(parent)
+        grid = QGridLayout()
+        grid.setHorizontalSpacing(14)
+        grid.setVerticalSpacing(14)
+        for i, (signal_name, title, description) in enumerate(TOOLS):
+            card = ChoiceCard("wrench", title, description)
+            card.set_indicator_visible(False)
+            card.clicked.connect(getattr(self, signal_name).emit)
+            grid.addWidget(card, i // 2, i % 2)
+
+        outer = QVBoxLayout(self)
+        outer.setContentsMargins(0, 0, 0, 0)
+        outer.addLayout(grid)
+        outer.addStretch(1)