karcytics-sdk 3.2.0__tar.gz → 3.3.0__tar.gz

{karcytics_sdk-3.2.0/src/karcytics_sdk.egg-info → karcytics_sdk-3.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: karcytics-sdk
-Version: 3.2.0
+Version: 3.3.0
 Summary: Software Development Kit and CLI for Karcytics.
 Author: Kalaimaran Balasothy
 License: # PolyForm Noncommercial License 1.0.0

{karcytics_sdk-3.2.0 → karcytics_sdk-3.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "karcytics-sdk"
-version = "3.2.0"
+version = "3.3.0"
 description = "Software Development Kit and CLI for Karcytics."
 readme = "README.md"
 license = { file = "LICENSE" }

{karcytics_sdk-3.2.0 → karcytics_sdk-3.3.0}/src/karcytics_sdk/contrib/image_utils.py

@@ -1,7 +1,7 @@
 """Image loading, format conversion, and preprocessing utilities (deprecated).
 
-Deprecated: this is western-blot band-image logic, which moved into that
-plugin. It will be removed in karcytics-sdk 4.0.
+Deprecated: this is band-image logic from the Gel & Blot plugin (formerly western-blot),
+which now owns it. It will be removed in karcytics-sdk 4.0.
 
 This module provides low-level image I/O and transformation functions
 used throughout the Karcytics analysis pipeline. All functions operate on
@@ -36,7 +36,7 @@ from skimage.util import img_as_float64
 
 warnings.warn(
     "karcytics_sdk.contrib.image_utils is deprecated and will be removed in karcytics-sdk 4.0: it is "
-    "western-blot band-image logic, which now lives in that plugin. Copy what you need into your plugin.",
+    "band-image logic that now lives in the Gel & Blot plugin (formerly western-blot). Copy what you need into your plugin.",
     DeprecationWarning,
     stacklevel=2,
 )

{karcytics_sdk-3.2.0 → karcytics_sdk-3.3.0}/src/karcytics_sdk/plugin/__init__.py

@@ -19,12 +19,16 @@ if TYPE_CHECKING:
         BioCaptionLabel,
         BioComboBox,
         BioDoubleSpinBox,
+        BioFooter,
         BioHeaderLabel,
         BioHelpButton,
         BioLineEdit,
         BioListWidget,
+        BioMenu,
+        BioProgressDialog,
         BioRunButton,
         BioScrollArea,
+        BioSectionLabel,
         BioSpinBox,
         BioSplitter,
         BioStatusLabel,
@@ -36,6 +40,7 @@ if TYPE_CHECKING:
         PrimaryButton,
         SecondaryButton,
         SubtitleLabel,
+        WorkspaceSaveButton,
         apply_component_style,
         repopulate_combo,
     )
@@ -65,6 +70,8 @@ if TYPE_CHECKING:
     from .logging import get_logger
     from .managed_task import FunctionalTask
     from .manifest import PluginManifest
+    from .params import Param
+    from .params_form import ParamsForm
     from .preferences import PreferenceManagerProtocol
     from .rendering import (
         MPL_RASTER_LOCK,
@@ -91,6 +98,7 @@ if TYPE_CHECKING:
         tutorial_manager,
     )
     from .signals import PluginSignals, move_to_gui_thread, safe_disconnect
+    from .stage_rail import StageRail, StageStatus
     from .state import PluginState
     from .tasks import TaskHandle, submit_task
     from .timing import Debouncer
@@ -153,12 +161,16 @@ _EXPORTS: dict[str, tuple[str, ...]] = {
         "BioCaptionLabel",
         "BioComboBox",
         "BioDoubleSpinBox",
+        "BioFooter",
         "BioHeaderLabel",
         "BioHelpButton",
         "BioLineEdit",
         "BioListWidget",
+        "BioMenu",
+        "BioProgressDialog",
         "BioRunButton",
         "BioScrollArea",
+        "BioSectionLabel",
         "BioSpinBox",
         "BioSplitter",
         "BioStatusLabel",
@@ -170,6 +182,7 @@ _EXPORTS: dict[str, tuple[str, ...]] = {
         "PrimaryButton",
         "SecondaryButton",
         "SubtitleLabel",
+        "WorkspaceSaveButton",
         "apply_component_style",
         "repopulate_combo",
     ),
@@ -199,6 +212,8 @@ _EXPORTS: dict[str, tuple[str, ...]] = {
     ".logging": ("get_logger",),
     ".managed_task": ("FunctionalTask",),
     ".manifest": ("PluginManifest",),
+    ".params": ("Param",),
+    ".params_form": ("ParamsForm",),
     ".preferences": ("PreferenceManagerProtocol",),
     ".rendering": (
         "MPL_RASTER_LOCK",
@@ -224,6 +239,7 @@ _EXPORTS: dict[str, tuple[str, ...]] = {
         "task_scheduler",
         "tutorial_manager",
     ),
+    ".stage_rail": ("StageRail", "StageStatus"),
     ".signals": ("PluginSignals", "move_to_gui_thread", "safe_disconnect"),
     ".state": ("PluginState",),
     ".tasks": ("TaskHandle", "submit_task"),
@@ -345,13 +361,17 @@ __all__ = [
     "AxesColors",
     "BioComboBox",
     "BioDoubleSpinBox",
+    "BioFooter",
     "BioHeaderLabel",
     "BioHelpButton",
     "BioLineEdit",
     "BioListWidget",
+    "BioMenu",
+    "BioProgressDialog",
     "BioRibbon",
     "BioRunButton",
     "BioScrollArea",
+    "BioSectionLabel",
     "BioSpinBox",
     "BioSplitter",
     "BioStatusLabel",
@@ -365,6 +385,7 @@ __all__ = [
     "StepIndicator",
     "SubtitleLabel",
     "WizardPanel",
+    "WorkspaceSaveButton",
     "WizardStep",
     "apply_component_style",
     # Dialogs
@@ -408,6 +429,10 @@ __all__ = [
     "array_to_pixmap",
     "FunctionalTask",
     "TaskHandle",
+    "Param",
+    "ParamsForm",
+    "StageRail",
+    "StageStatus",
 ]
 
 
@@ -426,5 +451,18 @@ def __getattr__(name: str) -> object:
     return value
 
 
+def _preload_exports() -> None:
+    """Import every eagerly-exported name now, as the old barrel did.
+
+    The UI daemon calls this before its stdin-reader thread starts: on
+    Windows, importing native-extension-heavy modules on the main thread
+    while that thread is blocked reading stdin can deadlock (see
+    ``ui_daemon_runtime.run``). ``LayeredMatplotlibCanvas`` stays lazy, as it
+    always was.
+    """
+    for name in (*(n for names in _EXPORTS.values() for n in names), *_ALIASES):
+        __getattr__(name)
+
+
 def __dir__() -> list[str]:
     return sorted(set(globals()) | set(_LOCATIONS))

{karcytics_sdk-3.2.0 → karcytics_sdk-3.3.0}/src/karcytics_sdk/plugin/analysis.py

@@ -7,6 +7,7 @@ the UI.
 
 import logging
 from abc import ABC, abstractmethod
+from collections.abc import Callable
 from typing import Any
 
 from PySide6.QtCore import QObject, QRunnable, Signal
@@ -177,14 +178,17 @@ class AnalysisRunnable(QRunnable):
     standard QThreadPool management system.
     """
 
-    def __init__(self, worker: AnalysisWorker):
+    def __init__(self, worker: AnalysisWorker, on_done: Callable[[], None] | None = None):
         """Initialize the runnable wrapper with a target worker.
 
         Args:
             worker: The background AnalysisWorker controller containing the job.
+            on_done: Called on the pool thread once this runnable has let go of
+                the worker, so its owner can release it on its own thread.
         """
         super().__init__()
         self.worker: AnalysisWorker | None = worker
+        self._on_done = on_done
         # QThreadPool will take ownership and delete this runnable after run()
         self.setAutoDelete(True)
 
@@ -204,4 +208,10 @@ class AnalysisRunnable(QRunnable):
             # Fallback for truly catastrophic failures inside the worker itself
             logger.exception(f"Critical failure in background runnable: {e}")
         finally:
+            # Let go first: whoever releases the worker after on_done then
+            # holds the last reference, so it is never destroyed here, on the
+            # pool thread, while the GUI thread may still be delivering its
+            # signals.
             self.worker = None
+            if self._on_done is not None:
+                self._on_done()

{karcytics_sdk-3.2.0 → karcytics_sdk-3.3.0}/src/karcytics_sdk/plugin/components.py

@@ -540,6 +540,17 @@ class BioCaptionLabel(QLabel):
         self.setStyleSheet(f"font-size: {size}px; color: {Colors.FG_SECONDARY};")
 
 
+class BioSectionLabel(QLabel):
+    """A small bold heading over a group of controls, e.g. in a tab's sidebar."""
+
+    def __init__(self, text: str, parent=None):
+        super().__init__(text, parent)
+        _connect_theme_signal(self._apply_theme_styles)
+
+    def _apply_theme_styles(self) -> None:
+        self.setStyleSheet(f"color: {Colors.FG_SECONDARY}; font-weight: bold; font-size: 11px;")
+
+
 class BioStatusLabel(QLabel):
     """Standardized italicized status text."""
 
@@ -637,11 +648,14 @@ class BioComboBox(QComboBox):
         """)
 
 
+_KEEP_SELECTION = object()
+
+
 def repopulate_combo(
     combo: QComboBox,
     items: Sequence[tuple[str, Any]],
     *,
-    restore_data: Any = None,
+    restore_data: Any = _KEEP_SELECTION,
 ) -> None:
     """Rebuild a combo box's items and restore a selection, without spurious signals.
 
@@ -658,8 +672,9 @@ def repopulate_combo(
         items: Ordered (label, data) pairs for every item to show.
         restore_data: The `data` value to reselect if still present in
             `items` after rebuilding — typically the combo's own
-            `currentData()` captured before calling this. `None` leaves
-            the current index wherever `clear()`/`addItem()` land it.
+            `currentData()` captured before calling this. `None` is a value
+            like any other (an "All events" item often carries it). Leave it
+            out to keep the index wherever `clear()`/`addItem()` land it.
 
     Returns:
         None.
@@ -667,7 +682,8 @@ def repopulate_combo(
     items = list(items)
     current = [(combo.itemText(i), combo.itemData(i)) for i in range(combo.count())]
     items_unchanged = current == items
-    selection_already_right = restore_data is None or combo.currentData() == restore_data
+    keep = restore_data is _KEEP_SELECTION
+    selection_already_right = keep or combo.currentData() == restore_data
 
     if items_unchanged and selection_already_right:
         return
@@ -677,7 +693,7 @@ def repopulate_combo(
         combo.clear()
         for label, data in items:
             combo.addItem(label, data)
-    if restore_data is not None:
+    if not keep:
         idx = combo.findData(restore_data)
         if idx >= 0:
             combo.setCurrentIndex(idx)

{karcytics_sdk-3.2.0 → karcytics_sdk-3.3.0}/src/karcytics_sdk/plugin/image_view.py

@@ -1,7 +1,7 @@
 """A zoomable, pannable image viewer for image-analysis plugins.
 
 `ImageView` is the part every image plugin's canvas had re-implemented
-(western-blot's `ImageCanvas`, cytometrics' `MultiChannelCanvas`): showing
+(gel-blot's `ImageCanvas`, cytometrics' `MultiChannelCanvas`): showing
 an image, wheel zoom around the cursor with limits, panning, fit-to-view, an
 empty state with a load button and drag-and-drop, a calibration line, a
 scale bar, and named overlay layers. Plugins subclass it and add their own

karcytics_sdk-3.3.0/src/karcytics_sdk/plugin/params.py

@@ -0,0 +1,58 @@
+"""User-settable parameters, declared once and turned into controls by ``ParamsForm``.
+
+An algorithm (a segmenter, a background method, a lane finder…) declares
+what it can be told as a list of :class:`Param`. The form builds the
+controls from that list, so adding a parameter never means editing UI code.
+This module imports no Qt, so analysis code can declare parameters freely.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+#: The kinds a ``Param`` can be. ``options`` is a pick-list whose entries
+#: arrive at runtime (channel names, image names…) through
+#: ``ParamsForm.set_options(param.source, names)``.
+KINDS = ("float", "int", "bool", "choice", "options")
+
+
+@dataclass(frozen=True)
+class Param:
+    """One parameter: enough to build its control, label it and explain it.
+
+    ``unit`` is shown after the value. A form can map a unit to another
+    display (µm instead of px, say) with ``ParamsForm.set_unit_display``;
+    the algorithm always receives the value in the unit it declared.
+    ``advanced`` parameters sit behind the form's "Advanced settings" toggle.
+    ``enabled_by`` names a ``bool`` parameter that switches this one on.
+    """
+
+    key: str
+    label: str
+    kind: str
+    default: Any = None
+    minimum: float | None = None
+    maximum: float | None = None
+    step: float | None = None
+    decimals: int = 1
+    unit: str = ""
+    choices: tuple[tuple[str, Any], ...] = ()
+    source: str = ""
+    advanced: bool = False
+    help: str = ""
+    special_value_text: str = ""
+    enabled_by: str = ""
+
+    def __post_init__(self) -> None:
+        if self.kind not in KINDS:
+            raise ValueError(f"Param {self.key!r}: kind must be one of {KINDS}, not {self.kind!r}")
+        if self.kind == "options" and not self.source:
+            raise ValueError(f"Param {self.key!r}: an 'options' parameter needs a source")
+        if self.kind == "choice" and not self.choices:
+            raise ValueError(f"Param {self.key!r}: a 'choice' parameter needs choices")
+
+
+def defaults(params: list[Param]) -> dict[str, Any]:
+    """Every parameter's default, keyed like ``ParamsForm.values()``."""
+    return {p.key: p.default for p in params}

karcytics_sdk-3.3.0/src/karcytics_sdk/plugin/params_form.py

@@ -0,0 +1,319 @@
+"""Controls generated from a list of :class:`~karcytics_sdk.plugin.params.Param`.
+
+Basic parameters are shown; advanced ones sit behind an "Advanced settings"
+toggle. Values the user typed are remembered by key, so swapping one
+algorithm's parameters for another's keeps the shared ones. A form can
+show units differently from how the algorithm takes them (µm on screen,
+pixels to the algorithm) through ``set_unit_display``, and can keep a
+user's preferred values as "my defaults" in any preference store.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any
+
+from PySide6.QtCore import Qt, Signal
+from PySide6.QtWidgets import QCheckBox, QGridLayout, QLabel, QVBoxLayout, QWidget
+
+from .components import (
+    BioComboBox,
+    BioDoubleSpinBox,
+    BioHelpButton,
+    BioToggleButton,
+    _connect_theme_signal,
+    _get_theme_tokens,
+)
+from .params import Param
+from .preferences import PreferenceManagerProtocol
+
+_ADVANCED_CLOSED = "Advanced settings ▸"
+_ADVANCED_OPEN = "Advanced settings ▾"
+
+#: Maps a parameter's declared unit to (suffix shown, display units per declared unit).
+UnitDisplay = Callable[[str], tuple[str, float]]
+
+
+def _unit_as_declared(unit: str) -> tuple[str, float]:
+    return unit, 1.0
+
+
+class ParamsForm(QWidget):
+    """A form for a list of parameters; ``changed`` fires on every edit."""
+
+    changed = Signal()
+
+    def __init__(self, parent: QWidget | None = None) -> None:
+        super().__init__(parent)
+        self._params: list[Param] = []
+        self._widgets: dict[str, QWidget] = {}
+        self._labels: dict[str, QLabel] = {}
+        self._helps: dict[str, BioHelpButton] = {}
+        self._memory: dict[str, Any] = {}
+        # The default of the parameter each remembered value was set on: a value only
+        # carries over to a parameter with the same default (another algorithm's "Max
+        # Area" of 1e6 is not this one's 5000). Values set explicitly carry over anywhere.
+        self._memory_defaults: dict[str, Any] = {}
+        self._hidden: set[str] = set()
+        self._options: dict[str, list[str]] = {}
+        self._unit_display: UnitDisplay = _unit_as_declared
+
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+        self._basic = QWidget()
+        self._basic_grid = _grid(self._basic)
+        layout.addWidget(self._basic)
+
+        self.btn_advanced = BioToggleButton(_ADVANCED_CLOSED)
+        self.btn_advanced.toggled.connect(self._on_advanced_toggled)
+        layout.addWidget(self.btn_advanced)
+        self._advanced = QWidget()
+        self._advanced_grid = _grid(self._advanced)
+        self._advanced.setVisible(False)
+        layout.addWidget(self._advanced)
+        self.btn_advanced.setVisible(False)
+
+        _connect_theme_signal(self.apply_theme)
+
+    # ── Building ─────────────────────────────────────────────────────────────
+
+    def set_params(self, params: list[Param]) -> None:
+        """Rebuild the controls for `params`, keeping values the user already set."""
+        self._memory.update(self.display_values())
+        self._memory_defaults.update({p.key: p.default for p in self._params})
+        for w in [*self._widgets.values(), *self._labels.values(), *self._helps.values()]:
+            w.setParent(None)  # type: ignore[call-overload]  # PySide6 stub omits Optional
+            w.deleteLater()
+        self._widgets.clear()
+        self._labels.clear()
+        self._helps.clear()
+        self._params = list(params)
+
+        rows = {False: 0, True: 0}
+        self.setVisible(bool(self._params))
+        for p in self._params:
+            grid = self._advanced_grid if p.advanced else self._basic_grid
+            widget = self._make_widget(p)
+            self._widgets[p.key] = widget
+            r = rows[p.advanced]
+            if p.kind == "bool":
+                grid.addWidget(widget, r, 1)
+            else:
+                label = QLabel(f"{p.label}:")
+                label.setAlignment(Qt.AlignmentFlag.AlignRight | Qt.AlignmentFlag.AlignVCenter)
+                label.setToolTip(p.help)
+                self._labels[p.key] = label
+                grid.addWidget(label, r, 0)
+                grid.addWidget(widget, r, 1)
+            if p.help:
+                button = BioHelpButton()
+                button.setHelpText(p.help, p.label)
+                self._helps[p.key] = button
+                grid.addWidget(button, r, 2)
+            rows[p.advanced] = r + 1
+
+        self._apply_hidden()
+        has_advanced = rows[True] > 0
+        self.btn_advanced.setVisible(has_advanced)
+        self._advanced.setVisible(has_advanced and self.btn_advanced.isChecked())
+        self._apply_units()
+        self._apply_dependencies()
+        self.apply_theme()
+
+    def set_options(self, source: str, names: list[str]) -> None:
+        """Offer `names` in every ``options`` picker fed by `source`, keeping each choice that survives."""
+        self._options[source] = list(names)
+        for p in self._params:
+            if p.kind == "options" and p.source == source:
+                combo = self._widgets[p.key]
+                assert isinstance(combo, BioComboBox)
+                current = combo.currentText() or self._memory.get(p.key, "")
+                combo.blockSignals(True)
+                combo.clear()
+                combo.addItems(names)
+                if current in names:
+                    combo.setCurrentText(current)
+                combo.blockSignals(False)
+
+    def set_unit_display(self, unit_display: UnitDisplay) -> None:
+        """Show units through `unit_display`. The numbers the user typed are kept."""
+        self._unit_display = unit_display
+        self._apply_units()
+
+    def set_hidden(self, keys: set[str]) -> None:
+        """Hide the controls of `keys`; their values are still read and written."""
+        self._hidden = set(keys)
+        self._apply_hidden()
+
+    # ── Values ───────────────────────────────────────────────────────────────
+
+    def display_values(self) -> dict[str, Any]:
+        """Every control's value as shown (in the displayed unit)."""
+        return {p.key: self._read(p) for p in self._params}
+
+    def set_display_values(self, values: dict[str, Any]) -> None:
+        """Set controls from values in the displayed unit; unknown keys are remembered for later."""
+        self._memory.update(values)
+        for key in values:
+            self._memory_defaults.pop(key, None)
+        for p in self._params:
+            if p.key in values:
+                self._write(p, values[p.key])
+        self._apply_dependencies()
+
+    def values(self) -> dict[str, Any]:
+        """The algorithm's input: every value converted back to its declared unit."""
+        out: dict[str, Any] = {}
+        for p in self._params:
+            value = self._read(p)
+            if p.kind in ("float", "int") and p.unit:
+                value = value / self._unit_display(p.unit)[1]
+            if p.kind == "int":
+                value = int(round(value))
+            out[p.key] = value
+        return out
+
+    def reset_to_defaults(self) -> None:
+        """Put every control back to its parameter's declared default."""
+        self.set_display_values({p.key: p.default for p in self._params})
+        self.changed.emit()
+
+    def save_defaults(self, store: PreferenceManagerProtocol, namespace: str) -> None:
+        """Keep the current values as this user's defaults for `namespace` in `store`."""
+        saved = dict(store.get(namespace, {}) or {})
+        saved.update(self.display_values())
+        store.set(namespace, saved)
+        store.save()
+
+    def load_defaults(self, store: PreferenceManagerProtocol, namespace: str) -> bool:
+        """Apply this user's saved defaults for `namespace`, if any. Returns whether there were any."""
+        saved = store.get(namespace, {}) or {}
+        if not saved:
+            return False
+        self.set_display_values(dict(saved))
+        return True
+
+    # ── Access for tests and hosts ───────────────────────────────────────────
+
+    def widget(self, key: str) -> QWidget | None:
+        return self._widgets.get(key)
+
+    def label(self, key: str) -> QLabel | None:
+        return self._labels.get(key)
+
+    def apply_theme(self) -> None:
+        """Re-colour the plain Qt widgets (the Bio* ones restyle themselves)."""
+        colors, _, _ = _get_theme_tokens()
+        for p in self._params:
+            if p.kind == "bool":
+                self._widgets[p.key].setStyleSheet(f"color: {colors.FG_PRIMARY};")
+        for label in self._labels.values():
+            label.setStyleSheet(f"color: {colors.FG_PRIMARY};")
+
+    # ── Internals ────────────────────────────────────────────────────────────
+
+    def _remembered(self, p: Param) -> Any:
+        if p.key in self._memory and self._memory_defaults.get(p.key, p.default) == p.default:
+            return self._memory[p.key]
+        return p.default
+
+    def _make_widget(self, p: Param) -> QWidget:
+        remembered = self._remembered(p)
+        if p.kind == "bool":
+            box = QCheckBox(p.label)
+            box.setChecked(bool(remembered))
+            box.setToolTip(p.help)
+            box.toggled.connect(self._on_changed)
+            return box
+        if p.kind in ("options", "choice"):
+            combo = BioComboBox()
+            combo.setMinimumWidth(180)
+            combo.view().setMinimumWidth(300)
+            combo.setToolTip(p.help)
+            if p.kind == "options":
+                names = self._options.get(p.source, [])
+                combo.addItems(names)
+                if remembered in names:
+                    combo.setCurrentText(remembered)
+            else:
+                for text, data in p.choices:
+                    combo.addItem(text, data)
+                combo.setCurrentIndex(max(combo.findData(remembered), 0))
+            combo.currentIndexChanged.connect(self._on_changed)
+            return combo
+        spin = BioDoubleSpinBox()
+        spin.setDecimals(0 if p.kind == "int" else p.decimals)
+        spin.setRange(
+            p.minimum if p.minimum is not None else -1e9,
+            p.maximum if p.maximum is not None else 1e9,
+        )
+        if p.step is not None:
+            spin.setSingleStep(p.step)
+        if p.special_value_text:
+            spin.setSpecialValueText(p.special_value_text)
+        spin.setValue(float(remembered or 0))
+        spin.setToolTip(p.help)
+        spin.valueChanged.connect(self._on_changed)
+        return spin
+
+    def _read(self, p: Param) -> Any:
+        w = self._widgets[p.key]
+        if isinstance(w, QCheckBox):
+            return w.isChecked()
+        if isinstance(w, BioComboBox):
+            return w.currentText() if p.kind == "options" else w.currentData()
+        assert isinstance(w, BioDoubleSpinBox)
+        return int(w.value()) if p.kind == "int" else w.value()
+
+    def _write(self, p: Param, value: Any) -> None:
+        w = self._widgets[p.key]
+        w.blockSignals(True)
+        if isinstance(w, QCheckBox):
+            w.setChecked(bool(value))
+        elif isinstance(w, BioComboBox):
+            if p.kind == "options":
+                w.setCurrentText(str(value))
+            else:
+                w.setCurrentIndex(max(w.findData(value), 0))
+        elif isinstance(w, BioDoubleSpinBox):
+            w.setValue(float(value or 0))
+        w.blockSignals(False)
+
+    def _apply_hidden(self) -> None:
+        for key, widget in self._widgets.items():
+            widget.setVisible(key not in self._hidden)
+            for extra in (self._labels, self._helps):
+                if key in extra:
+                    extra[key].setVisible(key not in self._hidden)
+
+    def _apply_units(self) -> None:
+        for p in self._params:
+            w = self._widgets[p.key]
+            if isinstance(w, BioDoubleSpinBox) and p.unit:
+                w.setSuffix(f" {self._unit_display(p.unit)[0]}")
+
+    def _apply_dependencies(self) -> None:
+        for p in self._params:
+            if not p.enabled_by or p.enabled_by not in self._widgets:
+                continue
+            switch = self._widgets[p.enabled_by]
+            on = isinstance(switch, QCheckBox) and switch.isChecked()
+            self._widgets[p.key].setEnabled(on)
+            if p.key in self._labels:
+                self._labels[p.key].setEnabled(on)
+
+    def _on_changed(self, *_args: object) -> None:
+        self._apply_dependencies()
+        self.changed.emit()
+
+    def _on_advanced_toggled(self, checked: bool) -> None:
+        self.btn_advanced.setText(_ADVANCED_OPEN if checked else _ADVANCED_CLOSED)
+        self._advanced.setVisible(checked)
+
+
+def _grid(parent: QWidget) -> QGridLayout:
+    grid = QGridLayout(parent)
+    grid.setContentsMargins(0, 0, 0, 0)
+    grid.setSpacing(8)
+    grid.setColumnStretch(1, 1)
+    return grid