nucleuskit-toolkit 2.2.0__py3-none-any.whl

nucleuskit_toolkit/ui/pages/about_page.py

@@ -0,0 +1,88 @@
+"""About: application and processing-core versions, emotion models, license and links."""
+
+from __future__ import annotations
+
+from importlib.metadata import PackageNotFoundError, version
+
+from PySide6.QtCore import Qt, QUrl
+from PySide6.QtGui import QDesktopServices
+from PySide6.QtWidgets import QGridLayout, QHBoxLayout, QPushButton, QVBoxLayout, QWidget
+
+import nucleuskit_toolkit
+from nucleuskit_toolkit.ui.icons import icon
+from nucleuskit_toolkit.ui.theme import current_palette
+from nucleuskit_toolkit.ui.widgets import Card, Divider, SectionHeader, label
+
+LINKS = (
+    ("Nucleus-Kit on GitHub", "https://github.com/fs-re-ak/NucleusKit-ProcessingPipeline"),
+    ("re-ak-core on GitHub", "https://github.com/fs-re-ak/re-ak-core"),
+    ("Changelog", "https://github.com/fs-re-ak/NucleusKit-ProcessingPipeline/blob/main/CHANGELOG.md"),
+    ("License (GPL-3.0-or-later)", "https://github.com/fs-re-ak/NucleusKit-ProcessingPipeline/blob/main/LICENSE"),
+)
+
+
+def _package_version(name: str) -> str:
+    try:
+        return version(name)
+    except PackageNotFoundError:
+        return "not installed"
+
+
+class AboutPage(QWidget):
+    def __init__(self, parent: QWidget | None = None) -> None:
+        super().__init__(parent)
+        from reak_core.models import DEFAULT_MODEL, builtin_releases, resolve_key
+
+        card = Card()
+        card.setMaximumWidth(960)
+        card.body.addWidget(
+            SectionHeader(
+                "Nucleus-Kit Processing Toolkit", "Copyright (C) 2026 RE-AK Technologies Inc.", icon="activity"
+            )
+        )
+        card.body.addWidget(Divider())
+
+        grid = QGridLayout()
+        grid.setHorizontalSpacing(24)
+        grid.setVerticalSpacing(10)
+        default = resolve_key(DEFAULT_MODEL)
+        models = ", ".join(
+            f"{r.name} {r.version}" + (" (recommended)" if key == default else "")
+            for key, r in builtin_releases().items()
+        )
+        rows = (
+            ("Version", nucleuskit_toolkit.__version__),
+            ("Processing core", f"re-ak-core {_package_version('re-ak-core')}"),
+            ("Emotion models", models),
+            ("Qt", f"PySide6 {_package_version('PySide6')}"),
+            ("License", "GNU General Public License v3.0 or later"),
+        )
+        for i, (name, value) in enumerate(rows):
+            grid.addWidget(label(name, "hint"), i, 0, Qt.AlignmentFlag.AlignTop)
+            grid.addWidget(label(value, "strong", wrap=True), i, 1)
+        grid.setColumnStretch(1, 1)
+        card.body.addLayout(grid)
+        card.body.addWidget(Divider())
+
+        links = QHBoxLayout()
+        links.setSpacing(8)
+        self._link_buttons: list[QPushButton] = []
+        for text, url in LINKS:
+            btn = QPushButton("  " + text)
+            btn.setProperty("variant", "secondary")
+            btn.setCursor(Qt.CursorShape.PointingHandCursor)
+            btn.clicked.connect(lambda _=False, u=url: QDesktopServices.openUrl(QUrl(u)))
+            links.addWidget(btn)
+            self._link_buttons.append(btn)
+        links.addStretch(1)
+        card.body.addLayout(links)
+        self.refresh_theme()
+
+        col = QVBoxLayout(self)
+        col.setContentsMargins(0, 0, 0, 0)
+        col.addWidget(card)
+        col.addStretch(1)
+
+    def refresh_theme(self) -> None:
+        for btn in self._link_buttons:
+            btn.setIcon(icon("external", current_palette().text, 16))

nucleuskit_toolkit/ui/pages/channel_fixer_page.py

@@ -0,0 +1,205 @@
+"""Channel Fixer: repair one RMS channel in a processed session."""
+
+from __future__ import annotations
+
+import queue
+import sys
+import traceback
+
+from PySide6.QtCore import QObject, QThread, QTimer, Signal, Slot
+from PySide6.QtGui import QTextCursor
+from PySide6.QtWidgets import (
+    QComboBox,
+    QFileDialog,
+    QGroupBox,
+    QHBoxLayout,
+    QLineEdit,
+    QMessageBox,
+    QPlainTextEdit,
+    QProgressBar,
+    QPushButton,
+    QVBoxLayout,
+    QWidget,
+)
+from reak_core.constants import CHANNEL_NAMES
+from reak_core.tools import fix_session
+
+from nucleuskit_toolkit.ui.offline_job import QueueTextWriter, channel_fixer_preflight
+
+
+class ChannelFixerWorker(QObject):
+    finished_ok = Signal()
+    finished_err = Signal(str)
+
+    def __init__(
+        self,
+        folder: str,
+        channel_idx: int,
+        log_queue: queue.SimpleQueue[str],
+    ) -> None:
+        super().__init__()
+        self._folder = folder
+        self._channel_idx = channel_idx
+        self._log_queue = log_queue
+
+    @Slot()
+    def run_fix(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
+            out = fix_session(self._folder, self._channel_idx)
+            print(f"Report written: {out}")
+        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()
+
+
+class ChannelFixerPage(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: ChannelFixerWorker | None = None
+
+        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 = QLineEdit()
+        self._session.setPlaceholderText("Session folder path…")
+        browse_s = QPushButton("Browse…")
+        browse_s.clicked.connect(self._browse_session)
+
+        sess_row = QHBoxLayout()
+        sess_row.addWidget(self._session, 1)
+        sess_row.addWidget(browse_s)
+
+        self._channel = QComboBox()
+        for name in CHANNEL_NAMES:
+            self._channel.addItem(name)
+
+        ch_row = QHBoxLayout()
+        ch_row.addWidget(self._channel, 1)
+
+        session_box = QGroupBox("Session (must contain features/emotions/rmsSignals.csv)")
+        sg = QVBoxLayout(session_box)
+        sg.addLayout(sess_row)
+
+        channel_box = QGroupBox("Channel to fix (canonical name)")
+        cg = QVBoxLayout(channel_box)
+        cg.addLayout(ch_row)
+
+        self._run = QPushButton("Run channel fixer")
+        self._run.clicked.connect(self._run_clicked)
+
+        self._progress = QProgressBar()
+        self._progress.setRange(0, 0)
+        self._progress.setVisible(False)
+
+        actions = QHBoxLayout()
+        actions.addWidget(self._run)
+        actions.addWidget(self._progress, 1)
+
+        self._log = QPlainTextEdit()
+        self._log.setReadOnly(True)
+
+        log_box = QGroupBox("Log")
+        lg = QVBoxLayout(log_box)
+        lg.addWidget(self._log)
+
+        layout = QVBoxLayout(self)
+        layout.addLayout(top)
+        layout.addWidget(session_box)
+        layout.addWidget(channel_box)
+        layout.addLayout(actions)
+        layout.addWidget(log_box, 1)
+
+        self._poll_timer = QTimer(self)
+        self._poll_timer.timeout.connect(self._drain_log_queue)
+        self._poll_timer.start(120)
+
+    def _browse_session(self) -> None:
+        path = QFileDialog.getExistingDirectory(self, "Select session folder")
+        if path:
+            self._session.setText(path)
+
+    def _set_processing(self, running: bool) -> None:
+        self._back.setEnabled(not running)
+        self._run.setEnabled(not running)
+        self._session.setEnabled(not running)
+        self._channel.setEnabled(not running)
+        self._progress.setVisible(running)
+        self.processing_changed.emit(running)
+
+    def _run_clicked(self) -> None:
+        folder = self._session.text().strip()
+        err = channel_fixer_preflight(folder)
+        if err:
+            QMessageBox.warning(self, "Session", err)
+            return
+        if self._thread is not None and self._thread.isRunning():
+            QMessageBox.information(self, "Busy", "A run is already in progress.")
+            return
+
+        channel_idx = self._channel.currentIndex()
+        self._set_processing(True)
+        self._insert_log(f"\n--- Starting channel fixer: {folder!r} channel index {channel_idx} ---\n")
+
+        thread = QThread()
+        worker = ChannelFixerWorker(folder, channel_idx, self._log_queue)
+        worker.moveToThread(thread)
+        thread.started.connect(worker.run_fix)
+        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 _clear_thread_ref(self) -> None:
+        self._thread = None
+        self._worker = None
+
+    def _on_finished_ok(self) -> None:
+        self._set_processing(False)
+        QMessageBox.information(self, "Channel fixer", "Run finished.")
+
+    def _on_finished_err(self, msg: str) -> None:
+        self._set_processing(False)
+        QMessageBox.critical(self, "Channel fixer", msg)
+
+    def _insert_log(self, text: str) -> None:
+        self._log.moveCursor(QTextCursor.End)
+        self._log.insertPlainText(text)
+        sb = self._log.verticalScrollBar()
+        sb.setValue(sb.maximum())
+
+    def _drain_log_queue(self) -> None:
+        try:
+            while True:
+                chunk = self._log_queue.get_nowait()
+                self._insert_log(chunk)
+        except queue.Empty:
+            pass

nucleuskit_toolkit/ui/pages/channel_gain_page.py

@@ -0,0 +1,362 @@
+"""Per-channel RMS gain and zero adjustment with blue vs red distribution plots."""
+
+from __future__ import annotations
+
+import numpy as np
+import pandas as pd
+import pyqtgraph as pg
+from PySide6.QtCore import Qt, Signal
+from PySide6.QtWidgets import (
+    QAbstractItemView,
+    QComboBox,
+    QDoubleSpinBox,
+    QFileDialog,
+    QFormLayout,
+    QGroupBox,
+    QHBoxLayout,
+    QHeaderView,
+    QLabel,
+    QMessageBox,
+    QPushButton,
+    QScrollArea,
+    QSizePolicy,
+    QSplitter,
+    QTableWidget,
+    QTableWidgetItem,
+    QVBoxLayout,
+    QWidget,
+)
+from reak_core.constants import CHANNEL_NAMES
+from reak_core.tools.rms_columns import as_output_rms_frame, normalize_rms_dataframe
+from reak_core.tools.rms_ops import (
+    append_operation,
+    ensure_baseline_snapshot,
+    original_rms_csv,
+    working_rms_csv,
+)
+
+from nucleuskit_toolkit.ui.offline_job import rms_features_preflight
+from nucleuskit_toolkit.ui.plot_style import plot_colors, set_label, set_title, style_plot, style_view, translucent
+
+
+def _quartile_stats(values: np.ndarray) -> tuple[float, float, float, float, float]:
+    a = np.asarray(values, dtype=float)
+    a = a[np.isfinite(a)]
+    if a.size == 0:
+        return (float("nan"),) * 5
+    qs = np.quantile(a, (0.0, 0.25, 0.5, 0.75, 1.0))
+    return tuple(float(x) for x in qs)
+
+
+def _apply_gain_zero(df: pd.DataFrame, gains: list[float], zeros: list[float]) -> pd.DataFrame:
+    out = df.copy()
+    for i, name in enumerate(CHANNEL_NAMES):
+        out[name] = out[name].astype(float) * gains[i] + zeros[i]
+    return out
+
+
+class ChannelGainPage(QWidget):
+    go_tools_menu = Signal()
+
+    _MAX_SCATTER = 1800
+    _X_LEFT = -0.35
+    _X_RIGHT = 0.75
+
+    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._folder: str | None = None
+        self._work_df: pd.DataFrame | None = None
+        self._blue_df: pd.DataFrame | None = None
+
+        self._gains = [1.0] * 8
+        self._zeros = [0.0] * 8
+        self._spin_gains: list[QDoubleSpinBox] = []
+        self._spin_zeros: list[QDoubleSpinBox] = []
+
+        self._browse = QPushButton("Select session folder…")
+        self._browse.clicked.connect(self._browse_session)
+
+        self._reload = QPushButton("Reload RMS")
+        self._reload.clicked.connect(self._reload_data)
+
+        self._apply = QPushButton("Apply to rmsSignals.csv")
+        self._apply.clicked.connect(self._apply_clicked)
+
+        self._hint = QLabel(
+            "Blue = frozen baseline (original/rmsSignals.csv if present, else current file on load). "
+            "Red = preview after gain/zero. Zoom and pan on the plot affect the vertical axis only."
+        )
+        self._hint.setWordWrap(True)
+
+        self._channel_combo = QComboBox()
+        for name in CHANNEL_NAMES:
+            self._channel_combo.addItem(name)
+        self._channel_combo.currentIndexChanged.connect(lambda _i: self._refresh_preview())
+
+        ctrl_col = QVBoxLayout()
+        ctrl_col.addWidget(self._browse)
+        ctrl_col.addWidget(self._reload)
+        ctrl_col.addWidget(self._apply)
+        ctrl_col.addWidget(self._hint)
+        ctrl_col.addWidget(QLabel("Plot channel:"))
+        ctrl_col.addWidget(self._channel_combo)
+
+        form_scroll = QScrollArea()
+        form_scroll.setWidgetResizable(True)
+        form_inner = QWidget()
+        form_layout = QVBoxLayout(form_inner)
+        for i, name in enumerate(CHANNEL_NAMES):
+            box = QGroupBox(name)
+            fl = QFormLayout(box)
+            sg = QDoubleSpinBox()
+            sg.setRange(0.001, 1000.0)
+            sg.setDecimals(4)
+            sg.setValue(1.0)
+            sg.setSingleStep(0.05)
+            sz = QDoubleSpinBox()
+            sz.setRange(-1e6, 1e6)
+            sz.setDecimals(4)
+            sz.setValue(0.0)
+
+            def _mk_gain_handler(ii: int):
+                def _h(v: float) -> None:
+                    self._gains[ii] = v
+                    self._refresh_preview()
+
+                return _h
+
+            def _mk_zero_handler(ii: int):
+                def _h(v: float) -> None:
+                    self._zeros[ii] = v
+                    self._refresh_preview()
+
+                return _h
+
+            sg.valueChanged.connect(_mk_gain_handler(i))
+            sz.valueChanged.connect(_mk_zero_handler(i))
+            fl.addRow("Gain", sg)
+            fl.addRow("Zero", sz)
+            self._spin_gains.append(sg)
+            self._spin_zeros.append(sz)
+            form_layout.addWidget(box)
+        form_layout.addStretch(1)
+        form_scroll.setWidget(form_inner)
+
+        self._table = QTableWidget()
+        self._table.setColumnCount(11)
+        self._table.setHorizontalHeaderLabels(
+            [
+                "Channel",
+                "min B",
+                "min R",
+                "Q1 B",
+                "Q1 R",
+                "Med B",
+                "Med R",
+                "Q3 B",
+                "Q3 R",
+                "max B",
+                "max R",
+            ]
+        )
+        self._table.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeMode.Stretch)
+        self._table.setEditTriggers(QAbstractItemView.EditTrigger.NoEditTriggers)
+        self._table.setRowCount(8)
+
+        self._plot = pg.PlotWidget()
+        set_label(self._plot.getPlotItem(), "left", "RMS")
+        self.refresh_theme()
+        self._plot.setMinimumHeight(280)
+        self._plot.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
+        vb = self._plot.getViewBox()
+        vb.setMouseEnabled(x=False, y=True)
+        vb.sigRangeChanged.connect(self._on_plot_range_changed)
+
+        right_split = QSplitter(Qt.Orientation.Vertical)
+        right_split.addWidget(self._table)
+        right_split.addWidget(self._plot)
+        right_split.setStretchFactor(0, 0)
+        right_split.setStretchFactor(1, 1)
+
+        main_split = QSplitter(Qt.Orientation.Horizontal)
+        left_w = QWidget()
+        left_l = QVBoxLayout(left_w)
+        left_l.addLayout(ctrl_col)
+        left_l.addWidget(form_scroll, 1)
+        main_split.addWidget(left_w)
+        main_split.addWidget(right_split)
+        main_split.setStretchFactor(0, 0)
+        main_split.setStretchFactor(1, 1)
+
+        layout = QVBoxLayout(self)
+        layout.addLayout(top)
+        layout.addWidget(main_split, 1)
+
+    def refresh_theme(self) -> None:
+        """Re-apply the plot colours of the current theme (redraws the distributions)."""
+        style_view(self._plot)
+        style_plot(self._plot.getPlotItem(), grid=False)
+        self._plot.showGrid(x=False, y=True, alpha=plot_colors().grid_alpha)
+        if getattr(self, "_blue_df", None) is not None:
+            self._refresh_preview()
+
+    def _on_plot_range_changed(self, *_args) -> None:
+        """Keep horizontal range fixed; only Y may change (zoom/pan)."""
+        vb = self._plot.getViewBox()
+        x0, x1 = self._X_LEFT, self._X_RIGHT
+        try:
+            xr = vb.viewRange()[0]
+        except Exception:
+            return
+        if abs(xr[0] - x0) < 1e-6 and abs(xr[1] - x1) < 1e-6:
+            return
+        vb.blockSignals(True)
+        try:
+            vb.setXRange(x0, x1, padding=0)
+        finally:
+            vb.blockSignals(False)
+
+    def _browse_session(self) -> None:
+        path = QFileDialog.getExistingDirectory(self, "Select session folder")
+        if path:
+            self._folder = path
+            self._reload_data()
+
+    def _reload_data(self) -> None:
+        if not self._folder:
+            QMessageBox.warning(self, "Session", "Select a session folder first.")
+            return
+        err = rms_features_preflight(self._folder)
+        if err:
+            QMessageBox.warning(self, "Session", err)
+            return
+        work_path = working_rms_csv(self._folder)
+        self._work_df = normalize_rms_dataframe(pd.read_csv(str(work_path)))
+        orig_path = original_rms_csv(self._folder)
+        if orig_path.is_file():
+            self._blue_df = normalize_rms_dataframe(pd.read_csv(str(orig_path)))
+        else:
+            self._blue_df = self._work_df.copy()
+        for i in range(8):
+            self._spin_gains[i].blockSignals(True)
+            self._spin_zeros[i].blockSignals(True)
+            self._spin_gains[i].setValue(1.0)
+            self._spin_zeros[i].setValue(0.0)
+            self._spin_gains[i].blockSignals(False)
+            self._spin_zeros[i].blockSignals(False)
+            self._gains[i] = 1.0
+            self._zeros[i] = 0.0
+        self._refresh_preview()
+
+    def _preview_df(self) -> pd.DataFrame | None:
+        if self._work_df is None:
+            return None
+        return _apply_gain_zero(self._work_df, self._gains, self._zeros)
+
+    def _refresh_preview(self) -> None:
+        if self._work_df is None or self._blue_df is None:
+            self._table.setRowCount(0)
+            self._plot.clear()
+            return
+        red_df = self._preview_df()
+        if red_df is None:
+            return
+
+        self._table.setRowCount(8)
+        for i, ch_name in enumerate(CHANNEL_NAMES):
+            bcol = self._blue_df[ch_name].to_numpy(dtype=float)
+            rcol = red_df[ch_name].to_numpy(dtype=float)
+            bstats = _quartile_stats(bcol)
+            rstats = _quartile_stats(rcol)
+            self._table.setItem(i, 0, QTableWidgetItem(ch_name))
+            for j in range(5):
+                self._table.setItem(i, 1 + 2 * j, QTableWidgetItem(f"{bstats[j]:.5g}"))
+                self._table.setItem(i, 2 + 2 * j, QTableWidgetItem(f"{rstats[j]:.5g}"))
+
+        idx = self._channel_combo.currentIndex()
+        if idx < 0:
+            idx = 0
+        name = CHANNEL_NAMES[idx]
+
+        bcol = self._blue_df[name].to_numpy(dtype=float)
+        rcol = red_df[name].to_numpy(dtype=float)
+
+        self._plot.clear()
+        set_title(self._plot.getPlotItem(), name)
+        n = len(bcol)
+        k = min(n, self._MAX_SCATTER)
+        if k < 1:
+            self._plot.setXRange(self._X_LEFT, self._X_RIGHT, padding=0.02)
+            return
+
+        rng = np.random.default_rng(42)
+        idx_s = rng.choice(n, size=k, replace=False)
+        vb = bcol[idx_s]
+        vr = rcol[idx_s]
+        xb = rng.uniform(-0.2, 0.2, k)
+        xr = 0.45 + rng.uniform(-0.2, 0.2, k)
+        sp_b = pg.ScatterPlotItem(
+            x=xb,
+            y=vb,
+            pen=None,
+            brush=pg.mkBrush(translucent(plot_colors().pair[0], 110)),
+            size=5,
+        )
+        sp_r = pg.ScatterPlotItem(
+            x=xr,
+            y=vr,
+            pen=None,
+            brush=pg.mkBrush(translucent(plot_colors().pair[1], 110)),
+            size=5,
+        )
+        self._plot.addItem(sp_b)
+        self._plot.addItem(sp_r)
+        vb_plot = self._plot.getViewBox()
+        vb_plot.blockSignals(True)
+        try:
+            vb_plot.setXRange(self._X_LEFT, self._X_RIGHT, padding=0.02)
+            y_all = np.concatenate([vb, vr])
+            y_all = y_all[np.isfinite(y_all)]
+            if y_all.size > 0:
+                y_min = float(np.min(y_all))
+                y_max = float(np.max(y_all))
+                pad = max((y_max - y_min) * 0.05, 1e-9)
+                vb_plot.setYRange(y_min - pad, y_max + pad, padding=0.02)
+        finally:
+            vb_plot.blockSignals(False)
+
+    def _apply_clicked(self) -> None:
+        if not self._folder or self._work_df is None:
+            QMessageBox.warning(self, "Session", "Load a session first.")
+            return
+        err = rms_features_preflight(self._folder)
+        if err:
+            QMessageBox.warning(self, "Session", err)
+            return
+        out = _apply_gain_zero(self._work_df, self._gains, self._zeros)
+        work_path = working_rms_csv(self._folder)
+        try:
+            ensure_baseline_snapshot(self._folder)
+            as_output_rms_frame(out).to_csv(work_path, index=False)
+            parts = [
+                f"{CHANNEL_NAMES[i]}:g={self._gains[i]:.4g},z={self._zeros[i]:.4g}"
+                for i in range(8)
+            ]
+            msg = "gain_adjust " + ";".join(parts)
+            if len(msg) > 500:
+                msg = msg[:497] + "..."
+            append_operation(self._folder, msg)
+        except OSError as e:
+            QMessageBox.critical(self, "Apply", str(e))
+            return
+        self._reload_data()
+        QMessageBox.information(self, "Gain", "Applied to rmsSignals.csv.")