TwoPy 0.2.0__tar.gz → 0.2.1__tar.gz

{twopy-0.2.0 → twopy-0.2.1}/PKG-INFO

@@ -1,9 +1,11 @@
 Metadata-Version: 2.4
 Name: twopy
-Version: 0.2.0
+Version: 0.2.1
 Summary: Two-photon imaging analysis tool with a napari interface.
 Author-email: Gustavo Madeira Santana <fromweb1@gumadeiras.com>
 License-Expression: MIT
+Project-URL: Homepage, https://twopy.gumadeiras.com
+Project-URL: Repository, https://github.com/gumadeiras/twopy
 Requires-Python: <3.14,>=3.13
 Description-Content-Type: text/markdown
 Requires-Dist: h5py<4,>=3.16
@@ -73,9 +75,11 @@ When a source recording has not been converted yet, twopy converts it first. Con
 
 ## Docs
 
-- [GUI guide](docs/gui.md): napari loading, ROI editing, plotting, and saved outputs.
-- [Python API guide](docs/python_api.md): find recordings, convert data, run analysis, and open napari from scripts.
-- [Custom workflow guide](docs/custom_workflows.md): add versioned local analyses to the napari Custom tab.
+- [Full documentation](https://twopy.gumadeiras.com)
+- [Getting started](docs/getting_started.md): install, configure, launch, and save your first analysis.
+- [GUI guide](docs/gui/index.md): one page per task — loading, ROIs, plots, custom workflows, group matching, saving.
+- [Python API guide](docs/python_api.md): find recordings, convert data, extract traces, fit kernels, and open napari from scripts.
+- [Writing custom workflows](docs/writing_custom_workflows.md): add your own analysis to the napari Custom tab.
 - [Development guide](docs/development.md): source setup and local checks.
 - [Input data spec](docs/input_data_spec.md): short recording folder contract.
 - [Recording file reference](docs/recording_file_schema.md): detailed source and converted file schema.

{twopy-0.2.0 → twopy-0.2.1}/README.md

@@ -53,9 +53,11 @@ When a source recording has not been converted yet, twopy converts it first. Con
 
 ## Docs
 
-- [GUI guide](docs/gui.md): napari loading, ROI editing, plotting, and saved outputs.
-- [Python API guide](docs/python_api.md): find recordings, convert data, run analysis, and open napari from scripts.
-- [Custom workflow guide](docs/custom_workflows.md): add versioned local analyses to the napari Custom tab.
+- [Full documentation](https://twopy.gumadeiras.com)
+- [Getting started](docs/getting_started.md): install, configure, launch, and save your first analysis.
+- [GUI guide](docs/gui/index.md): one page per task — loading, ROIs, plots, custom workflows, group matching, saving.
+- [Python API guide](docs/python_api.md): find recordings, convert data, extract traces, fit kernels, and open napari from scripts.
+- [Writing custom workflows](docs/writing_custom_workflows.md): add your own analysis to the napari Custom tab.
 - [Development guide](docs/development.md): source setup and local checks.
 - [Input data spec](docs/input_data_spec.md): short recording folder contract.
 - [Recording file reference](docs/recording_file_schema.md): detailed source and converted file schema.

{twopy-0.2.0 → twopy-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "twopy"
-version = "0.2.0"
+version = "0.2.1"
 description = "Two-photon imaging analysis tool with a napari interface."
 readme = "README.md"
 requires-python = ">=3.13,<3.14"
@@ -29,6 +29,10 @@ dependencies = [
 [project.scripts]
 twopy = "twopy.napari:main"
 
+[project.urls]
+Homepage = "https://twopy.gumadeiras.com"
+Repository = "https://github.com/gumadeiras/twopy"
+
 [tool.setuptools.packages.find]
 where = ["src"]
 
@@ -43,11 +47,15 @@ target-version = "py313"
 [tool.ruff.lint]
 select = [
   "ANN",
+  "ARG",
   "B",
+  "C4",
   "D",
   "E",
   "F",
   "I",
+  "NPY",
+  "PTH",
   "SIM",
   "UP",
   "W",

{twopy-0.2.0 → twopy-0.2.1}/src/twopy/analysis/background_subtraction.py

@@ -15,6 +15,7 @@ from typing import Literal
 
 import numpy as np
 import numpy.typing as npt
+from scipy import sparse
 
 from twopy.converted import RecordingData
 from twopy.frame_ranges import normalize_frame_range
@@ -278,6 +279,7 @@ def _extract_mean_traces_from_indices(
     rather than total recording length.
     """
     traces = np.empty((frame_stop - frame_start, len(pixel_indices_by_trace)))
+    projection = _mean_projection(pixel_indices_by_trace)
     _check_cancelled(check_cancelled)
     for chunk_start, chunk_stop, frames in recording.movie.iter_frame_batches(
         chunk_frames=chunk_frames,
@@ -289,10 +291,7 @@ def _extract_mean_traces_from_indices(
         chunk_offset = chunk_start - frame_start
         chunk_slice = slice(chunk_offset, chunk_offset + (chunk_stop - chunk_start))
         chunk_flat = frames.reshape(frames.shape[0], -1)
-        for trace_index, pixel_indices in enumerate(pixel_indices_by_trace):
-            traces[chunk_slice, trace_index] = chunk_flat[:, pixel_indices].mean(
-                axis=1,
-            )
+        traces[chunk_slice, :] = _project_trace_pixels(chunk_flat, projection)
         _check_cancelled(check_cancelled)
 
     return traces
@@ -344,6 +343,7 @@ def _extract_movie_global_percentile_corrected_traces(
     )
     frame_count = frame_stop - frame_start
     roi_count = len(roi_pixel_indices)
+    projection = _mean_projection(roi_pixel_indices)
     raw_values = np.empty((frame_count, roi_count), dtype=np.float64)
     background_values = np.empty((frame_count, roi_count), dtype=np.float64)
     corrected_values = np.empty((frame_count, roi_count), dtype=np.float64)
@@ -359,14 +359,19 @@ def _extract_movie_global_percentile_corrected_traces(
         chunk_slice = slice(chunk_offset, chunk_offset + (chunk_stop - chunk_start))
         chunk_flat = frames.reshape(frames.shape[0], -1)
         background_trace = chunk_flat[:, background_indices].mean(axis=1)
-        for roi_index, pixel_indices in enumerate(roi_pixel_indices):
-            roi_pixels = chunk_flat[:, pixel_indices]
-            raw_values[chunk_slice, roi_index] = roi_pixels.mean(axis=1)
-            background_values[chunk_slice, roi_index] = background_trace
-            # Clamp pixels before averaging so dim pixels cannot pull the
-            # corrected ROI trace below zero.
-            corrected_pixels = np.maximum(roi_pixels - background_trace[:, None], 0.0)
-            corrected_values[chunk_slice, roi_index] = corrected_pixels.mean(axis=1)
+        roi_pixels = chunk_flat[:, projection.pixel_indices]
+        raw_values[chunk_slice, :] = _project_selected_pixels(roi_pixels, projection)
+        background_values[chunk_slice, :] = background_trace[:, np.newaxis]
+        # Clamp pixels before averaging so dim pixels cannot pull the
+        # corrected ROI trace below zero.
+        corrected_pixels = np.maximum(
+            roi_pixels - background_trace[:, np.newaxis],
+            0.0,
+        )
+        corrected_values[chunk_slice, :] = _project_selected_pixels(
+            corrected_pixels,
+            projection,
+        )
         _check_cancelled(check_cancelled)
 
     metadata: dict[str, BackgroundMetadataValue] = {
@@ -440,6 +445,7 @@ def _extract_movie_y_stripe_percentile_corrected_traces(
     )
     frame_count = frame_stop - frame_start
     roi_count = len(roi_pixel_indices)
+    projection = _mean_projection(roi_pixel_indices)
     raw_values = np.empty((frame_count, roi_count), dtype=np.float64)
     background_values = np.empty((frame_count, roi_count), dtype=np.float64)
     corrected_values = np.empty((frame_count, roi_count), dtype=np.float64)
@@ -460,15 +466,21 @@ def _extract_movie_y_stripe_percentile_corrected_traces(
         )
         chunk_flat = frames.reshape(frames.shape[0], -1)
         background_flat = background_field.reshape(background_field.shape[0], -1)
-        for roi_index, pixel_indices in enumerate(roi_pixel_indices):
-            roi_pixels = chunk_flat[:, pixel_indices]
-            roi_background_pixels = background_flat[:, pixel_indices]
-            raw_values[chunk_slice, roi_index] = roi_pixels.mean(axis=1)
-            background_values[chunk_slice, roi_index] = roi_background_pixels.mean(
-                axis=1,
-            )
-            corrected_pixels = np.maximum(roi_pixels - roi_background_pixels, 0.0)
-            corrected_values[chunk_slice, roi_index] = corrected_pixels.mean(axis=1)
+        roi_pixels = chunk_flat[:, projection.pixel_indices]
+        roi_background_pixels = background_flat[:, projection.pixel_indices]
+        raw_values[chunk_slice, :] = _project_selected_pixels(roi_pixels, projection)
+        background_values[chunk_slice, :] = _project_selected_pixels(
+            roi_background_pixels,
+            projection,
+        )
+        corrected_pixels = np.maximum(
+            roi_pixels - roi_background_pixels,
+            0.0,
+        )
+        corrected_values[chunk_slice, :] = _project_selected_pixels(
+            corrected_pixels,
+            projection,
+        )
         _check_cancelled(check_cancelled)
 
     metadata: dict[str, BackgroundMetadataValue] = {
@@ -593,6 +605,93 @@ def _roi_pixel_indices_from_masks(
     return tuple(np.flatnonzero(mask).astype(np.int64) for mask in flat_masks)
 
 
+@dataclass(frozen=True)
+class _MeanProjection:
+    """Sparse averaging matrix plus selected flattened pixel indices."""
+
+    pixel_indices: npt.NDArray[np.int64]
+    matrix: sparse.csc_matrix
+
+
+def _mean_projection(
+    pixel_indices_by_trace: tuple[npt.NDArray[np.int64], ...],
+) -> _MeanProjection:
+    """Return selected pixels and a sparse pixel-to-trace averaging matrix.
+
+    Args:
+        pixel_indices_by_trace: One flattened pixel-index array per trace.
+
+    Returns:
+        Selected flattened pixel indices plus a sparse matrix shaped
+        ``(selected_pixels, traces)`` whose columns average each trace.
+
+    Pixel indices are concatenated per trace instead of deduplicated. That
+    preserves the existing behavior for overlapping ROIs, where the same movie
+    pixel can contribute independently to more than one ROI mean.
+    """
+    selected_pixel_indices: list[npt.NDArray[np.int64]] = []
+    rows: list[npt.NDArray[np.int64]] = []
+    columns: list[npt.NDArray[np.int64]] = []
+    values: list[npt.NDArray[np.float64]] = []
+    row_start = 0
+    for trace_index, pixel_indices in enumerate(pixel_indices_by_trace):
+        if pixel_indices.size == 0:
+            continue
+        selected_pixel_indices.append(pixel_indices)
+        rows.append(
+            np.arange(
+                row_start,
+                row_start + pixel_indices.size,
+                dtype=np.int64,
+            ),
+        )
+        row_start += pixel_indices.size
+        columns.append(
+            np.full(pixel_indices.shape, trace_index, dtype=np.int64),
+        )
+        values.append(
+            np.full(
+                pixel_indices.shape,
+                1.0 / float(pixel_indices.size),
+                dtype=np.float64,
+            ),
+        )
+    if len(selected_pixel_indices) == 0:
+        return _MeanProjection(
+            pixel_indices=np.array([], dtype=np.int64),
+            matrix=sparse.csc_matrix((0, len(pixel_indices_by_trace))),
+        )
+    return _MeanProjection(
+        pixel_indices=np.concatenate(selected_pixel_indices),
+        matrix=sparse.csc_matrix(
+            (
+                np.concatenate(values),
+                (np.concatenate(rows), np.concatenate(columns)),
+            ),
+            shape=(row_start, len(pixel_indices_by_trace)),
+        ),
+    )
+
+
+def _project_trace_pixels(
+    chunk_flat: npt.NDArray[np.float64],
+    projection: _MeanProjection,
+) -> npt.NDArray[np.float64]:
+    """Return trace means from a flattened movie chunk and projection."""
+    return _project_selected_pixels(chunk_flat[:, projection.pixel_indices], projection)
+
+
+def _project_selected_pixels(
+    selected_pixels: npt.NDArray[np.float64],
+    projection: _MeanProjection,
+) -> npt.NDArray[np.float64]:
+    """Return trace means from selected pixel columns."""
+    return np.asarray(
+        selected_pixels @ projection.matrix,
+        dtype=np.float64,
+    )
+
+
 def _check_cancelled(check_cancelled: Callable[[], None] | None) -> None:
     """Raise ``CancelledError`` when an interactive caller superseded this work."""
     if check_cancelled is None:

{twopy-0.2.0 → twopy-0.2.1}/src/twopy/analysis/dff.py

@@ -115,6 +115,10 @@ def compute_roi_delta_f_over_f(
         data_rate_hz=data_rate_hz,
         baseline_sample_seconds=baseline_sample_seconds,
     )
+    _validate_baseline_samples_for_background_method(
+        traces=traces,
+        baseline_samples=baseline_samples,
+    )
     tau = _fit_shared_tau(
         frame_numbers=baseline_samples.frame_numbers,
         mean_fluorescence=baseline_samples.values.mean(axis=1),
@@ -274,6 +278,35 @@ def _baseline_samples(
     )
 
 
+def _validate_baseline_samples_for_background_method(
+    *,
+    traces: BackgroundCorrectedRoiTraces,
+    baseline_samples: _BaselineSamples,
+) -> None:
+    """Reject background-corrected baselines that cannot support dF/F."""
+    if traces.method != "roi_y_stripe_percentile":
+        return
+
+    invalid = ~np.isfinite(baseline_samples.values) | (baseline_samples.values <= 0.0)
+    if not np.any(invalid):
+        return
+
+    roi_indices = np.flatnonzero(np.any(invalid, axis=0))
+    labels = ", ".join(traces.labels[index] for index in roi_indices[:5])
+    if roi_indices.size > 5:
+        labels = f"{labels}, ..."
+    minimum = float(np.nanmin(baseline_samples.values[:, roi_indices]))
+    msg = (
+        "ROI y-stripe P% background subtraction over-subtracted baseline "
+        f"fluorescence for {labels}; minimum corrected baseline sample is "
+        f"{minimum:.6g}. dF/F needs positive baseline fluorescence, so the "
+        "local y-stripe pixels are not a valid additive background for those "
+        "ROIs. Use shared y-stripe P%, global percentile, or revise the ROIs "
+        "to leave dim local background pixels."
+    )
+    raise ValueError(msg)
+
+
 def _validate_baseline_local_range(
     *,
     window: FrameWindow,

{twopy-0.2.0 → twopy-0.2.1}/src/twopy/analysis/kernels/__init__.py

@@ -80,8 +80,8 @@ class StimulusKernelOptions:
     baseline_epoch_number: int = 1
     discard_first_stimulus_epoch: bool = True
     selected_epoch_numbers: tuple[int, ...] | None = None
-    num_stim_past: int = 150
-    num_stim_future: int = 25
+    num_stim_past: int = 100
+    num_stim_future: int = 10
     method: KernelFitMethod = "ols"
     hemisphere: Hemisphere | None = None
 

{twopy-0.2.0 → twopy-0.2.1}/src/twopy/analysis/persistence.py

@@ -869,7 +869,7 @@ def _trial_response_row(
         "stop_frame": trial.stop_frame,
         "frame_count": trial.stop_frame - trial.start_frame,
     }
-    row.update({column: "" for column in time_columns})
+    row.update(dict.fromkeys(time_columns, ""))
     for time_seconds, value in zip(
         trial.time_seconds,
         trial.values[:, roi_index],

{twopy-0.2.0 → twopy-0.2.1}/src/twopy/analysis_cache.py

@@ -10,6 +10,7 @@ files are removed from the local cache after they copy successfully because the
 publish destination is their durable location.
 """
 
+import os
 import shutil
 import tempfile
 from concurrent.futures import Executor, Future
@@ -266,7 +267,7 @@ def copy_file_atomically(source: Path, target: Path) -> None:
     temp_path = Path(temp_name)
     try:
         with (
-            open(temp_descriptor, "wb") as temp_file,
+            os.fdopen(temp_descriptor, "wb") as temp_file,
             source.open(
                 "rb",
             ) as source_file,

{twopy-0.2.0 → twopy-0.2.1}/src/twopy/config.py

@@ -21,6 +21,7 @@ __all__ = [
     "DatabaseAccess",
     "TwopyConfig",
     "data_path_match",
+    "data_path_recording_candidates",
     "load_config",
     "resolve_data_recording_path",
     "resolve_analysis_cache_dir",
@@ -84,7 +85,7 @@ def load_config(path: Path = DEFAULT_CONFIG_PATH) -> TwopyConfig:
         msg = f"twopy config must be a YAML mapping: {config_path}"
         raise ValueError(msg)
 
-    raw_config: dict[object, object] = {key: value for key, value in loaded.items()}
+    raw_config: dict[object, object] = dict(loaded.items())
 
     return TwopyConfig(
         database_path=_required_path(raw_config, "database_path", config_path),
@@ -136,13 +137,7 @@ def resolve_data_recording_path(
     function is the ordered availability check that picks the preferred mounted
     copy without hiding missing-data errors behind a second abstraction.
     """
-    candidates = tuple(
-        data_root.expanduser().joinpath(*relative_parts)
-        for data_root in config.data_paths
-    )
-    if not candidates:
-        msg = "twopy config must include at least one data path"
-        raise ValueError(msg)
+    candidates = _recording_candidates_for_relative_parts(config, relative_parts)
 
     for candidate in candidates:
         if candidate.exists():
@@ -177,6 +172,35 @@ def data_path_match(
     return None
 
 
+def data_path_recording_candidates(
+    config: TwopyConfig,
+    recording_dir: Path,
+) -> tuple[Path, ...]:
+    """Return every configured mirror candidate for one recording path.
+
+    Args:
+        config: Loaded twopy configuration with ordered data roots.
+        recording_dir: Recording folder under one configured data root.
+
+    Returns:
+        Candidate recording folders under every configured root with the same
+        root-relative path, or an empty tuple when ``recording_dir`` is external.
+
+    Database loads may fall back to the first configured root when no source
+    copy is mounted so cache-only loads can still work. This helper exposes the
+    full mirrored candidate set for diagnostics and audits without changing
+    that load behavior.
+    """
+    match = data_path_match(config, recording_dir)
+    if match is None:
+        return ()
+    _matched_root, relative_recording = match
+    return _recording_candidates_for_relative_parts(
+        config,
+        tuple(str(part) for part in relative_recording.parts),
+    )
+
+
 def resolve_analysis_output_dir(config: TwopyConfig, recording_dir: Path) -> Path:
     """Resolve the output directory for one recording.
 
@@ -314,6 +338,21 @@ def _required_path_tuple(
     return tuple(paths)
 
 
+def _recording_candidates_for_relative_parts(
+    config: TwopyConfig,
+    relative_parts: tuple[str, ...],
+) -> tuple[Path, ...]:
+    """Return ordered data-root candidates for one relative recording path."""
+    candidates = tuple(
+        data_root.expanduser().joinpath(*relative_parts)
+        for data_root in config.data_paths
+    )
+    if not candidates:
+        msg = "twopy config must include at least one data path"
+        raise ValueError(msg)
+    return candidates
+
+
 def _external_analysis_cache_dir(
     config: TwopyConfig,
     source_dir: Path,

{twopy-0.2.0 → twopy-0.2.1}/src/twopy/custom/__init__.py

@@ -31,6 +31,7 @@ from twopy.custom.types import (
     CustomEpoch,
     CustomLineBand,
     CustomLinePlot,
+    CustomRecordingMetadata,
     CustomResult,
     CustomRunContext,
     CustomTable,
@@ -43,6 +44,7 @@ __all__ = [
     "CustomEpoch",
     "CustomLineBand",
     "CustomLinePlot",
+    "CustomRecordingMetadata",
     "CustomParameterSpec",
     "CustomResult",
     "CustomRunContext",

{twopy-0.2.0 → twopy-0.2.1}/src/twopy/custom/native_workflows/direction_selectivity.py

@@ -25,7 +25,7 @@ class DirectionSelectivityParams:
         window_stop_seconds: Epoch-relative metric stop time.
         rectify_responses: Whether negative preferred/null responses are set
             to zero before computing DSI.
-        dsi_threshold: Minimum absolute DSI to plot and highlight.
+        dsi_threshold: Minimum absolute DSI to show and highlight.
         output_name: CSV filename under the workflow output folder.
 
     Returns:
@@ -88,9 +88,9 @@ class DirectionSelectivityParams:
     dsi_threshold: float = field(
         default=0.0,
         metadata={
-            "label": "DSI plot threshold",
+            "label": "DSI show threshold",
             "description": (
-                "Only ROIs with absolute DSI at or above this value are plotted."
+                "Only ROIs with absolute DSI at or above this value are shown."
             ),
             "max": 1.0,
             "twopy_role": "table_highlight_threshold",
@@ -125,8 +125,9 @@ def run(
         params: Custom tab values.
 
     Returns:
-        Table and response plot data for the Custom tab.
+        Table output plus ROI visibility rows for the current response plot.
     """
+    selected_roi_indices = ctx.roi_indices_for_selector(params.roi_selector)
     rois = ctx.rois_for_selector(params.roi_selector)
     computation = ctx.compute_standard_responses(rois)
     window_seconds = ctx.epoch_window(
@@ -158,27 +159,27 @@ def run(
         },
         roi_labels=rois.labels,
     )
-    passing_roi_indices = tuple(
+    passing_table_rows = tuple(
         int(index) for index in np.flatnonzero(np.abs(dsi) >= params.dsi_threshold)
     )
-    response_plot_data = ctx.response_plot_data(
-        computation.grouped_responses,
-        source_path=csv_path,
-        roi_indices=passing_roi_indices,
+    visible_roi_indices = tuple(
+        selected_roi_indices[index]
+        for index in passing_table_rows
+        if index < len(selected_roi_indices)
     )
     return CustomResult(
         message=(
             f"Computed DSI for {len(rois.labels)} ROIs; "
-            f"plotting {len(passing_roi_indices)} above absolute threshold."
+            f"showing {len(visible_roi_indices)} above absolute threshold."
         ),
         tables=(
             CustomTable(
                 "Direction selectivity",
                 csv_path,
-                highlighted_rows=passing_roi_indices,
+                highlighted_rows=passing_table_rows,
             ),
         ),
-        response_plot_data=response_plot_data,
+        visible_roi_indices=visible_roi_indices,
     )
 
 

{twopy-0.2.0 → twopy-0.2.1}/src/twopy/custom/native_workflows/response_kernels.py

@@ -95,7 +95,7 @@ class ResponseKernelParams:
         },
     )
     num_stim_past: int = field(
-        default=150,
+        default=100,
         metadata={
             "label": "Past samples",
             "description": "Stimulus samples before each response sample.",
@@ -103,7 +103,7 @@ class ResponseKernelParams:
         },
     )
     num_stim_future: int = field(
-        default=25,
+        default=10,
         metadata={
             "label": "Future samples",
             "description": "Future stimulus samples used as negative-lag QC.",
@@ -244,7 +244,6 @@ def _olfactory_kernel_result(
         ipsi_mean, ipsi_band = _mean_sem_plot_series(
             kernels.ipsilateral[epoch_index],
             series_index=len(mean_rows),
-            label=f"{epoch_name} ipsi",
         )
         mean_rows.append(ipsi_mean)
         mean_labels.append(f"{epoch_name} ipsi")
@@ -252,7 +251,6 @@ def _olfactory_kernel_result(
         contra_mean, contra_band = _mean_sem_plot_series(
             kernels.contralateral[epoch_index],
             series_index=len(mean_rows),
-            label=f"{epoch_name} contra",
         )
         mean_rows.append(contra_mean)
         mean_labels.append(f"{epoch_name} contra")
@@ -324,7 +322,6 @@ def _visual_kernel_result(
         contrast_mean, contrast_band = _mean_sem_plot_series(
             contrast,
             series_index=len(mean_rows),
-            label=epoch_name,
         )
         mean_rows.append(contrast_mean)
         mean_labels.append(epoch_name)
@@ -355,7 +352,6 @@ def _mean_sem_plot_series(
     values: np.ndarray,
     *,
     series_index: int,
-    label: str,
 ) -> tuple[np.ndarray, CustomLineBand]:
     """Return one mean row and filled SEM band for one kernel matrix."""
     mean, sem = finite_mean_and_sem(values, axis=0)
@@ -363,7 +359,6 @@ def _mean_sem_plot_series(
         series_index=series_index,
         lower=mean - sem,
         upper=mean + sem,
-        label=f"{label} SEM",
     )
 
 

{twopy-0.2.0 → twopy-0.2.1}/src/twopy/custom/provenance.py

@@ -87,6 +87,7 @@ def validate_custom_result(
         raise ValueError(msg)
     if result.response_plot_data is not None:
         _validate_response_plot_data(result.response_plot_data)
+    _validate_custom_result_visible_rois(result.visible_roi_indices)
     return result
 
 
@@ -101,6 +102,19 @@ def _validate_table_highlighted_rows(highlighted_rows: object) -> None:
             raise ValueError(msg)
 
 
+def _validate_custom_result_visible_rois(visible_roi_indices: object) -> None:
+    """Check optional ROI rows selected by a workflow result."""
+    if visible_roi_indices is None:
+        return
+    if not isinstance(visible_roi_indices, tuple):
+        msg = "CustomResult.visible_roi_indices must be a tuple of integers."
+        raise ValueError(msg)
+    for index in visible_roi_indices:
+        if type(index) is not int or index < 0:
+            msg = "CustomResult.visible_roi_indices must contain non-negative integers."
+            raise ValueError(msg)
+
+
 def custom_result_artifact_paths(result: CustomResult) -> tuple[Path, ...]:
     """Return every output file path declared by a custom result.