essreduce 25.11.1__py3-none-any.whl → 25.11.3__py3-none-any.whl

ess/reduce/__init__.py

@@ -4,7 +4,7 @@
 
 import importlib.metadata
 
-from . import nexus, time_of_flight, uncertainty
+from . import nexus, normalization, time_of_flight, uncertainty
 
 try:
     __version__ = importlib.metadata.version("essreduce")
@@ -13,4 +13,4 @@ except importlib.metadata.PackageNotFoundError:
 
 del importlib
 
-__all__ = ["nexus", "time_of_flight", "uncertainty"]
+__all__ = ["nexus", "normalization", "time_of_flight", "uncertainty"]

ess/reduce/nexus/__init__.py

@@ -20,6 +20,7 @@ from ._nexus_loader import (
     load_all_components,
     load_component,
     load_data,
+    load_from_path,
     open_component_group,
     open_nexus_file,
 )
@@ -33,6 +34,7 @@ __all__ = [
     'load_all_components',
     'load_component',
     'load_data',
+    'load_from_path',
     'open_component_group',
     'open_nexus_file',
     'types',

ess/reduce/nexus/_nexus_loader.py

@@ -8,7 +8,7 @@ from collections.abc import Generator, Mapping
 from contextlib import AbstractContextManager, contextmanager, nullcontext
 from dataclasses import dataclass
 from math import prod
-from typing import TypeVar, cast
+from typing import Any, TypeVar, cast
 
 import scipp as sc
 import scippnexus as snx
@@ -42,6 +42,31 @@ class NoLockingIfNeededType:
 NoLockingIfNeeded = NoLockingIfNeededType()
 
 
+def load_from_path(
+    location: NeXusLocationSpec,
+    definitions: Mapping | NoNewDefinitionsType = NoNewDefinitions,
+) -> Any:
+    """Load a field or group from a NeXus file given its location.
+
+    Parameters
+    ----------
+    location:
+        Location of the field within the NeXus file (filename, entry name, selection).
+    definitions:
+        Application definitions to use for the file.
+
+    Returns
+    -------
+    :
+        The loaded field (as a variable, data array, or raw python object) or group
+        (as a data group).
+    """
+    with open_nexus_file(location.filename, definitions=definitions) as f:
+        entry = _unique_child_group(f, snx.NXentry, location.entry_name)
+        item = entry[location.component_name]
+        return item[location.selection]
+
+
 def load_component(
     location: NeXusLocationSpec,
     *,

ess/reduce/nexus/workflow.py

@@ -691,16 +691,12 @@ def LoadMonitorWorkflow(
 
 
 def LoadDetectorWorkflow(
-    *,
-    run_types: Iterable[sciline.typing.Key],
-    monitor_types: Iterable[sciline.typing.Key],
+    *, run_types: Iterable[sciline.typing.Key]
 ) -> sciline.Pipeline:
     """Generic workflow for loading detector data from a NeXus file."""
     wf = sciline.Pipeline(
         (*_common_providers, *_detector_providers),
-        constraints=_gather_constraints(
-            run_types=run_types, monitor_types=monitor_types
-        ),
+        constraints=_gather_constraints(run_types=run_types, monitor_types=[]),
     )
     wf[DetectorBankSizes] = DetectorBankSizes({})
     wf[PreopenNeXusFile] = PreopenNeXusFile(False)

ess/reduce/normalization.py

@@ -0,0 +1,215 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright (c) 2025 Scipp contributors (https://github.com/scipp)
+"""Normalization routines for neutron data reduction."""
+
+import functools
+
+import scipp as sc
+
+from .uncertainty import UncertaintyBroadcastMode, broadcast_uncertainties
+
+
+def normalize_by_monitor_histogram(
+    detector: sc.DataArray,
+    *,
+    monitor: sc.DataArray,
+    uncertainty_broadcast_mode: UncertaintyBroadcastMode,
+) -> sc.DataArray:
+    """Normalize detector data by a normalized histogrammed monitor.
+
+    This normalization accounts for both the (wavelength) profile of the incident beam
+    and the integrated neutron flux, meaning measurement duration and source strength.
+
+    - For *event* detectors, the monitor values are mapped to the detector
+      using :func:`scipp.lookup`. That is, for detector event :math:`d_i`,
+      :math:`m_i` is the monitor bin value at the same coordinate.
+    - For *histogram* detectors, the monitor is rebinned using to the detector
+      binning using :func:`scipp.rebin`. Thus, detector value :math:`d_i` and
+      monitor value :math:`m_i` correspond to the same bin.
+
+    In both cases, let :math:`x_i` be the lower bound of monitor bin :math:`i`
+    and let :math:`\\Delta x_i = x_{i+1} - x_i` be the width of that bin.
+
+    The detector is normalized according to
+
+    .. math::
+
+        d_i^\\text{Norm} = \\frac{d_i}{m_i} \\Delta x_i
+
+    Parameters
+    ----------
+    detector:
+        Input detector data.
+        Must have a coordinate named ``monitor.dim``, that is, the single
+        dimension name of the **monitor**.
+    monitor:
+        A histogrammed monitor.
+        Must be one-dimensional and have a dimension coordinate, typically "wavelength".
+    uncertainty_broadcast_mode:
+        Choose how uncertainties of the monitor are broadcast to the sample data.
+
+    Returns
+    -------
+    :
+        ``detector`` normalized by ``monitor``.
+        If the monitor has masks or contains non-finite values, the output has a mask
+        called '_monitor_mask' constructed from the monitor masks and non-finite values.
+
+    See also
+    --------
+    normalize_by_monitor_integrated:
+        Normalize by an integrated monitor.
+    """
+    _check_monitor_range_contains_detector(monitor=monitor, detector=detector)
+
+    dim = monitor.dim
+
+    if detector.bins is None:
+        monitor = monitor.rebin({dim: detector.coords[dim]})
+    detector = _mask_detector_for_norm(detector=detector, monitor=monitor)
+    coord = monitor.coords[dim]
+    delta_w = sc.DataArray(coord[1:] - coord[:-1], masks=monitor.masks)
+    norm = broadcast_uncertainties(
+        monitor / delta_w, prototype=detector, mode=uncertainty_broadcast_mode
+    )
+
+    if detector.bins is None:
+        return detector / norm.rebin({dim: detector.coords[dim]})
+    return detector.bins / sc.lookup(norm, dim=dim)
+
+
+def normalize_by_monitor_integrated(
+    detector: sc.DataArray,
+    *,
+    monitor: sc.DataArray,
+    uncertainty_broadcast_mode: UncertaintyBroadcastMode,
+) -> sc.DataArray:
+    """Normalize detector data by an integrated monitor.
+
+    This normalization accounts only for the integrated neutron flux,
+    meaning measurement duration and source strength.
+    It does *not* account for the (wavelength) profile of the incident beam.
+    For that, see :func:`normalize_by_monitor_histogram`.
+
+    Let :math:`d_i` be a detector event or the counts in a detector bin.
+    The normalized detector is
+
+    .. math::
+
+        d_i^\\text{Norm} = \\frac{d_i}{\\sum_j\\, m_j}
+
+    where :math:`m_j` is the monitor counts in bin :math:`j`.
+    Note that this is not a true integral but only a sum over monitor events.
+
+    The result depends on the range of the monitor but not its
+    binning within that range.
+
+    Parameters
+    ----------
+    detector:
+        Input detector data.
+    monitor:
+        A histogrammed monitor.
+        Must be one-dimensional and have a dimension coordinate, typically "wavelength".
+    uncertainty_broadcast_mode:
+        Choose how uncertainties of the monitor are broadcast to the sample data.
+
+    Returns
+    -------
+    :
+        `detector` normalized by a monitor.
+        If the monitor has masks or contains non-finite values, the output has a mask
+        called '_monitor_mask' constructed from the monitor masks and non-finite values.
+
+    See also
+    --------
+    normalize_by_monitor_histogram:
+        Normalize by a monitor histogram.
+    """
+    _check_monitor_range_contains_detector(monitor=monitor, detector=detector)
+    detector = _mask_detector_for_norm(detector=detector, monitor=monitor)
+    norm = monitor.nansum().data
+    norm = broadcast_uncertainties(
+        norm, prototype=detector, mode=uncertainty_broadcast_mode
+    )
+    return detector / norm
+
+
+def _check_monitor_range_contains_detector(
+    *, monitor: sc.DataArray, detector: sc.DataArray
+) -> None:
+    dim = monitor.dim
+    if not monitor.coords.is_edges(dim):
+        raise sc.CoordError(
+            f"Monitor coordinate '{dim}' must be bin-edges to integrate the monitor."
+        )
+
+    # Prefer a bin coord over an event coord because this makes the behavior for binned
+    # and histogrammed data consistent. If we used an event coord, we might allow a
+    # monitor range that is less than the detector bins which is fine for the events,
+    # but would be wrong if the detector was subsequently histogrammed.
+    if (det_coord := detector.coords.get(dim)) is not None:
+        lo = det_coord[dim, :-1].nanmin()
+        hi = det_coord[dim, 1:].nanmax()
+    elif (det_coord := detector.bins.coords.get(dim)) is not None:
+        lo = det_coord.nanmin()
+        hi = det_coord.nanmax()
+    else:
+        raise sc.CoordError(
+            f"Missing '{dim}' coordinate in detector for monitor normalization."
+        )
+
+    if monitor.coords[dim].min() > lo or monitor.coords[dim].max() < hi:
+        raise ValueError(
+            f"Cannot normalize by monitor: The {dim} range of the monitor "
+            f"({monitor.coords[dim].min():c} to {monitor.coords[dim].max():c}) "
+            f"is smaller than the range of the detector ({lo:c} to {hi:c})."
+        )
+
+
+def _mask_detector_for_norm(
+    *, detector: sc.DataArray, monitor: sc.DataArray
+) -> sc.DataArray:
+    """Mask the detector where the monitor is masked.
+
+    For performance, this applies the monitor mask to the detector bins.
+    This can lead to masking more events than strictly necessary if we
+    used an event mask.
+    """
+    dim = monitor.dim
+
+    if (monitor_mask := _monitor_mask(monitor)) is None:
+        return detector
+
+    if (detector_coord := detector.coords.get(monitor.dim)) is not None:
+        # Apply the mask to the bins or a dense detector.
+        # Use rebin to reshape the mask to the detector.
+        mask = sc.DataArray(monitor_mask, coords={dim: monitor.coords[dim]}).rebin(
+            {dim: detector_coord}
+        ).data != sc.scalar(0, unit=None)
+        return detector.assign_masks({"_monitor_mask": mask})
+
+    # else: Apply the mask to the events.
+    if dim not in detector.bins.coords:
+        raise sc.CoordError(
+            f"Detector must have coordinate '{dim}' to mask by monitor."
+        )
+    event_mask = sc.lookup(
+        sc.DataArray(monitor_mask, coords={dim: monitor.coords[dim]})
+    )[detector.bins.coords[dim]]
+    return detector.bins.assign_masks({"_monitor_mask": event_mask})
+
+
+def _monitor_mask(monitor: sc.DataArray) -> sc.Variable | None:
+    """Mask nonfinite and zero monitor values and combine all masks."""
+    masks = list(monitor.masks.values())
+
+    finite = sc.isfinite(monitor.data)
+    nonzero = monitor.data != sc.scalar(0, unit=monitor.unit)
+    valid = finite & nonzero
+    if not valid.all():
+        masks.append(~valid)
+
+    if not masks:
+        return None
+    return functools.reduce(sc.logical_or, masks)

ess/reduce/time_of_flight/__init__.py

@@ -28,6 +28,7 @@ from .types import (
     PulseStrideOffset,
     TimeOfFlightLookupTable,
     TimeOfFlightLookupTableFilename,
+    ToaDetector,
     TofDetector,
     TofMonitor,
 )
@@ -51,6 +52,7 @@ __all__ = [
     "TimeOfFlightLookupTable",
     "TimeOfFlightLookupTableFilename",
     "TimeResolution",
+    "ToaDetector",
     "TofDetector",
     "TofLookupTableWorkflow",
     "TofMonitor",

ess/reduce/time_of_flight/eto_to_tof.py

@@ -36,6 +36,7 @@ from .types import (
     MonitorLtotal,
     PulseStrideOffset,
     TimeOfFlightLookupTable,
+    ToaDetector,
     TofDetector,
     TofMonitor,
 )
@@ -196,12 +197,32 @@ def _guess_pulse_stride_offset(
     return sorted(tofs, key=lambda x: sc.isnan(tofs[x]).sum())[0]
 
 
-def _time_of_flight_data_events(
+def _prepare_tof_interpolation_inputs(
     da: sc.DataArray,
     lookup: sc.DataArray,
     ltotal: sc.Variable,
-    pulse_stride_offset: int,
-) -> sc.DataArray:
+    pulse_stride_offset: int | None,
+) -> dict:
+    """
+    Prepare the inputs required for the time-of-flight interpolation.
+    This function is used when computing the time-of-flight for event data, and for
+    computing the time-of-arrival for event data (as they both require guessing the
+    pulse_stride_offset if not provided).
+
+    Parameters
+    ----------
+    da:
+        Data array with event data.
+    lookup:
+        Lookup table giving time-of-flight as a function of distance and time of
+        arrival.
+    ltotal:
+        Total length of the flight path from the source to the detector.
+    pulse_stride_offset:
+        When pulse-skipping, the offset of the first pulse in the stride. This is
+        typically zero but can be a small integer < pulse_stride.
+        If None, a guess is made.
+    """
     etos = da.bins.coords["event_time_offset"].to(dtype=float, copy=False)
     eto_unit = elem_unit(etos)
 
@@ -259,12 +280,34 @@ def _time_of_flight_data_events(
         pulse_index += pulse_stride_offset
         pulse_index %= pulse_stride
 
-    # Compute time-of-flight for all neutrons using the interpolator
-    tofs = interp(
+    return {
+        "eto": etos,
+        "pulse_index": pulse_index,
+        "pulse_period": pulse_period,
+        "interp": interp,
+        "ltotal": ltotal,
+    }
+
+
+def _time_of_flight_data_events(
+    da: sc.DataArray,
+    lookup: sc.DataArray,
+    ltotal: sc.Variable,
+    pulse_stride_offset: int | None,
+) -> sc.DataArray:
+    inputs = _prepare_tof_interpolation_inputs(
+        da=da,
+        lookup=lookup,
         ltotal=ltotal,
-        event_time_offset=etos,
-        pulse_index=pulse_index,
-        pulse_period=pulse_period,
+        pulse_stride_offset=pulse_stride_offset,
+    )
+
+    # Compute time-of-flight for all neutrons using the interpolator
+    tofs = inputs["interp"](
+        ltotal=inputs["ltotal"],
+        event_time_offset=inputs["eto"],
+        pulse_index=inputs["pulse_index"],
+        pulse_period=inputs["pulse_period"],
     )
 
     parts = da.bins.constituents
@@ -416,6 +459,53 @@ def monitor_time_of_flight_data(
     )
 
 
+def detector_time_of_arrival_data(
+    detector_data: RawDetector[RunType],
+    lookup: TimeOfFlightLookupTable,
+    ltotal: DetectorLtotal[RunType],
+    pulse_stride_offset: PulseStrideOffset,
+) -> ToaDetector[RunType]:
+    """
+    Convert the time-of-flight data to time-of-arrival data using a lookup table.
+    The output data will have a time-of-arrival coordinate.
+    The time-of-arrival is the time since the neutron was emitted from the source.
+    It is basically equal to event_time_offset + pulse_index * pulse_period.
+
+    Parameters
+    ----------
+    da:
+        Raw detector data loaded from a NeXus file, e.g., NXdetector containing
+        NXevent_data.
+    lookup:
+        Lookup table giving time-of-flight as a function of distance and time of
+        arrival.
+    ltotal:
+        Total length of the flight path from the source to the detector.
+    pulse_stride_offset:
+        When pulse-skipping, the offset of the first pulse in the stride. This is
+        typically zero but can be a small integer < pulse_stride.
+    """
+    if detector_data.bins is None:
+        raise NotImplementedError(
+            "Computing time-of-arrival in histogram mode is not implemented yet."
+        )
+    inputs = _prepare_tof_interpolation_inputs(
+        da=detector_data,
+        lookup=lookup,
+        ltotal=ltotal,
+        pulse_stride_offset=pulse_stride_offset,
+    )
+    parts = detector_data.bins.constituents
+    parts["data"] = inputs["eto"]
+    # The pulse index is None if pulse_stride == 1 (i.e., no pulse skipping)
+    if inputs["pulse_index"] is not None:
+        parts["data"] = parts["data"] + inputs["pulse_index"] * inputs["pulse_period"]
+    result = detector_data.bins.assign_coords(
+        toa=sc.bins(**parts, validate_indices=False)
+    )
+    return result
+
+
 def providers() -> tuple[Callable]:
     """
     Providers of the time-of-flight workflow.
@@ -425,4 +515,5 @@ def providers() -> tuple[Callable]:
         monitor_time_of_flight_data,
         detector_ltotal_from_straight_line_approximation,
         monitor_ltotal_from_straight_line_approximation,
+        detector_time_of_arrival_data,
     )

ess/reduce/time_of_flight/fakes.py

@@ -56,7 +56,7 @@ class FakeBeamline:
                 else tof_pkg.Clockwise,
                 open=ch.slit_begin,
                 close=ch.slit_end,
-                phase=abs(ch.phase),
+                phase=ch.phase if ch.frequency.value > 0.0 else -ch.phase,
                 distance=sc.norm(ch.axle_position - source_position),
                 name=name,
             )

ess/reduce/time_of_flight/lut.py

@@ -420,7 +420,7 @@ def simulate_chopper_cascade_using_tof(
             else tof.Clockwise,
             open=ch.slit_begin,
             close=ch.slit_end,
-            phase=abs(ch.phase),
+            phase=ch.phase if ch.frequency.value > 0.0 else -ch.phase,
             distance=sc.norm(
                 ch.axle_position - source_position.to(unit=ch.axle_position.unit)
             ),

ess/reduce/time_of_flight/types.py

@@ -37,5 +37,17 @@ class TofDetector(sl.Scope[RunType, sc.DataArray], sc.DataArray):
     """Detector data with time-of-flight coordinate."""
 
 
+class ToaDetector(sl.Scope[RunType, sc.DataArray], sc.DataArray):
+    """Detector data with time-of-arrival coordinate.
+
+    When the pulse stride is 1 (i.e., no pulse skipping), the time-of-arrival is the
+    same as the event_time_offset. When pulse skipping is used, the time-of-arrival is
+    the event_time_offset + pulse_offset * pulse_period.
+    This means that the time-of-arrival is basically the event_time_offset wrapped
+    over the frame period instead of the pulse period
+    (where frame_period = pulse_stride * pulse_period).
+    """
+
+
 class TofMonitor(sl.Scope[RunType, MonitorType, sc.DataArray], sc.DataArray):
     """Monitor data with time-of-flight coordinate."""

{essreduce-25.11.1.dist-info → essreduce-25.11.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: essreduce
-Version: 25.11.1
+Version: 25.11.3
 Summary: Common data reduction tools for the ESS facility
 Author: Scipp contributors
 License-Expression: BSD-3-Clause

{essreduce-25.11.1.dist-info → essreduce-25.11.3.dist-info}/RECORD

@@ -1,5 +1,6 @@
-ess/reduce/__init__.py,sha256=o1pWRP9YGwTukM_k-qlG6KcoXOpMb0PDVH59vod12lw,419
+ess/reduce/__init__.py,sha256=9iqQ57K3stwyujDzOk30hj7WqZt1Ycnb9AVDDDmk3K0,451
 ess/reduce/logging.py,sha256=6n8Czq4LZ3OK9ENlKsWSI1M3KvKv6_HSoUiV4__IUlU,357
+ess/reduce/normalization.py,sha256=B4O5W3CV_ti-zeU7tyQEAXk5pCUebZ0BG30YN2I3TyY,7844
 ess/reduce/parameter.py,sha256=4sCfoKOI2HuO_Q7JLH_jAXnEOFANSn5P3NdaOBzhJxc,4635
 ess/reduce/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ess/reduce/streaming.py,sha256=zbqxQz5dASDq4ZVyx-TdbapBXMyBttImCYz_6WOj4pg,17978
@@ -12,21 +13,21 @@ ess/reduce/live/__init__.py,sha256=jPQVhihRVNtEDrE20PoKkclKV2aBF1lS7cCHootgFgI,2
 ess/reduce/live/raw.py,sha256=d86s5fBjdf6tI_FWNMG4ZG67GCY2JADOobrinncNIjE,24367
 ess/reduce/live/roi.py,sha256=Hs-pW98k41WU6Kl3UQ41kQawk80c2QNOQ_WNctLzDPE,3795
 ess/reduce/live/workflow.py,sha256=bsbwvTqPhRO6mC__3b7MgU7DWwAnOvGvG-t2n22EKq8,4285
-ess/reduce/nexus/__init__.py,sha256=8TLqqALxRV5_QdCwLAjq3r6xneq6rzdh2dD7d9AXkYo,1065
-ess/reduce/nexus/_nexus_loader.py,sha256=8jN97CbFaSJ6XZEFzkoeAGyol8WpLTUZsHkUWu8WHsU,23136
+ess/reduce/nexus/__init__.py,sha256=xXc982vZqRba4jR4z5hA2iim17Z7niw4KlS1aLFbn1Q,1107
+ess/reduce/nexus/_nexus_loader.py,sha256=5J26y_t-kabj0ik0jf3OLSYda3lDLDQhvPd2_ro7Q_0,23927
 ess/reduce/nexus/json_generator.py,sha256=ME2Xn8L7Oi3uHJk9ZZdCRQTRX-OV_wh9-DJn07Alplk,2529
 ess/reduce/nexus/json_nexus.py,sha256=QrVc0p424nZ5dHX9gebAJppTw6lGZq9404P_OFl1giA,10282
 ess/reduce/nexus/types.py,sha256=g5oBBEYPH7urF1tDP0tqXtixhQN8JDpe8vmiKrPiUW0,9320
-ess/reduce/nexus/workflow.py,sha256=nU_YzaRJO5yUGNIHVPScJF_oEddZxaA2gChPF9mMhDQ,25031
+ess/reduce/nexus/workflow.py,sha256=KRzG_flkAGNCkwDGwhTjX3h3Hi4GexMEz84trMw7HIg,24944
 ess/reduce/scripts/grow_nexus.py,sha256=hET3h06M0xlJd62E3palNLFvJMyNax2kK4XyJcOhl-I,3387
-ess/reduce/time_of_flight/__init__.py,sha256=Av6Pu_AKO0tF8IsWXchUXjjHps7ts2NFVnui6k3Eq-o,1425
-ess/reduce/time_of_flight/eto_to_tof.py,sha256=aPPQYbbz_73eq5dQCS97q02D2UUFntOfow2lWkkRyxg,14993
-ess/reduce/time_of_flight/fakes.py,sha256=0gtbSX3ZQilaM4ZP5dMr3fqbnhpyoVsZX2YEb8GgREE,4489
+ess/reduce/time_of_flight/__init__.py,sha256=jn8x9rZ6PzyP_wK8ACd3cg9rOpDAu_IqHyTNSeKfVn0,1461
+ess/reduce/time_of_flight/eto_to_tof.py,sha256=NN-UeVuFVg_WIe6ePAxN7HSxFxd-1BCrdasFB5WEfHw,18166
+ess/reduce/time_of_flight/fakes.py,sha256=4viK0OsmwEHSc5bDqSNN0jdo982D-oO4phdLC6vZLng,4527
 ess/reduce/time_of_flight/interpolator_numba.py,sha256=wh2YS3j2rOu30v1Ok3xNHcwS7t8eEtZyZvbfXOCtgrQ,3835
 ess/reduce/time_of_flight/interpolator_scipy.py,sha256=_InoAPuMm2qhJKZQBAHOGRFqtvvuQ8TStoN7j_YgS4M,1853
-ess/reduce/time_of_flight/lut.py,sha256=bNf3EmMw86pp3lB499zvKEkCkcDlqS2eHFvyVX4bCBk,18750
+ess/reduce/time_of_flight/lut.py,sha256=k8_aLQSK4kwvpOIOJgUs8J0DgromMieiKYSl7PTBC18,18788
 ess/reduce/time_of_flight/resample.py,sha256=Opmi-JA4zNH725l9VB99U4O9UlM37f5ACTCGtwBcows,3718
-ess/reduce/time_of_flight/types.py,sha256=VhJYLcLA_NfU-lILFNxjBkQUaC8AeNr_DJMeQuNgZOc,1302
+ess/reduce/time_of_flight/types.py,sha256=xq-CjRZIzcfknqeNcUXMIZxvfK9eYmAJtXv-i4sJamE,1855
 ess/reduce/time_of_flight/workflow.py,sha256=mkgESvQ5Yt3CyAsa1iewkjBOHUqrHm5rRc1EhOQRewQ,2213
 ess/reduce/widgets/__init__.py,sha256=SoSHBv8Dc3QXV9HUvPhjSYWMwKTGYZLpsWwsShIO97Q,5325
 ess/reduce/widgets/_base.py,sha256=_wN3FOlXgx_u0c-A_3yyoIH-SdUvDENGgquh9S-h5GI,4852
@@ -40,9 +41,9 @@ ess/reduce/widgets/_spinner.py,sha256=2VY4Fhfa7HMXox2O7UbofcdKsYG-AJGrsgGJB85nDX
 ess/reduce/widgets/_string_widget.py,sha256=iPAdfANyXHf-nkfhgkyH6gQDklia0LebLTmwi3m-iYQ,1482
 ess/reduce/widgets/_switchable_widget.py,sha256=fjKz99SKLhIF1BLgGVBSKKn3Lu_jYBwDYGeAjbJY3Q8,2390
 ess/reduce/widgets/_vector_widget.py,sha256=aTaBqCFHZQhrIoX6-sSqFWCPePEW8HQt5kUio8jP1t8,1203
-essreduce-25.11.1.dist-info/licenses/LICENSE,sha256=nVEiume4Qj6jMYfSRjHTM2jtJ4FGu0g-5Sdh7osfEYw,1553
-essreduce-25.11.1.dist-info/METADATA,sha256=YJBtrUy0Gw60xZHi0TrmkBhC4XroNNC_CIEL0qRD5z8,1937
-essreduce-25.11.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-essreduce-25.11.1.dist-info/entry_points.txt,sha256=PMZOIYzCifHMTe4pK3HbhxUwxjFaZizYlLD0td4Isb0,66
-essreduce-25.11.1.dist-info/top_level.txt,sha256=0JxTCgMKPLKtp14wb1-RKisQPQWX7i96innZNvHBr-s,4
-essreduce-25.11.1.dist-info/RECORD,,
+essreduce-25.11.3.dist-info/licenses/LICENSE,sha256=nVEiume4Qj6jMYfSRjHTM2jtJ4FGu0g-5Sdh7osfEYw,1553
+essreduce-25.11.3.dist-info/METADATA,sha256=RG8gLrZiQjprpTwz70dd-300cLF2jZeOEIigmwWFBOY,1937
+essreduce-25.11.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+essreduce-25.11.3.dist-info/entry_points.txt,sha256=PMZOIYzCifHMTe4pK3HbhxUwxjFaZizYlLD0td4Isb0,66
+essreduce-25.11.3.dist-info/top_level.txt,sha256=0JxTCgMKPLKtp14wb1-RKisQPQWX7i96innZNvHBr-s,4
+essreduce-25.11.3.dist-info/RECORD,,