TwoPy 0.3.1__tar.gz → 0.3.3__tar.gz

{twopy-0.3.1 → twopy-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: twopy
-Version: 0.3.1
+Version: 0.3.3
 Summary: Two-photon imaging analysis tool with a napari interface.
 Author-email: Gustavo Madeira Santana <fromweb1@gumadeiras.com>
 License-Expression: MIT
@@ -12,6 +12,7 @@ Requires-Dist: h5py<4,>=3.16
 Requires-Dist: matplotlib<4,>=3.10
 Requires-Dist: napari[all]<0.8,>=0.7
 Requires-Dist: numpy<3,>=2.3
+Requires-Dist: packaging<27,>=26
 Requires-Dist: pre-commit<5,>=4.6
 Requires-Dist: qtpy<3,>=2.4
 Requires-Dist: pyyaml<7,>=6.0.3
@@ -30,7 +31,7 @@ Two-photon imaging analysis tool for the Clark Lab output format.
 
 twopy lets you open two-photon recordings, draw ROIs, plot responses in real time, process and analyze them, and save them.
 
-When you first load a recording, twopy converts it to a standardized HDF5 format. The converted format includes the aligned movie, mean image, stimulus tables, photodiode signals, and  recording metadata. Analysis and the GUI both work from the converted files, so the original source files remain separate from twopy's outputs. By default, converted recordings and interactive analysis outputs are cached locally under `~/.cache/twopy/recordings` for speed; saving ROIs and analysis publishes the changed output files back to the configured `analysis_output` location in the background.
+When you first load a recording, twopy converts it to HDF5 files that it owns. Those files include the aligned movie, mean image, stimulus tables, photodiode signals, and recording metadata. Analysis and the GUI both work from the converted files, so the original source files remain separate from twopy's outputs. By default, converted recordings and interactive analysis outputs are cached locally under `~/.cache/twopy/recordings` for speed; saving ROIs and analysis copies the changed output files back to the configured `analysis_output` location in the background.
 
 ## Install
 
@@ -48,7 +49,19 @@ Verify the install:
 micromamba run -n twopy python -c 'import twopy; print(twopy.__name__)'
 ```
 
-For a source checkout, copy `config.example.yml` to `config.yml` and edit the paths for your computer. `config.yml` stays local and is not tracked by git.
+Create the config template in your user folder:
+
+```sh
+twopy config setup
+```
+
+twopy prints the config path it wrote. On macOS and Linux the default is `~/.config/twopy/config.yml`; on Windows it is under `%APPDATA%\twopy\config.yml`. Edit that file with your database, data, and output paths before launching twopy. If you launch `twopy` before a config exists, twopy creates the same template, prints the path, and stops so you can edit it.
+
+Validate the active config and show its path and file contents:
+
+```sh
+twopy config
+```
 
 ## Start
 
@@ -57,6 +70,8 @@ micromamba activate twopy
 twopy
 ```
 
+`twopy` validates the config before opening napari. It does not require lab data folders or network drives to be mounted at launch.
+
 Open a source recording or converted recording directly:
 
 ```sh

{twopy-0.3.1 → twopy-0.3.3}/README.md

@@ -8,7 +8,7 @@ Two-photon imaging analysis tool for the Clark Lab output format.
 
 twopy lets you open two-photon recordings, draw ROIs, plot responses in real time, process and analyze them, and save them.
 
-When you first load a recording, twopy converts it to a standardized HDF5 format. The converted format includes the aligned movie, mean image, stimulus tables, photodiode signals, and  recording metadata. Analysis and the GUI both work from the converted files, so the original source files remain separate from twopy's outputs. By default, converted recordings and interactive analysis outputs are cached locally under `~/.cache/twopy/recordings` for speed; saving ROIs and analysis publishes the changed output files back to the configured `analysis_output` location in the background.
+When you first load a recording, twopy converts it to HDF5 files that it owns. Those files include the aligned movie, mean image, stimulus tables, photodiode signals, and recording metadata. Analysis and the GUI both work from the converted files, so the original source files remain separate from twopy's outputs. By default, converted recordings and interactive analysis outputs are cached locally under `~/.cache/twopy/recordings` for speed; saving ROIs and analysis copies the changed output files back to the configured `analysis_output` location in the background.
 
 ## Install
 
@@ -26,7 +26,19 @@ Verify the install:
 micromamba run -n twopy python -c 'import twopy; print(twopy.__name__)'
 ```
 
-For a source checkout, copy `config.example.yml` to `config.yml` and edit the paths for your computer. `config.yml` stays local and is not tracked by git.
+Create the config template in your user folder:
+
+```sh
+twopy config setup
+```
+
+twopy prints the config path it wrote. On macOS and Linux the default is `~/.config/twopy/config.yml`; on Windows it is under `%APPDATA%\twopy\config.yml`. Edit that file with your database, data, and output paths before launching twopy. If you launch `twopy` before a config exists, twopy creates the same template, prints the path, and stops so you can edit it.
+
+Validate the active config and show its path and file contents:
+
+```sh
+twopy config
+```
 
 ## Start
 
@@ -35,6 +47,8 @@ micromamba activate twopy
 twopy
 ```
 
+`twopy` validates the config before opening napari. It does not require lab data folders or network drives to be mounted at launch.
+
 Open a source recording or converted recording directly:
 
 ```sh

{twopy-0.3.1 → twopy-0.3.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "twopy"
-version = "0.3.1"
+version = "0.3.3"
 description = "Two-photon imaging analysis tool with a napari interface."
 readme = "README.md"
 requires-python = ">=3.13,<3.14"
@@ -17,6 +17,7 @@ dependencies = [
   "matplotlib>=3.10,<4",
   "napari[all]>=0.7,<0.8",
   "numpy>=2.3,<3",
+  "packaging>=26,<27",
   "pre-commit>=4.6,<5",
   "qtpy>=2.4,<3",
   "pyyaml>=6.0.3,<7",
@@ -37,7 +38,7 @@ Repository = "https://github.com/gumadeiras/twopy"
 where = ["src"]
 
 [tool.setuptools.package-data]
-twopy = ["calibrations/*.csv"]
+twopy = ["calibrations/*.csv", "config.example.yml", "napari/assets/*.png"]
 
 [tool.ruff]
 line-length = 88

{twopy-0.3.1 → twopy-0.3.3}/src/twopy/analysis/group_matching.py

@@ -143,7 +143,7 @@ def make_manual_fov_group_rows(
 
 
 def make_manual_roi_match_rows(
-    recording_rois: Mapping[Path, str],
+    recording_rois: Sequence[tuple[Path, str]],
     *,
     group_cell_id: int,
     fov_group_id: str = "",
@@ -153,7 +153,9 @@ def make_manual_roi_match_rows(
     """Create validated match-table rows for one user decision.
 
     Args:
-        recording_rois: Mapping from recording path to ROI label.
+        recording_rois: Recording path and ROI label pairs selected for one
+            group. A recording can appear more than once when multiple ROIs
+            from that recording belong in the group.
         group_cell_id: Positive cell-group identifier for this decision.
         fov_group_id: Optional user-facing FOV group identifier.
         status: Decision status for every emitted row.
@@ -172,16 +174,27 @@ def make_manual_roi_match_rows(
         raise ValueError(msg)
 
     rows: list[ManualRoiMatchRow] = []
+    seen: set[tuple[Path, str]] = set()
     for recording_path, roi_label in sorted(
-        recording_rois.items(),
-        key=lambda item: str(item[0]),
+        recording_rois,
+        key=lambda item: (str(item[0]), item[1]),
     ):
+        validated_path = _validate_recording_path(recording_path)
+        validated_roi = _validate_roi_label(roi_label)
+        key = (validated_path, validated_roi)
+        if key in seen:
+            msg = (
+                "Manual ROI match rows cannot repeat the same recording and "
+                f"ROI label: {validated_path} {validated_roi}."
+            )
+            raise ValueError(msg)
+        seen.add(key)
         rows.append(
             ManualRoiMatchRow(
                 fov_group_id=fov_group_id,
                 group_cell_id=group_cell_id,
-                recording_path=_validate_recording_path(recording_path),
-                roi_label=_validate_roi_label(roi_label),
+                recording_path=validated_path,
+                roi_label=validated_roi,
                 status=status,
                 note=note,
             ),
@@ -225,7 +238,7 @@ def matched_manual_roi_groups(
 
 def add_manual_roi_match_group(
     rows: Sequence[ManualRoiMatchRow],
-    recording_rois: Mapping[Path, str],
+    recording_rois: Sequence[tuple[Path, str]],
     *,
     fov_group_id: str,
     note: str = "",
@@ -234,7 +247,7 @@ def add_manual_roi_match_group(
 
     Args:
         rows: Existing manual ROI match rows.
-        recording_rois: Mapping from recording path to selected ROI label.
+        recording_rois: Selected recording path and ROI label pairs.
         fov_group_id: FOV id for the new matched group.
         note: Optional note copied to every new row.
 
@@ -255,7 +268,7 @@ def add_manual_roi_match_group(
 
 def replace_manual_roi_match_group(
     rows: Sequence[ManualRoiMatchRow],
-    recording_rois: Mapping[Path, str],
+    recording_rois: Sequence[tuple[Path, str]],
     *,
     fov_group_id: str,
     group_cell_id: int,
@@ -265,7 +278,7 @@ def replace_manual_roi_match_group(
 
     Args:
         rows: Existing manual ROI match rows.
-        recording_rois: Replacement recording-to-ROI selections.
+        recording_rois: Replacement recording path and ROI label pairs.
         fov_group_id: FOV id containing the group.
         group_cell_id: Existing group id to replace.
         note: Optional note copied to every replacement row.

{twopy-0.3.1 → twopy-0.3.3}/src/twopy/analysis/persistence.py

@@ -101,7 +101,8 @@ class LoadedAnalysisOutputs:
     """Analysis objects loaded from one twopy analysis HDF5 file.
 
     Inputs: one file written by ``save_analysis_outputs``.
-    Outputs: optional ROI, trace, dF/F, window, and response objects.
+    Outputs: optional ROI, trace, dF/F, window, response objects, and a warning
+        when an old file uses a setting twopy no longer uses.
 
     Groups are optional because scripts can save only the products they have
     computed. Missing groups load as ``None`` or an empty window tuple.
@@ -117,6 +118,7 @@ class LoadedAnalysisOutputs:
     response_processing_options: ResponseProcessingOptions | None
     normalization_factors: RoiNormalizationFactors | None
     correlation_scores: RoiCorrelationScores | None
+    load_warning: str | None = None
 
 
 def save_analysis_outputs(
@@ -146,7 +148,7 @@ def save_analysis_outputs(
         grouped_responses: Optional grouped trial responses.
         response_processing_options: Optional smoothing, low-pass, and
             correlation-QC settings used for these outputs.
-        normalization_factors: Optional per-ROI factors used for epoch-peak
+        normalization_factors: Optional per-ROI factors used for response-size
             normalization.
         correlation_scores: Optional ROI-level correlation QC scores.
         response_summary_trials_csv: Optional CSV path for one row per trial
@@ -344,6 +346,11 @@ def load_analysis_outputs(path: Path) -> LoadedAnalysisOutputs:
                 if response_processing is not None
                 else None
             ),
+            load_warning=(
+                response_processing.load_warning
+                if response_processing is not None
+                else None
+            ),
         )
 
 

{twopy-0.3.1 → twopy-0.3.3}/src/twopy/analysis/response_plotting.py

@@ -80,6 +80,8 @@ class ResponsePlotData:
         correlation_window_stop_default_seconds: Optional default QC stop time.
         visible_roi_indices: Optional ROI rows to show initially while keeping all
             ROI data available.
+        load_warning: Optional warning when an old file uses a setting twopy no
+            longer uses.
 
     Returns:
         Immutable response plot view model with no GUI object references.
@@ -93,6 +95,7 @@ class ResponsePlotData:
     correlation_scores: RoiCorrelationScores | None = None
     correlation_window_stop_default_seconds: float | None = None
     visible_roi_indices: tuple[int, ...] | None = None
+    load_warning: str | None = None
 
 
 def response_plot_data_from_grouped(
@@ -105,6 +108,7 @@ def response_plot_data_from_grouped(
     response_processing_options: ResponseProcessingOptions | None = None,
     correlation_scores: RoiCorrelationScores | None = None,
     correlation_window_stop_default_seconds: float | None = None,
+    load_warning: str | None = None,
 ) -> ResponsePlotData:
     """Summarize grouped responses into mean and SEM traces for plotting.
 
@@ -122,6 +126,8 @@ def response_plot_data_from_grouped(
         correlation_scores: Optional ROI-level correlation QC scores.
         correlation_window_stop_default_seconds: Optional default stop time for
             enabling Plot-tab correlation QC.
+        load_warning: Optional warning when an old file uses a setting twopy no
+            longer uses.
 
     Returns:
         Plot-ready data with one item per stimulus epoch type.
@@ -162,6 +168,7 @@ def response_plot_data_from_grouped(
         response_processing_options=response_processing_options,
         correlation_scores=correlation_scores,
         correlation_window_stop_default_seconds=correlation_window_stop_default_seconds,
+        load_warning=load_warning,
     )
 
 
@@ -215,6 +222,7 @@ def filter_response_plot_data_rois(
             plot_data.visible_roi_indices,
             keep_indices,
         ),
+        load_warning=plot_data.load_warning,
     )
 
 

{twopy-0.3.1 → twopy-0.3.3}/src/twopy/analysis/response_processing/__init__.py

@@ -15,7 +15,7 @@ from twopy.analysis.response_processing.apply import (
     RoiNormalizationFactors,
     apply_correlation_filter_to_grouped_roi_responses,
     mask_grouped_roi_responses_by_included_rois,
-    normalize_grouped_roi_responses_by_epoch_peak,
+    normalize_grouped_roi_responses_by_epoch_abs_peak,
     process_grouped_roi_responses,
     process_roi_delta_f_over_f,
 )
@@ -55,7 +55,7 @@ __all__ = [
     "mask_grouped_roi_responses_by_included_rois",
     "nan_aware_moving_average",
     "nan_aware_savgol_filter",
-    "normalize_grouped_roi_responses_by_epoch_peak",
+    "normalize_grouped_roi_responses_by_epoch_abs_peak",
     "process_grouped_roi_responses",
     "process_roi_delta_f_over_f",
     "ResponseProcessingOptions",

{twopy-0.3.1 → twopy-0.3.3}/src/twopy/analysis/response_processing/apply.py

@@ -37,7 +37,7 @@ from twopy.analysis.responses import (
 
 __all__ = [
     "apply_correlation_filter_to_grouped_roi_responses",
-    "normalize_grouped_roi_responses_by_epoch_peak",
+    "normalize_grouped_roi_responses_by_epoch_abs_peak",
     "mask_grouped_roi_responses_by_included_rois",
     "RoiNormalizationFactors",
     "ResponseProcessingResult",
@@ -50,10 +50,10 @@ _NORMALIZATION_MIN_PEAK = 1e-12
 
 @dataclass(frozen=True)
 class RoiNormalizationFactors:
-    """Per-ROI factors used for epoch-peak response normalization.
+    """Per-ROI scale factors used for response-size normalization.
 
     Inputs: grouped response trials and one enabled normalization option.
-    Outputs: the positive peak factor for each ROI in the selected epoch.
+    Outputs: the positive response size used to scale each ROI.
     """
 
     roi_labels: tuple[str, ...]
@@ -150,9 +150,11 @@ def process_grouped_roi_responses(
     validate_response_processing_options(options, data_rate_hz=grouped.data_rate_hz)
     validate_grouped_roi_responses(grouped)
     processed = _copy_grouped_with_processed_values(grouped, options=options)
-    processed, normalization_factors = normalize_grouped_roi_responses_by_epoch_peak(
-        processed,
-        options=options.normalization,
+    processed, normalization_factors = (
+        normalize_grouped_roi_responses_by_epoch_abs_peak(
+            processed,
+            options=options.normalization,
+        )
     )
     processed, correlation_scores = apply_correlation_filter_to_grouped_roi_responses(
         processed,
@@ -166,12 +168,12 @@ def process_grouped_roi_responses(
     )
 
 
-def normalize_grouped_roi_responses_by_epoch_peak(
+def normalize_grouped_roi_responses_by_epoch_abs_peak(
     grouped: GroupedRoiResponses,
     *,
     options: NormalizationOptions,
 ) -> tuple[GroupedRoiResponses, RoiNormalizationFactors | None]:
-    """Normalize grouped responses by each ROI's selected-epoch peak.
+    """Scale each ROI by its strongest average response in the selected epoch.
 
     Args:
         grouped: Grouped ROI responses to normalize.
@@ -182,17 +184,17 @@ def normalize_grouped_roi_responses_by_epoch_peak(
         normalization is disabled.
 
     Raises:
-        ValueError: If the selected epoch is absent or any ROI lacks a positive
-        finite peak in that epoch.
+        ValueError: If the selected epoch is absent or any ROI lacks a finite
+        nonzero response in that epoch.
     """
     validate_grouped_roi_responses(grouped)
-    if options.method not in {"none", "epoch_peak"}:
+    if options.method not in {"none", "epoch_abs_peak"}:
         msg = f"Unknown normalization method {options.method!r}"
         raise ValueError(msg)
     if options.method == "none":
         return grouped, None
     if options.epoch_number is None:
-        msg = "epoch-peak normalization requires an epoch_number"
+        msg = "response-size normalization requires an epoch_number"
         raise ValueError(msg)
     factors = _normalization_factors(grouped, options=options)
     trials = tuple(
@@ -336,7 +338,7 @@ def _normalization_factors(
     *,
     options: NormalizationOptions,
 ) -> RoiNormalizationFactors:
-    """Return per-ROI selected-epoch peak factors."""
+    """Return each ROI's selected-epoch response size."""
     selected_trials = tuple(
         trial
         for trial in grouped.trials
@@ -356,7 +358,7 @@ def _normalization_factors(
         roi_labels=grouped.roi_labels,
         data_rate_hz=grouped.data_rate_hz,
     )
-    factors = np.nanmax(summary.mean_values, axis=1)
+    factors = np.nanmax(np.abs(summary.mean_values), axis=1)
     bad_indices = tuple(
         index
         for index, factor in enumerate(factors)
@@ -365,7 +367,7 @@ def _normalization_factors(
     if len(bad_indices) > 0:
         bad_labels = ", ".join(grouped.roi_labels[index] for index in bad_indices)
         msg = (
-            "Normalization epoch peak must be positive for every ROI; "
+            "Normalization epoch must have a nonzero response for every ROI; "
             f"invalid ROI labels: {bad_labels}"
         )
         raise ValueError(msg)

{twopy-0.3.1 → twopy-0.3.3}/src/twopy/analysis/response_processing/options.py

@@ -28,7 +28,7 @@ __all__ = [
 
 SmoothingMethod = Literal["none", "moving_average", "savgol"]
 LowPassFilterMethod = Literal["none", "butterworth"]
-NormalizationMethod = Literal["none", "epoch_peak"]
+NormalizationMethod = Literal["none", "epoch_abs_peak"]
 CorrelationFilterReference = Literal["none", "epoch_mean", "epoch_peak"]
 CorrelationWindowSeconds = tuple[float | None, float | None]
 
@@ -70,15 +70,16 @@ class LowPassFilterOptions:
 
 @dataclass(frozen=True)
 class NormalizationOptions:
-    """Epoch-peak normalization settings for grouped ROI responses.
+    """Settings for scaling grouped ROI responses by one selected epoch.
 
     Inputs: a normalization method and the stimulus epoch used as the scale
     reference.
     Outputs: normalization values applied after trial grouping.
 
-    ``method="none"`` leaves grouped responses unchanged. ``method="epoch_peak"``
-    divides every response for each ROI by that ROI's mean-response peak in the
-    selected epoch, so the selected epoch's plotted peak becomes one.
+    ``method="none"`` leaves grouped responses unchanged.
+    ``method="epoch_abs_peak"`` divides every response for each ROI by that
+    ROI's strongest average response in the selected epoch, whether positive or
+    negative.
     """
 
     method: NormalizationMethod = "none"
@@ -111,8 +112,8 @@ class CorrelationFilterOptions:
 class ResponseProcessingOptions:
     """Complete response post-processing configuration.
 
-    Inputs: optional smoothing, low-pass filtering, epoch-peak normalization,
-    and correlation QC settings.
+    Inputs: optional smoothing, low-pass filtering, response-size
+    normalization, and correlation QC settings.
     Outputs: one immutable object used by workflow, plotting, and saved analysis
     metadata.
     """
@@ -210,15 +211,15 @@ def _validate_low_pass_options(
 
 
 def _validate_normalization_options(options: NormalizationOptions) -> None:
-    """Validate epoch-peak normalization options."""
-    if options.method not in {"none", "epoch_peak"}:
+    """Validate response-size normalization options."""
+    if options.method not in {"none", "epoch_abs_peak"}:
         msg = f"Unknown normalization method {options.method!r}"
         raise ValueError(msg)
     if options.epoch_number is not None and options.epoch_number < 1:
         msg = f"normalization epoch_number must be positive; got {options.epoch_number}"
         raise ValueError(msg)
-    if options.method == "epoch_peak" and options.epoch_number is None:
-        msg = "epoch-peak normalization requires an epoch_number"
+    if options.method == "epoch_abs_peak" and options.epoch_number is None:
+        msg = "response-size normalization requires an epoch_number"
         raise ValueError(msg)
 
 

{twopy-0.3.1 → twopy-0.3.3}/src/twopy/analysis/response_processing/persistence.py

@@ -51,7 +51,7 @@ _SMOOTHING_METHODS: tuple[SmoothingMethod, ...] = (
     "savgol",
 )
 _LOW_PASS_METHODS: tuple[LowPassFilterMethod, ...] = ("none", "butterworth")
-_NORMALIZATION_METHODS: tuple[NormalizationMethod, ...] = ("none", "epoch_peak")
+_NORMALIZATION_METHODS: tuple[NormalizationMethod, ...] = ("none", "epoch_abs_peak")
 _CORRELATION_REFERENCES: tuple[CorrelationFilterReference, ...] = (
     "none",
     "epoch_mean",
@@ -64,13 +64,14 @@ class PersistedResponseProcessing:
     """Response-processing audit data loaded from HDF5.
 
     Inputs: one ``response_processing`` HDF5 group.
-    Outputs: typed options plus optional normalization factors and ROI
-    correlation scores.
+    Outputs: typed options plus optional factors, ROI correlation scores, and a
+        warning when an old file uses a setting twopy no longer uses.
     """
 
     options: ResponseProcessingOptions
     normalization_factors: RoiNormalizationFactors | None
     correlation_scores: RoiCorrelationScores | None
+    load_warning: str | None = None
 
 
 def write_response_processing_group(
@@ -86,7 +87,7 @@ def write_response_processing_group(
         group: Destination ``response_processing`` HDF5 group.
         options: Processing options used for the saved analysis output.
         normalization_factors: Optional per-ROI normalization factors used for
-            epoch-peak normalization.
+            response-size normalization.
         correlation_scores: Optional ROI-level correlation QC result.
 
     Returns:
@@ -159,14 +160,17 @@ def read_response_processing_group(group: h5py.Group) -> PersistedResponseProces
     Returns:
         Typed processing options plus optional correlation scores.
     """
+    normalization_options, normalization_load_warning = (
+        _read_normalization_options(
+            group["normalization"],
+        )
+        if "normalization" in group
+        else (NormalizationOptions(), None)
+    )
     options = ResponseProcessingOptions(
         smoothing=_read_smoothing_options(group["smoothing"]),
         low_pass=_read_low_pass_options(group["low_pass"]),
-        normalization=(
-            _read_normalization_options(group["normalization"])
-            if "normalization" in group
-            else NormalizationOptions()
-        ),
+        normalization=normalization_options,
         correlation_filter=_read_correlation_filter_options(
             group["correlation_filter"],
         ),
@@ -178,7 +182,11 @@ def read_response_processing_group(group: h5py.Group) -> PersistedResponseProces
                 group["normalization"],
                 options=options.normalization,
             )
-            if "normalization" in group and "factors" in group["normalization"]
+            if (
+                "normalization" in group
+                and "factors" in group["normalization"]
+                and options.normalization.method != "none"
+            )
             else None
         ),
         correlation_scores=(
@@ -186,6 +194,7 @@ def read_response_processing_group(group: h5py.Group) -> PersistedResponseProces
             if "correlation_scores" in group
             else None
         ),
+        load_warning=normalization_load_warning,
     )
 
 
@@ -215,16 +224,35 @@ def _read_low_pass_options(group: h5py.Group) -> LowPassFilterOptions:
     )
 
 
-def _read_normalization_options(group: h5py.Group) -> NormalizationOptions:
-    """Read normalization settings from one HDF5 group."""
-    return NormalizationOptions(
-        method=require_string_choice(
-            plain_hdf5_attr_value(group.attrs["method"], scalar_only=True),
-            name="response_processing normalization method",
-            allowed=_NORMALIZATION_METHODS,
+def _read_normalization_options(
+    group: h5py.Group,
+) -> tuple[NormalizationOptions, str | None]:
+    """Read normalization settings and report old settings twopy no longer uses."""
+    raw_method = plain_hdf5_attr_value(group.attrs["method"], scalar_only=True)
+    if raw_method == "epoch_peak":
+        return (
+            NormalizationOptions(
+                method="none",
+                epoch_number=_optional_int_from_attr(group.attrs["epoch_number"]),
+                epoch_name=_optional_text_from_attr(group.attrs["epoch_name"]),
+            ),
+            (
+                "This saved analysis used old positive-peak normalization. "
+                "Twopy is showing the saved responses as stored. Recompute to use "
+                "strongest-response normalization."
+            ),
+        )
+    return (
+        NormalizationOptions(
+            method=require_string_choice(
+                raw_method,
+                name="response_processing normalization method",
+                allowed=_NORMALIZATION_METHODS,
+            ),
+            epoch_number=_optional_int_from_attr(group.attrs["epoch_number"]),
+            epoch_name=_optional_text_from_attr(group.attrs["epoch_name"]),
         ),
-        epoch_number=_optional_int_from_attr(group.attrs["epoch_number"]),
-        epoch_name=_optional_text_from_attr(group.attrs["epoch_name"]),
+        None,
     )
 
 
@@ -246,7 +274,7 @@ def _read_normalization_factors(
     *,
     options: NormalizationOptions,
 ) -> RoiNormalizationFactors:
-    """Read persisted epoch-peak normalization factors."""
+    """Read persisted response-size normalization factors."""
     return RoiNormalizationFactors(
         roi_labels=_read_string_dataset(group, "roi_labels"),
         factors=require_float64_array(

{twopy-0.3.1 → twopy-0.3.3}/src/twopy/analysis/workflow.py

@@ -33,7 +33,7 @@ from twopy.analysis.response_processing import (
     RoiCorrelationScores,
     RoiNormalizationFactors,
     apply_correlation_filter_to_grouped_roi_responses,
-    normalize_grouped_roi_responses_by_epoch_peak,
+    normalize_grouped_roi_responses_by_epoch_abs_peak,
     process_roi_delta_f_over_f,
 )
 from twopy.analysis.response_window_options import (
@@ -561,7 +561,7 @@ def _compute_recording_responses_from_baseline(
     )
     _check_cancelled(check_cancelled)
     grouped_responses, normalization_factors = (
-        normalize_grouped_roi_responses_by_epoch_peak(
+        normalize_grouped_roi_responses_by_epoch_abs_peak(
             grouped_responses,
             options=processing_options.normalization,
         )