essreduce 25.2.4__tar.gz → 25.2.5__tar.gz

{essreduce-25.2.4/src/essreduce.egg-info → essreduce-25.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: essreduce
-Version: 25.2.4
+Version: 25.2.5
 Summary: Common data reduction tools for the ESS facility
 Author: Scipp contributors
 License: BSD 3-Clause License

{essreduce-25.2.4 → essreduce-25.2.5}/src/ess/reduce/nexus/_nexus_loader.py

@@ -180,10 +180,15 @@ def _attempt_to_open_without_locking(
     # HDF5 tracks file locking flags internally within a single process.
     # If the same file is opened multiple times, we can get a flag mismatch.
     # We can try opening without locking, maybe this matches the original flags.
-    if "file locking flag values don't match" in err.args[0]:
-        return True
-    if "file locking 'ignore disabled locks' flag values don't match" in err.args[0]:
-        return True
+    error_message = err.args[0]
+    if isinstance(error_message, str):
+        if "file locking flag values don't match" in error_message:
+            return True
+        if (
+            "file locking 'ignore disabled locks' flag values don't match"
+            in error_message
+        ):
+            return True
     return False
 
 

{essreduce-25.2.4 → essreduce-25.2.5}/src/ess/reduce/streaming.py

@@ -68,7 +68,18 @@ class Accumulator(ABC, Generic[T]):
     def _do_push(self, value: T) -> None: ...
 
     @property
-    @abstractmethod
+    def is_empty(self) -> bool:
+        """
+        Check if the accumulator is empty.
+
+        Returns
+        -------
+        :
+            True if the accumulator is empty, False otherwise.
+        """
+        return False
+
+    @property
     def value(self) -> T:
         """
         Get the accumulated value.
@@ -77,6 +88,24 @@ class Accumulator(ABC, Generic[T]):
         -------
         :
             Accumulated value.
+
+        Raises
+        ------
+        ValueError
+            If the accumulator is empty.
+        """
+        if self.is_empty:
+            raise ValueError("Cannot get value from empty accumulator")
+        return self._get_value()
+
+    @abstractmethod
+    def _get_value(self) -> T:
+        """Return the accumulated value, assuming it exists."""
+
+    @abstractmethod
+    def clear(self) -> None:
+        """
+        Clear the accumulator, resetting it to its initial state.
         """
 
 
@@ -92,7 +121,10 @@ class EternalAccumulator(Accumulator[T]):
         self._value: T | None = None
 
     @property
-    def value(self) -> T:
+    def is_empty(self) -> bool:
+        return self._value is None
+
+    def _get_value(self) -> T:
         return deepcopy(self._value)
 
     def _do_push(self, value: T) -> None:
@@ -101,6 +133,10 @@ class EternalAccumulator(Accumulator[T]):
         else:
             self._value += value
 
+    def clear(self) -> None:
+        """Clear the accumulated value."""
+        self._value = None
+
 
 class RollingAccumulator(Accumulator[T]):
     """
@@ -121,7 +157,10 @@ class RollingAccumulator(Accumulator[T]):
         self._values: list[T] = []
 
     @property
-    def value(self) -> T:
+    def is_empty(self) -> bool:
+        return len(self._values) == 0
+
+    def _get_value(self) -> T:
         # Naive and potentially slow implementation if values and/or window are large!
         return sc.reduce(self._values).sum()
 
@@ -130,6 +169,10 @@ class RollingAccumulator(Accumulator[T]):
         if len(self._values) > self._window:
             self._values.pop(0)
 
+    def clear(self) -> None:
+        """Clear the accumulated values."""
+        self._values = []
+
 
 class StreamProcessor:
     """
@@ -299,6 +342,16 @@ class StreamProcessor:
             self._finalize_workflow[key] = self._accumulators[key].value
         return self._finalize_workflow.compute(self._target_keys)
 
+    def clear(self) -> None:
+        """
+        Clear all accumulators, resetting them to their initial state.
+
+        This is useful for restarting a streaming computation without
+        creating a new StreamProcessor instance.
+        """
+        for accumulator in self._accumulators.values():
+            accumulator.clear()
+
 
 def _find_descendants(
     workflow: sciline.Pipeline, keys: tuple[sciline.typing.Key, ...]

{essreduce-25.2.4 → essreduce-25.2.5/src/essreduce.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: essreduce
-Version: 25.2.4
+Version: 25.2.5
 Summary: Common data reduction tools for the ESS facility
 Author: Scipp contributors
 License: BSD 3-Clause License

{essreduce-25.2.4 → essreduce-25.2.5}/tests/nexus/nexus_loader_test.py

@@ -1,6 +1,7 @@
 # SPDX-License-Identifier: BSD-3-Clause
 # Copyright (c) 2024 Scipp contributors (https://github.com/scipp)
-
+import os
+import sys
 from contextlib import contextmanager
 from io import BytesIO
 from pathlib import Path
@@ -661,17 +662,34 @@ def test_open_nexus_file_multiple_times(tmp_path: Path, locks: tuple[Any, Any])
             assert f1.name == f2.name
 
 
+def _in_conda_env():
+    return 'CONDA_PREFIX' in os.environ
+
+
+def _test_open_nexus_file_with_mismatched_locking(
+    tmp_path: Path, locks: tuple[Any, Any]
+) -> None:
+    from ess.reduce.nexus._nexus_loader import _open_nexus_file
+
+    path = FilePath(tmp_path / "file.nxs")
+    with snx.File(path, "w"):
+        pass
+
+    with _open_nexus_file(path, locking=locks[0]):
+        with pytest.raises(OSError, match="flag values don't match"):
+            _ = _open_nexus_file(path, locking=locks[1])
+
+
+@pytest.mark.skipif(
+    sys.platform in ("darwin", "win32")
+    or (sys.platform == "linux" and _in_conda_env()),
+    reason="HDF5 has different file locking flags on MacOS, Windows and Linux(conda)",
+)
 @pytest.mark.parametrize(
     "locks",
     [
-        (True, False),
         (True, None),
-        (False, True),
-        (False, None),
         (None, True),
-        (None, False),
-        # On a read-only filesystem, this would work:
-        (NoLockingIfNeeded, False),
         # This could be supported, but it could cause problems because the first
         # user expects the file to be locked.
         (True, NoLockingIfNeeded),
@@ -679,15 +697,31 @@ def test_open_nexus_file_multiple_times(tmp_path: Path, locks: tuple[Any, Any])
         (NoLockingIfNeeded, True),
     ],
 )
-def test_open_nexus_file_with_mismatched_locking(
+def test_open_nexus_file_with_mismatched_locking_pypi_linux(
     tmp_path: Path, locks: tuple[Any, Any]
 ) -> None:
-    from ess.reduce.nexus._nexus_loader import _open_nexus_file
+    _test_open_nexus_file_with_mismatched_locking(tmp_path, locks)
 
-    path = FilePath(tmp_path / "file.nxs")
-    with snx.File(path, "w"):
-        pass
 
-    with _open_nexus_file(path, locking=locks[0]):
-        with pytest.raises(OSError, match="flag values don't match"):
-            _ = _open_nexus_file(path, locking=locks[1])
+@pytest.mark.parametrize(
+    "locks",
+    [
+        (True, False),
+        (False, True),
+        (False, None),
+        (None, False),
+        # On a read-only filesystem, this would work:
+        (NoLockingIfNeeded, False),
+    ],
+)
+def test_open_nexus_file_with_mismatched_locking_all(
+    tmp_path: Path, locks: tuple[Any, Any]
+) -> None:
+    _test_open_nexus_file_with_mismatched_locking(tmp_path, locks)
+
+
+def test_open_nonexisting_file_raises_filenotfounderror():
+    from ess.reduce.nexus._nexus_loader import _open_nexus_file
+
+    with pytest.raises(FileNotFoundError):
+        _open_nexus_file(nexus.types.FilePath(Path("doesnotexist.hdf")))

{essreduce-25.2.4 → essreduce-25.2.5}/tests/streaming_test.py

@@ -45,6 +45,18 @@ def test_eternal_accumulator_does_not_modify_pushed_values() -> None:
     assert sc.identical(var, original)
 
 
+def test_eternal_accumulator_clear() -> None:
+    accum = streaming.EternalAccumulator()
+    var = sc.linspace(dim='x', start=0, stop=1, num=10)
+    for i in range(10):
+        accum.push(var[i].copy())
+    assert sc.identical(accum.value, sc.sum(var))
+    accum.clear()
+    assert accum.is_empty
+    with pytest.raises(ValueError, match="Cannot get value from empty accumulator"):
+        _ = accum.value
+
+
 def test_rolling_accumulator_sums_over_window() -> None:
     accum = streaming.RollingAccumulator(window=3)
     var = sc.linspace(dim='x', start=0, stop=1, num=10)
@@ -94,6 +106,52 @@ def test_rolling_accumulator_does_not_modify_pushed_values() -> None:
     assert sc.identical(var, original)
 
 
+def test_rolling_accumulator_clear() -> None:
+    accum = streaming.RollingAccumulator(window=3)
+    var = sc.linspace(dim='x', start=0, stop=1, num=10)
+    for i in range(5):
+        accum.push(var[i].copy())
+    assert sc.identical(accum.value, var[2:5].sum())
+    accum.clear()
+    assert accum.is_empty
+    with pytest.raises(ValueError, match="Cannot get value from empty accumulator"):
+        _ = accum.value
+
+
+def test_eternal_accumulator_is_empty() -> None:
+    accum = streaming.EternalAccumulator()
+    assert accum.is_empty
+    with pytest.raises(ValueError, match="Cannot get value from empty accumulator"):
+        _ = accum.value
+
+    var = sc.linspace(dim='x', start=0, stop=1, num=10)
+    accum.push(var[0].copy())
+    assert not accum.is_empty
+    assert sc.identical(accum.value, var[0])
+
+    accum.clear()
+    assert accum.is_empty
+    with pytest.raises(ValueError, match="Cannot get value from empty accumulator"):
+        _ = accum.value
+
+
+def test_rolling_accumulator_is_empty() -> None:
+    accum = streaming.RollingAccumulator(window=3)
+    assert accum.is_empty
+    with pytest.raises(ValueError, match="Cannot get value from empty accumulator"):
+        _ = accum.value
+
+    var = sc.linspace(dim='x', start=0, stop=1, num=10)
+    accum.push(var[0].copy())
+    assert not accum.is_empty
+    assert sc.identical(accum.value, var[0])
+
+    accum.clear()
+    assert accum.is_empty
+    with pytest.raises(ValueError, match="Cannot get value from empty accumulator"):
+        _ = accum.value
+
+
 DynamicA = NewType('DynamicA', float)
 DynamicB = NewType('DynamicB', float)
 DynamicC = NewType('DynamicC', float)
@@ -161,9 +219,16 @@ def test_StreamProcessor_uses_custom_accumulator() -> None:
             pass
 
         @property
-        def value(self) -> sc.Variable:
+        def is_empty(self) -> bool:
+            return False
+
+        def _get_value(self) -> sc.Variable:
             return sc.scalar(42)
 
+        def clear(self) -> None:
+            # Nothing to clear
+            pass
+
     base_workflow = sciline.Pipeline(
         (make_static_a, make_accum_a, make_accum_b, make_target)
     )
@@ -370,10 +435,9 @@ def test_StreamProcessor_raises_given_partial_update_for_accumulator() -> None:
         accumulators=(Target, AccumC),  # Target depends on both A and B
     )
     # We can update either (A, B) and/or C...
-    result = streaming_wf.add_chunk({DynamicA: sc.scalar(1), DynamicB: sc.scalar(4)})
-    assert sc.identical(result[Target], sc.scalar(2 * 1.0 / 4.0))
-    assert result[AccumC] is None
-    result = streaming_wf.add_chunk({DynamicC: sc.scalar(11)})
+    streaming_wf.accumulate({DynamicA: sc.scalar(1), DynamicB: sc.scalar(4)})
+    streaming_wf.accumulate({DynamicC: sc.scalar(11)})
+    result = streaming_wf.finalize()
     assert sc.identical(result[Target], sc.scalar(2 * 1.0 / 4.0))
     assert sc.identical(result[AccumC], sc.scalar(11))
     result = streaming_wf.add_chunk({DynamicA: sc.scalar(2), DynamicB: sc.scalar(5)})
@@ -428,3 +492,35 @@ def test_StreamProcessor_raises_when_trying_to_update_non_dynamic_key() -> None:
         match=r'Got non-dynamic keys: {tests.streaming_test.Target}',
     ):
         result = streaming_wf.add_chunk({Target: sc.scalar(2)})
+
+
+def test_StreamProcessor_clear() -> None:
+    base_workflow = sciline.Pipeline(
+        (make_static_a, make_accum_a, make_accum_b, make_target)
+    )
+
+    # Reset call counter to ensure we can track it properly
+    make_static_a.call_count = 0
+
+    streaming_wf = streaming.StreamProcessor(
+        base_workflow=base_workflow,
+        dynamic_keys=(DynamicA, DynamicB),
+        target_keys=(Target,),
+        accumulators=(AccumA, AccumB),
+    )
+    # Add some data
+    result = streaming_wf.add_chunk({DynamicA: sc.scalar(1), DynamicB: sc.scalar(4)})
+    assert sc.identical(result[Target], sc.scalar(2 * 1.0 / 4.0))
+    result = streaming_wf.add_chunk({DynamicA: sc.scalar(2), DynamicB: sc.scalar(5)})
+    assert sc.identical(result[Target], sc.scalar(2 * 3.0 / 9.0))
+
+    # Make sure static_a was called exactly once
+    assert make_static_a.call_count == 1
+
+    # Clear and verify we get back to initial state
+    streaming_wf.clear()
+    result = streaming_wf.add_chunk({DynamicA: sc.scalar(1), DynamicB: sc.scalar(4)})
+    assert sc.identical(result[Target], sc.scalar(2 * 1.0 / 4.0))
+
+    # Static values should be preserved after clear, so call_count remains 1
+    assert make_static_a.call_count == 1