TwoPy 0.1.4__tar.gz → 0.1.5__tar.gz

{twopy-0.1.4 → twopy-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: twopy
-Version: 0.1.4
+Version: 0.1.5
 Summary: Two-photon imaging analysis tool with a napari interface.
 Author-email: Gustavo Madeira Santana <fromweb1@gumadeiras.com>
 License-Expression: MIT
@@ -66,9 +66,8 @@ Basic GUI flow:
 
 1. Choose a recording.
 2. Draw or edit ROIs in the `rois` Labels layer.
-3. Click Save ROIs.
-4. Update response plots from the current ROIs.
-5. Save analysis outputs.
+3. Update response plots from the current ROIs.
+4. Click Save ROIs + analysis when the plots look right.
 
 When a source recording has not been converted yet, twopy converts it first. Converted data includes the aligned movie, mean image, stimulus tables, photodiode signals, and recording metadata.
 

{twopy-0.1.4 → twopy-0.1.5}/README.md

@@ -46,9 +46,8 @@ Basic GUI flow:
 
 1. Choose a recording.
 2. Draw or edit ROIs in the `rois` Labels layer.
-3. Click Save ROIs.
-4. Update response plots from the current ROIs.
-5. Save analysis outputs.
+3. Update response plots from the current ROIs.
+4. Click Save ROIs + analysis when the plots look right.
 
 When a source recording has not been converted yet, twopy converts it first. Converted data includes the aligned movie, mean image, stimulus tables, photodiode signals, and recording metadata.
 

{twopy-0.1.4 → twopy-0.1.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "twopy"
-version = "0.1.4"
+version = "0.1.5"
 description = "Two-photon imaging analysis tool with a napari interface."
 readme = "README.md"
 requires-python = ">=3.13,<3.14"

{twopy-0.1.4 → twopy-0.1.5}/src/twopy/__init__.py

@@ -57,8 +57,8 @@ from twopy.api import find_recordings
 from twopy.conversion import convert_recording_to_twopy, load_source_conversion_inputs
 from twopy.converted import load_converted_recording, recording_frame_rate_hz
 from twopy.napari import (
-    NapariControlDocks,
     NapariRecordingView,
+    NapariSidebarWidgets,
     add_twopy_magicgui_controls,
     launch_napari,
     open_recording_in_napari,
@@ -149,8 +149,8 @@ __all__ = [
     "make_roi_set",
     "map_stimulus_epochs_to_frame_windows",
     "map_stimulus_specific_column",
-    "NapariControlDocks",
     "NapariRecordingView",
+    "NapariSidebarWidgets",
     "open_recording_in_napari",
     "pair_photodiode_events_to_imaging_frames",
     "PhotodiodeAlignment",

{twopy-0.1.4 → twopy-0.1.5}/src/twopy/napari/__init__.py

@@ -9,7 +9,7 @@ database, ROI, and analysis modules stay independent so a future napari plugin
 can wrap these helpers instead of owning scientific logic.
 """
 
-from twopy.napari.controls import NapariControlDocks, add_twopy_magicgui_controls
+from twopy.napari.controls import NapariSidebarWidgets, add_twopy_magicgui_controls
 from twopy.napari.launcher import launch_napari, main
 from twopy.napari.roi import roi_label_image_from_layer, save_napari_label_rois
 from twopy.napari.types import NapariRecordingView
@@ -17,7 +17,7 @@ from twopy.napari.viewer import open_recording_in_napari
 
 __all__ = [
     "NapariRecordingView",
-    "NapariControlDocks",
+    "NapariSidebarWidgets",
     "add_twopy_magicgui_controls",
     "launch_napari",
     "main",

{twopy-0.1.4 → twopy-0.1.5}/src/twopy/napari/controls.py

@@ -1,11 +1,11 @@
 """Magicgui controls for the twopy napari adapter.
 
 Inputs: napari viewer, current ROI Labels layer, and paths chosen by the user.
-Outputs: small dock widgets for loading converted recordings and saving ROI
-masks.
+Outputs: one tabbed right-sidebar dock for loading converted recordings,
+tracking loaded recordings, and controlling response plots.
 
-The control panel owns GUI callbacks only. Loading recordings and saving ROIs
-still go through the same typed helpers used by scripts.
+The controls own GUI callbacks only. Loading recordings still goes through the
+same typed helpers used by scripts.
 """
 
 from collections.abc import Callable
@@ -13,27 +13,18 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Protocol, cast
 
-import numpy as np
 from magicgui.widgets import FileEdit
+from qtpy.QtCore import Qt
+from qtpy.QtWidgets import QFormLayout, QLabel, QSizePolicy, QVBoxLayout, QWidget
 
 from twopy.converted import RecordingData
 from twopy.napari.constants import DEFAULT_PATH_TEXT
-from twopy.napari.layout import (
-    place_loaded_recordings_dock_after_load,
-    place_save_rois_dock_before_layer_list,
-)
 from twopy.napari.loading import resolve_or_convert_recording
-from twopy.napari.movie import resolve_movie_frame_range
 from twopy.napari.paths import (
     PathInput,
     is_default_path,
-    resolve_widget_output_path,
 )
 from twopy.napari.protocols import NapariViewer
-from twopy.napari.roi import (
-    roi_label_image_from_layer_for_recording,
-    save_napari_label_rois,
-)
 from twopy.napari.session import (
     LoadedNapariRecording,
     LoadedRecordingsPanel,
@@ -41,48 +32,33 @@ from twopy.napari.session import (
     render_loaded_recordings_panel,
     select_loaded_recording,
     unload_loaded_recording,
-    update_selected_roi_save_file,
+)
+from twopy.napari.sidebar import (
+    TWOPY_SIDEBAR_MINIMUM_WIDTH,
+    create_twopy_sidebar_widget,
 )
 from twopy.napari.state import (
     read_last_recording_folder,
     recording_folder_for_state,
     write_last_recording_folder,
 )
-from twopy.napari.text import counted_noun
-
-__all__ = ["NapariControlDocks", "add_twopy_magicgui_controls"]
 
-
-class _RoiSavePathReceiver(Protocol):
-    """Small protocol for widgets that mirror the selected ROI save path."""
-
-    def set_roi_save_file(self, roi_save_file: Path | None) -> None:
-        """Store the ROI HDF5 path for the selected recording.
-
-        Args:
-            roi_save_file: ROI output path, or ``None`` when no recording is
-                selected.
-
-        Returns:
-            None.
-        """
-        ...
+__all__ = ["NapariSidebarWidgets", "add_twopy_magicgui_controls"]
 
 
 @dataclass
-class NapariControlDocks:
-    """Dock widgets created for twopy napari controls.
+class NapariSidebarWidgets:
+    """Widgets created for the twopy napari right sidebar.
 
     Inputs: Qt widgets and napari dock objects.
     Outputs: grouped references for scripts and tests.
     """
 
     load_widget: object
-    load_dock_widget: object
     loaded_recordings_widget: object
-    loaded_recordings_dock_widget: object
-    save_rois_widget: object
-    save_rois_dock_widget: object
+    response_options_widget: object | None
+    sidebar_widget: object
+    sidebar_dock_widget: object
 
 
 @dataclass
@@ -111,6 +87,17 @@ class NapariControlState:
     replace_selected_on_next_load: bool = False
 
 
+class _LoadRecordingGui(Protocol):
+    """Small shape of the magicgui recording-load callable.
+
+    Inputs: magicgui function widget created in ``_make_twopy_load_widget``.
+    Outputs: access to the child controls that need compact Qt placement.
+    """
+
+    recording_folder: object
+    roi_file_to_load: object
+
+
 def add_twopy_magicgui_controls(
     viewer: NapariViewer,
     *,
@@ -118,12 +105,13 @@ def add_twopy_magicgui_controls(
     roi_save_file: Path,
     recording: RecordingData | None = None,
     response_plot_widget: object | None = None,
+    response_options_widget: object | None = None,
     mean_image_layer: object | None = None,
     movie_layer: object | None = None,
     dock_name: str = "twopy",
     dock_area: str = "right",
-) -> NapariControlDocks:
-    """Add the first twopy magicgui control panel to a napari viewer.
+) -> NapariSidebarWidgets:
+    """Add the twopy right sidebar to a napari viewer.
 
     Args:
         viewer: Napari viewer that should receive the dock widget.
@@ -134,6 +122,8 @@ def add_twopy_magicgui_controls(
         recording: Optional loaded recording used to populate GUI defaults.
         response_plot_widget: Optional response plotting widget to refresh
             after a new recording is loaded.
+        response_options_widget: Optional response-options tabs to place in the
+            same right sidebar as the Load tab.
         mean_image_layer: Optional mean-image layer for an already loaded
             startup recording.
         movie_layer: Optional movie layer for an already loaded startup
@@ -142,11 +132,12 @@ def add_twopy_magicgui_controls(
         dock_area: Napari dock area.
 
     Returns:
-        Created load and save-ROI widgets plus their napari dock widgets.
+        Created load, loaded-recordings, and sidebar widgets plus the napari
+        dock widget that contains them.
 
-    The panel is intentionally small. It loads converted recordings and saves
-    the current Labels layer through the same helpers used by scripts, so a
-    future plugin can wrap this without changing ROI semantics.
+    The sidebar keeps twopy's right-side controls in one tabbed dock. The loader
+    itself stays small and uses the same helpers as scripts, so a future plugin
+    can wrap this without changing recording-load semantics.
     """
     state = NapariControlState(
         viewer=viewer,
@@ -168,69 +159,46 @@ def add_twopy_magicgui_controls(
         )
         state.selected_recording_index = 0
     load_widget = _make_twopy_load_widget(state)
-    load_dock_widget = viewer.window.add_dock_widget(
-        load_widget,
-        name=dock_name,
-        area=dock_area,
-    )
     loaded_recordings_widget = _make_loaded_recordings_widget(state)
-    loaded_recordings_dock_widget = viewer.window.add_dock_widget(
-        loaded_recordings_widget,
-        name="twopy loaded recordings",
-        area=dock_area,
-    )
-    place_loaded_recordings_dock_after_load(
-        viewer,
-        load_dock_widget,
-        loaded_recordings_dock_widget,
+    sidebar_widget = create_twopy_sidebar_widget(
+        load_widget=load_widget,
+        loaded_recordings_widget=loaded_recordings_widget,
+        response_options_widget=response_options_widget,
     )
-    save_rois_widget = _make_twopy_save_rois_widget(state)
-    save_rois_dock_widget = viewer.window.add_dock_widget(
-        save_rois_widget,
-        name="twopy save ROIs",
-        area="left",
+    sidebar_dock_widget = viewer.window.add_dock_widget(
+        sidebar_widget,
+        name=dock_name,
+        area=dock_area,
     )
-    place_save_rois_dock_before_layer_list(viewer, save_rois_dock_widget)
-    return NapariControlDocks(
+    if isinstance(sidebar_dock_widget, QWidget):
+        sidebar_dock_widget.setMinimumWidth(TWOPY_SIDEBAR_MINIMUM_WIDTH)
+    return NapariSidebarWidgets(
         load_widget=load_widget,
-        load_dock_widget=load_dock_widget,
         loaded_recordings_widget=loaded_recordings_widget,
-        loaded_recordings_dock_widget=loaded_recordings_dock_widget,
-        save_rois_widget=save_rois_widget,
-        save_rois_dock_widget=save_rois_dock_widget,
+        response_options_widget=response_options_widget,
+        sidebar_widget=sidebar_widget,
+        sidebar_dock_widget=sidebar_dock_widget,
     )
 
 
 def _make_twopy_load_widget(state: NapariControlState) -> object:
-    """Create the right-side magicgui widget for loading recordings.
+    """Create the right-side widget for loading recordings.
 
     Args:
         state: Mutable napari control state.
 
     Returns:
-        magicgui container with recording-load controls.
+        Qt widget with compact recording-load controls.
     """
     from magicgui import magicgui
-    from magicgui.widgets import Container, Label
-
-    default_movie_end_frame = _default_movie_end_frame(state.recording)
 
     @magicgui(
         call_button=False,
         layout="vertical",
-        movie_frame_range={
-            "widget_type": "RangeSlider",
-            "min": 0,
-            "max": max(default_movie_end_frame, 0),
-            "step": 1,
-            "tracking": False,
-        },
     )
     def load_recording(
         recording_folder: Path = Path(DEFAULT_PATH_TEXT),
         roi_file_to_load: Path = Path(DEFAULT_PATH_TEXT),
-        movie_frame_range: tuple[int, int] = (0, default_movie_end_frame),
-        load_movie: bool = True,
     ) -> str:
         """Load a recording into the current napari viewer.
 
@@ -240,11 +208,6 @@ def _make_twopy_load_widget(state: NapariControlState) -> object:
                 first when twopy output does not exist yet.
             roi_file_to_load: Optional existing ROI HDF5 file. ``default`` uses
                 ``rois.h5`` in the selected recording folder when it exists.
-            movie_frame_range: First and last movie frames to load. When the
-                empty-launch widget still shows ``(0, 0)``, twopy resolves it
-                to the recording's full frame range after the folder is
-                selected.
-            load_movie: Whether to load movie frames.
 
         Returns:
             Human-readable status for the dock widget.
@@ -266,23 +229,6 @@ def _make_twopy_load_widget(state: NapariControlState) -> object:
                 if is_default_path(roi_file_to_load)
                 else _resolve_optional_roi_path(roi_file_to_load)
             )
-            loaded_recording = _load_recording_for_defaults(
-                recording_data_path=paths.recording_data_path,
-                movie_path=paths.movie_path,
-            )
-            movie_range = None
-            if load_movie:
-                start_frame, end_frame = _widget_movie_frame_range_for_load(
-                    movie_frame_range,
-                    frame_count=loaded_recording.movie.shape[0],
-                    preserve_current_range=replace_selected,
-                )
-                movie_range = resolve_movie_frame_range(
-                    start_frame=start_frame,
-                    end_frame=end_frame,
-                    frame_count=loaded_recording.movie.shape[0],
-                    zero_end_means_last=True,
-                )
 
             # Import here to avoid a top-level cycle: viewer creates controls,
             # while controls can load recordings into that same viewer.
@@ -294,7 +240,7 @@ def _make_twopy_load_widget(state: NapariControlState) -> object:
                 roi_set=roi_path,
                 roi_save_file=paths.roi_save_file,
                 movie_path=paths.movie_path,
-                movie_frame_range=movie_range,
+                movie_frame_range=(0, None),
                 add_controls=False,
             )
             record_loaded_view(
@@ -309,9 +255,6 @@ def _make_twopy_load_widget(state: NapariControlState) -> object:
                     paths.recording_data_path,
                 ),
             )
-            frame_end = _default_movie_end_frame(view.recording)
-            load_recording.movie_frame_range.max = frame_end
-            load_recording.movie_frame_range.value = movie_range or (0, frame_end)
             _set_recording_picker_display_path(
                 cast(FileEdit, load_recording.recording_folder),
                 state,
@@ -328,10 +271,10 @@ def _make_twopy_load_widget(state: NapariControlState) -> object:
     load_recording.recording_folder.mode = "d"
     load_recording.roi_file_to_load.mode = "r"
 
-    load_recording.recording_folder.label = "recording folder or file"
-    load_recording.roi_file_to_load.label = "ROI file to load"
-    load_recording.movie_frame_range.label = "movie frames"
-    load_recording.load_movie.label = "load movie"
+    load_recording.recording_folder.label = "Recording"
+    load_recording.roi_file_to_load.label = "ROI file"
+    cast(FileEdit, load_recording.recording_folder).choose_btn.text = "Browse"
+    cast(FileEdit, load_recording.roi_file_to_load).choose_btn.text = "Browse"
     _configure_recording_folder_picker(
         cast(FileEdit, load_recording.recording_folder),
         state,
@@ -354,8 +297,8 @@ def _make_twopy_load_widget(state: NapariControlState) -> object:
             return
         load_recording()
 
-    def reload_after_option_change(_value: object) -> None:
-        """Reload the current recording after a non-path option changes.
+    def reload_after_roi_change(_value: object) -> None:
+        """Reload the current recording after the ROI file changes.
 
         Args:
             _value: Ignored widget signal value.
@@ -363,9 +306,8 @@ def _make_twopy_load_widget(state: NapariControlState) -> object:
         Returns:
             None.
 
-        Secondary controls such as the movie-frame slider should reuse the
-        resolved recording path stored in state. The visible picker text may be
-        shortened for display and is not always a real filesystem path.
+        The visible picker text may be shortened for display and is not always a
+        real filesystem path, so reloads reuse the stored recording path.
         """
         if state.is_loading or not _has_recording_to_load(
             load_recording.recording_folder.value,
@@ -381,18 +323,75 @@ def _make_twopy_load_widget(state: NapariControlState) -> object:
         )
 
     load_recording.recording_folder.changed.connect(load_after_selection)
-    load_recording.roi_file_to_load.changed.connect(reload_after_option_change)
-    load_recording.movie_frame_range.changed.connect(reload_after_option_change)
-    load_recording.load_movie.changed.connect(reload_after_option_change)
-
-    return Container(
-        widgets=[
-            Label(value="Load Recording"),
-            load_recording,
-        ],
-        layout="vertical",
-        labels=False,
-    )
+    load_recording.roi_file_to_load.changed.connect(reload_after_roi_change)
+
+    return LoadRecordingPanel(load_recording=load_recording)
+
+
+class LoadRecordingPanel(QWidget):
+    """Compact Qt panel that owns the recording-load controls.
+
+    Args:
+        load_recording: Magicgui callable widget whose child controls and
+            callbacks perform recording loading.
+
+    Outputs:
+        QWidget with a tight form layout for the Load tab.
+
+    The magicgui callable still owns validation and callback wiring. This panel
+    only arranges the existing controls with shorter labels so the path fields
+    and frame slider have enough horizontal room.
+    """
+
+    load_recording: object
+
+    def __init__(self, *, load_recording: object) -> None:
+        """Create a compact Load Recording panel.
+
+        Args:
+            load_recording: Magicgui callable widget built by
+                ``_make_twopy_load_widget``.
+
+        Returns:
+            None.
+        """
+        super().__init__()
+        self.load_recording = load_recording
+
+        layout = QVBoxLayout()
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(8)
+        title = QLabel("Load Recording")
+        title.setSizePolicy(QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Fixed)
+        layout.addWidget(title)
+
+        recording_gui = cast(_LoadRecordingGui, load_recording)
+        form = QFormLayout()
+        form.setContentsMargins(0, 0, 0, 0)
+        form.setHorizontalSpacing(8)
+        form.setVerticalSpacing(8)
+        form.setFieldGrowthPolicy(QFormLayout.FieldGrowthPolicy.AllNonFixedFieldsGrow)
+        form.setLabelAlignment(Qt.AlignmentFlag.AlignRight)
+        form.addRow("Recording", _control_native(recording_gui.recording_folder))
+        form.addRow("ROI file", _control_native(recording_gui.roi_file_to_load))
+        layout.addLayout(form)
+        self.setLayout(layout)
+
+
+def _control_native(widget: object) -> QWidget:
+    """Return the Qt widget wrapped by a magicgui control.
+
+    Args:
+        widget: Magicgui widget or Qt widget.
+
+    Returns:
+        QWidget that can be inserted into the compact Load form.
+    """
+    native_widget = getattr(widget, "native", widget)
+    if not isinstance(native_widget, QWidget):
+        msg = f"Load control expected a QWidget, got {type(native_widget).__name__}."
+        raise TypeError(msg)
+    return native_widget
 
 
 def _make_loaded_recordings_widget(state: NapariControlState) -> object:
@@ -413,63 +412,6 @@ def _make_loaded_recordings_widget(state: NapariControlState) -> object:
     return panel
 
 
-def _make_twopy_save_rois_widget(state: NapariControlState) -> object:
-    """Create the left-side magicgui widget for saving ROI labels.
-
-    Args:
-        state: Mutable napari control state.
-
-    Returns:
-        magicgui widget with one Save ROIs button.
-    """
-    from magicgui import magicgui
-
-    @magicgui(call_button="Save ROIs", layout="vertical")
-    def save_rois(roi_save_file: Path = Path(DEFAULT_PATH_TEXT)) -> str:
-        """Save current napari ROI labels to twopy ROI HDF5.
-
-        Args:
-            roi_save_file: Destination ROI HDF5 path. ``default`` uses the
-                current recording's default ROI output path.
-
-        Returns:
-            Human-readable status for the dock widget.
-        """
-        if state.roi_labels_layer is None:
-            return "No ROI Labels layer is available."
-        if state.recording is None:
-            return "No recording is selected."
-        try:
-            label_image = roi_label_image_from_layer_for_recording(
-                state.roi_labels_layer,
-                state.recording,
-            )
-        except ValueError as error:
-            return str(error)
-        if not np.any(label_image > 0):
-            return "No ROI labels to save."
-
-        resolved_output_path = resolve_widget_output_path(
-            roi_save_file,
-            default=state.roi_save_file,
-        )
-        roi_set = save_napari_label_rois(label_image, resolved_output_path)
-        state.roi_save_file = resolved_output_path
-        update_selected_roi_save_file(state, resolved_output_path)
-        if hasattr(state.response_plot_widget, "set_roi_save_file"):
-            cast(_RoiSavePathReceiver, state.response_plot_widget).set_roi_save_file(
-                resolved_output_path
-            )
-        return (
-            f"Saved {counted_noun(len(roi_set.labels), 'ROI', 'ROIs')} "
-            f"to {resolved_output_path}"
-        )
-
-    save_rois.roi_save_file.mode = "w"
-    save_rois.roi_save_file.label = "ROI save file"
-    return save_rois
-
-
 def _configure_recording_folder_picker(
     widget: FileEdit,
     state: NapariControlState,
@@ -706,75 +648,3 @@ def _resolve_optional_roi_path(path: PathInput) -> Path | None:
         msg = f"ROI file does not exist: {resolved}"
         raise ValueError(msg)
     return resolved.resolve()
-
-
-def _default_movie_end_frame(recording: RecordingData | None) -> int:
-    """Return the default inclusive movie end frame for a loaded recording.
-
-    Args:
-        recording: Optional loaded recording.
-
-    Returns:
-        Last available frame index, or ``0`` before a recording is loaded.
-    """
-    if recording is None:
-        return 0
-    return max(recording.movie.shape[0] - 1, 0)
-
-
-def _widget_movie_frame_range_for_load(
-    movie_frame_range: tuple[int, int],
-    *,
-    frame_count: int,
-    preserve_current_range: bool,
-) -> tuple[int, int]:
-    """Choose a GUI movie preview range for the recording being loaded.
-
-    Args:
-        movie_frame_range: Current range-slider value.
-        frame_count: Number of movie frames in the recording being loaded.
-        preserve_current_range: Whether this is a reload of the selected
-            recording after an option change.
-
-    Returns:
-        Inclusive preview range constrained to the recording length. New
-        recordings default to their full movie, while reloads preserve the
-        visible slider value where possible.
-
-    The frame-range widget keeps its previous value until after a recording
-    loads. That value is meaningful when reloading the same recording after an
-    option change, but stale when choosing a different recording.
-    """
-    last_frame = max(frame_count - 1, 0)
-    if not preserve_current_range:
-        return (0, last_frame)
-
-    start_frame = int(movie_frame_range[0])
-    end_frame = int(movie_frame_range[1])
-    if start_frame > last_frame:
-        start_frame = last_frame
-    if end_frame > last_frame:
-        end_frame = last_frame
-    return (start_frame, end_frame)
-
-
-def _load_recording_for_defaults(
-    *,
-    recording_data_path: Path,
-    movie_path: Path | None,
-) -> RecordingData:
-    """Load recording metadata before resolving frame defaults.
-
-    Args:
-        recording_data_path: Converted ``recording_data.h5`` path.
-        movie_path: Optional explicit converted movie path.
-
-    Returns:
-        Loaded recording object.
-
-    Loading the small manifest lets the empty-launch widget convert its initial
-    ``0`` end frame into the actual final frame before adding the movie layer.
-    """
-    from twopy.converted import load_converted_recording
-
-    return load_converted_recording(recording_data_path, movie_path=movie_path)