modacor 1.0.0__py3-none-any.whl

modacor/tests/modules/base_modules/test_append_source.py

@@ -0,0 +1,180 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# /usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+from __future__ import annotations
+
+__coding__ = "utf-8"
+__authors__ = ["Brian R. Pauw"]  # add names to the list as appropriate
+__copyright__ = "Copyright 2025, The MoDaCor team"
+__date__ = "30/11/2025"
+__status__ = "Development"  # "Development", "Production"
+# end of header and standard imports
+
+import sys
+import types
+from typing import List, Tuple
+
+import pytest
+
+from modacor.io.io_sources import IoSource, IoSources
+from modacor.modules.base_modules.append_source import AppendSource
+
+
+def _install_dummy_iosource_module(monkeypatch) -> Tuple[str, List[tuple]]:
+    """
+    Install a dummy loader module into sys.modules and return:
+
+    - the fully qualified loader path string
+    - a list that will collect call arguments for assertions
+    """
+    calls: List[tuple] = []
+
+    module_name = "modacor.tests.dummy_iosource_module"
+    mod = types.ModuleType(module_name)
+
+    class DummySource(IoSource):
+        """
+        Minimal IoSource subclass used only for testing.
+
+        We deliberately override __init__ and *do not* call super().__init__
+        to avoid depending on IoSource's real constructor signature.
+        We just provide the attributes IoSources.register_source is expected
+        to use (source_reference, resource_location).
+        """
+
+        def __init__(self, ref: str, loc: str) -> None:
+            self.source_reference = ref
+            self.resource_location = loc
+
+    def dummy_loader(*, source_reference: str, resource_location: str, **kwargs) -> IoSource:
+        """
+        Minimal loader that mimics the real loader signature used by AppendSource.
+        Returns a DummySource instance and records calls for assertions.
+        """
+        calls.append((source_reference, resource_location))
+        return DummySource(source_reference, resource_location)
+
+    # The attribute name here is what AppendSource._resolve_iosource_callable
+    # will try to retrieve from the module.
+    mod.DummyLoader = dummy_loader  # type: ignore[attr-defined]
+
+    # Inject into sys.modules so import_module() can find it
+    monkeypatch.setitem(sys.modules, module_name, mod)
+
+    loader_path = f"{module_name}.DummyLoader"
+    return loader_path, calls
+
+
+def _make_append_source_instance() -> AppendSource:
+    """
+    Create an AppendSource instance without going through ProcessStep.__init__.
+
+    We only need 'configuration' and 'io_sources' for these tests, so __new__
+    is sufficient and avoids coupling to ProcessStep's constructor signature.
+    """
+    instance = AppendSource.__new__(AppendSource)
+    return instance
+
+
+def test_append_single_source(monkeypatch):
+    loader_path, calls = _install_dummy_iosource_module(monkeypatch)
+
+    step = _make_append_source_instance()
+    step.configuration = {
+        "source_identifier": "sample_source",
+        "source_location": "/tmp/sample.dat",
+        "iosource_module": loader_path,
+    }
+    step.io_sources = IoSources()
+
+    result = step.calculate()
+
+    # No databundles modified
+    assert result == {}
+
+    # The new source should be present
+    assert "sample_source" in step.io_sources.defined_sources
+
+    # Loader should be called exactly once with the expected args
+    assert calls == [("sample_source", "/tmp/sample.dat")]
+
+
+def test_append_multiple_sources(monkeypatch):
+    loader_path, calls = _install_dummy_iosource_module(monkeypatch)
+
+    step = _make_append_source_instance()
+    step.configuration = {
+        "source_identifier": ["src1", "src2"],
+        "source_location": ["/tmp/file1.dat", "/tmp/file2.dat"],
+        "iosource_module": loader_path,
+    }
+    step.io_sources = IoSources()
+
+    result = step.calculate()
+
+    # Still no databundles modified
+    assert result == {}
+
+    # Both sources should be present
+    assert "src1" in step.io_sources.defined_sources
+    assert "src2" in step.io_sources.defined_sources
+
+    # Loader should have been called twice in order
+    assert calls == [
+        ("src1", "/tmp/file1.dat"),
+        ("src2", "/tmp/file2.dat"),
+    ]
+
+
+def test_mismatched_source_lengths_raises(monkeypatch):
+    loader_path, _ = _install_dummy_iosource_module(monkeypatch)
+
+    step = _make_append_source_instance()
+    step.configuration = {
+        "source_identifier": ["src1", "src2"],
+        "source_location": ["/tmp/only_one.dat"],
+        "iosource_module": loader_path,
+    }
+    step.io_sources = IoSources()
+
+    with pytest.raises(ValueError, match="counts must match"):
+        step.calculate()
+
+
+def test_existing_source_is_not_overwritten(monkeypatch):
+    loader_path, calls = _install_dummy_iosource_module(monkeypatch)
+
+    step = _make_append_source_instance()
+    step.io_sources = IoSources()
+
+    class PreExistingSource(IoSource):
+        """
+        Pre-registered IoSource subclass for testing overwrite behaviour.
+        """
+
+        def __init__(self, ref: str, loc: str) -> None:
+            self.source_reference = ref
+            self.resource_location = loc
+
+    # Pre-register a source with identifier "existing"
+    step.io_sources.register_source(PreExistingSource(ref="existing", loc="/tmp/original.dat"))
+
+    # Configuration attempts to append a source with the same identifier
+    step.configuration = {
+        "source_identifier": "existing",
+        "source_location": "/tmp/new_location.dat",
+        "iosource_module": loader_path,
+    }
+
+    result = step.calculate()
+
+    # No databundles modified
+    assert result == {}
+
+    # The identifier should still be present…
+    assert "existing" in step.io_sources.defined_sources
+
+    # …but the loader should not have been called at all,
+    # since AppendSource checks defined_sources before appending.
+    assert calls == []

modacor/tests/modules/base_modules/test_bitwise_or_masks.py

@@ -0,0 +1,264 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# /usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+from __future__ import annotations
+
+__coding__ = "utf-8"
+__authors__ = ["Brian R. Pauw"]  # add names to the list as appropriate
+__copyright__ = "Copyright 2026, The MoDaCor team"
+__date__ = "09/01/2026"
+__status__ = "Development"  # "Development", "Production"
+# end of header and standard imports
+
+import unittest
+
+import numpy as np
+
+from modacor import ureg
+from modacor.dataclasses.basedata import BaseData
+from modacor.dataclasses.databundle import DataBundle
+from modacor.dataclasses.processing_data import ProcessingData
+from modacor.io.io_sources import IoSources
+
+# module under test
+from modacor.modules.base_modules.bitwise_or_masks import BitwiseOrMasks
+
+TEST_IO_SOURCES = IoSources()
+
+
+class TestBitwiseOrMasksProcessingStep(unittest.TestCase):
+    """Testing class for modacor/modules/base_modules/bitwise_or_masks.py"""
+
+    def setUp(self):
+        self.test_processing_data = ProcessingData()
+
+        tgt = np.zeros((2, 3), dtype=np.uint32)
+        bs = np.array([[4, 0, 0], [0, 32, 0]], dtype=np.uint32)
+
+        db = DataBundle(
+            mask=BaseData(signal=tgt, units=ureg.dimensionless, uncertainties={}),
+            bs_mask=BaseData(signal=bs, units=ureg.dimensionless, uncertainties={}),
+        )
+        self.test_processing_data["sample"] = db
+
+    def _make_step(self, *, target="mask", sources=None) -> BitwiseOrMasks:
+        step = BitwiseOrMasks(io_sources=TEST_IO_SOURCES)
+        step.configuration = {
+            "with_processing_keys": ["sample"],
+            "target_mask_key": target,
+            "source_mask_keys": list(sources or []),
+        }
+        step.processing_data = self.test_processing_data
+        return step
+
+    # ------------------------------------------------------------------ #
+    # Actual tests
+    # ------------------------------------------------------------------ #
+
+    def test_bitwise_or_masks_calculate_inplace_when_target_is_uint32(self):
+        """
+        If the target is already uint32, the OR should be performed truly in-place
+        (target array object remains the same).
+        """
+        step = self._make_step(sources=["bs_mask"])
+
+        before_id = id(self.test_processing_data["sample"]["mask"].signal)
+        step.calculate()
+
+        out = self.test_processing_data["sample"]["mask"].signal
+        self.assertEqual(id(out), before_id)  # in-place, no replacement
+
+        expected = np.array([[4, 0, 0], [0, 32, 0]], dtype=np.uint32)
+        np.testing.assert_array_equal(out, expected)
+
+    def test_bitwise_or_masks_execution_via_call(self):
+        """
+        __call__ should run the step and update processing_data in-place.
+        """
+        step = BitwiseOrMasks(io_sources=TEST_IO_SOURCES)
+        step.configuration = {
+            "with_processing_keys": ["sample"],
+            "target_mask_key": "mask",
+            "source_mask_keys": ["bs_mask"],
+        }
+
+        step(self.test_processing_data)
+
+        out = self.test_processing_data["sample"]["mask"].signal
+        expected = np.array([[4, 0, 0], [0, 32, 0]], dtype=np.uint32)
+        np.testing.assert_array_equal(out, expected)
+
+    def test_uint8_source_is_converted_and_or_applied(self):
+        """
+        A uint8 mask source should be accepted and widened to uint32 only if needed.
+        """
+        self.test_processing_data = ProcessingData()
+
+        tgt = np.zeros((2, 3), dtype=np.uint32)
+        # uint8 source containing bit 2 and bit 5
+        src_u8 = np.array([[4, 0, 0], [0, 32, 0]], dtype=np.uint8)
+
+        db = DataBundle(
+            mask=BaseData(signal=tgt, units=ureg.dimensionless, uncertainties={}),
+            bs_mask=BaseData(signal=src_u8, units=ureg.dimensionless, uncertainties={}),
+        )
+        self.test_processing_data["sample"] = db
+
+        step = BitwiseOrMasks(io_sources=TEST_IO_SOURCES)
+        step.configuration = {
+            "with_processing_keys": ["sample"],
+            "target_mask_key": "mask",
+            "source_mask_keys": ["bs_mask"],
+        }
+        step.processing_data = self.test_processing_data
+        step.calculate()
+
+        out = self.test_processing_data["sample"]["mask"].signal
+        self.assertEqual(out.dtype, np.uint32)  # canonical dtype
+        expected = np.array([[4, 0, 0], [0, 32, 0]], dtype=np.uint32)
+        np.testing.assert_array_equal(out, expected)
+
+    def test_target_non_uint32_is_upcast_to_uint32_once(self):
+        """
+        If the target mask isn't uint32 (e.g. int64), the step should convert it to uint32
+        (one-time allocation) and then OR into that.
+        """
+        self.test_processing_data = ProcessingData()
+
+        tgt_i64 = np.zeros((2, 3), dtype=np.int64)
+        src = np.array([[1, 0, 0], [0, 2, 0]], dtype=np.uint32)
+
+        db = DataBundle(
+            mask=BaseData(signal=tgt_i64, units=ureg.dimensionless, uncertainties={}),
+            bs_mask=BaseData(signal=src, units=ureg.dimensionless, uncertainties={}),
+        )
+        self.test_processing_data["sample"] = db
+
+        step = BitwiseOrMasks(io_sources=TEST_IO_SOURCES)
+        step.configuration = {
+            "with_processing_keys": ["sample"],
+            "target_mask_key": "mask",
+            "source_mask_keys": ["bs_mask"],
+        }
+        step.processing_data = self.test_processing_data
+
+        before_id = id(self.test_processing_data["sample"]["mask"].signal)
+        step.calculate()
+
+        out = self.test_processing_data["sample"]["mask"].signal
+        self.assertEqual(out.dtype, np.uint32)
+        self.assertNotEqual(id(out), before_id)  # replacement happened due to upcast
+
+        expected = np.array([[1, 0, 0], [0, 2, 0]], dtype=np.uint32)
+        np.testing.assert_array_equal(out, expected)
+
+    def test_mixed_signed_int_preserves_high_bit_after_uint32_canonicalization(self):
+        """
+        OR in bit 31 (0x80000000), stored as negative in int32.
+        After canonicalization, target is uint32 and should contain 0x80000000.
+        """
+        self.test_processing_data = ProcessingData()
+
+        tgt = np.zeros((1,), dtype=np.uint32)
+        src = np.array([np.int32(-2147483648)], dtype=np.int32)  # 0x80000000
+
+        db = DataBundle(
+            mask=BaseData(signal=tgt, units=ureg.dimensionless, uncertainties={}),
+            bs_mask=BaseData(signal=src, units=ureg.dimensionless, uncertainties={}),
+        )
+        self.test_processing_data["sample"] = db
+
+        step = BitwiseOrMasks(io_sources=TEST_IO_SOURCES)
+        step.configuration = {
+            "with_processing_keys": ["sample"],
+            "target_mask_key": "mask",
+            "source_mask_keys": ["bs_mask"],
+        }
+        step.processing_data = self.test_processing_data
+        step.calculate()
+
+        out = self.test_processing_data["sample"]["mask"].signal
+        self.assertEqual(out.dtype, np.uint32)
+        self.assertEqual(int(out[0]), 0x80000000)
+
+        # source unchanged
+        self.assertEqual(src.dtype, np.int32)
+        self.assertEqual(int(src[0]), -2147483648)
+
+    def test_rejects_non_integer_masks(self):
+        """
+        Float masks should be rejected (masks must be integer dtype).
+        """
+        self.test_processing_data = ProcessingData()
+
+        tgt = np.zeros((2, 3), dtype=np.uint32)
+        bad = np.zeros((2, 3), dtype=float)
+
+        db = DataBundle(
+            mask=BaseData(signal=tgt, units=ureg.dimensionless, uncertainties={}),
+            bs_mask=BaseData(signal=bad, units=ureg.dimensionless, uncertainties={}),
+        )
+        self.test_processing_data["sample"] = db
+
+        step = BitwiseOrMasks(io_sources=TEST_IO_SOURCES)
+        step.configuration = {
+            "with_processing_keys": ["sample"],
+            "target_mask_key": "mask",
+            "source_mask_keys": ["bs_mask"],
+        }
+        step.processing_data = self.test_processing_data
+
+        with self.assertRaises(AssertionError):
+            step.calculate()
+
+    def test_broadcasting_and_shape_errors(self):
+        """
+        Broadcasting is handled by NumPy; incompatible shapes should raise ValueError.
+        """
+        # broadcastable (2,3) |= (2,1)
+        self.test_processing_data = ProcessingData()
+
+        tgt = np.zeros((2, 3), dtype=np.uint32)
+        src = np.array([[1], [2]], dtype=np.uint8)  # now explicitly uint8
+
+        db = DataBundle(
+            mask=BaseData(signal=tgt, units=ureg.dimensionless, uncertainties={}),
+            bs_mask=BaseData(signal=src, units=ureg.dimensionless, uncertainties={}),
+        )
+        self.test_processing_data["sample"] = db
+
+        step = BitwiseOrMasks(io_sources=TEST_IO_SOURCES)
+        step.configuration = {
+            "with_processing_keys": ["sample"],
+            "target_mask_key": "mask",
+            "source_mask_keys": ["bs_mask"],
+        }
+        step.processing_data = self.test_processing_data
+        step.calculate()
+
+        expected = np.array([[1, 1, 1], [2, 2, 2]], dtype=np.uint32)
+        np.testing.assert_array_equal(self.test_processing_data["sample"]["mask"].signal, expected)
+
+        # incompatible -> ValueError from NumPy ufunc broadcasting rules (especially with out=)
+        self.test_processing_data = ProcessingData()
+
+        tgt2 = np.zeros((2, 3), dtype=np.uint32)
+        bad = np.zeros((4,), dtype=np.uint8)
+
+        db2 = DataBundle(
+            mask=BaseData(signal=tgt2, units=ureg.dimensionless, uncertainties={}),
+            bs_mask=BaseData(signal=bad, units=ureg.dimensionless, uncertainties={}),
+        )
+        self.test_processing_data["sample"] = db2
+
+        step2 = BitwiseOrMasks(io_sources=TEST_IO_SOURCES)
+        step2.configuration = {
+            "with_processing_keys": ["sample"],
+            "target_mask_key": "mask",
+            "source_mask_keys": ["bs_mask"],
+        }
+        step2.processing_data = self.test_processing_data
+
+        with self.assertRaises(ValueError):
+            step2.calculate()

modacor/tests/modules/base_modules/test_combine_uncertainties.py

@@ -0,0 +1,105 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# /usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+from __future__ import annotations
+
+__coding__ = "utf-8"
+__authors__ = ["Brian R. Pauw"]  # add names to the list as appropriate
+__copyright__ = "Copyright 2026, The MoDaCor team"
+__date__ = "20/01/2026"
+__status__ = "Development"  # "Development", "Production"
+# end of header and standard imports
+
+import numpy as np
+import pytest
+
+from modacor import ureg
+from modacor.dataclasses.basedata import BaseData
+from modacor.dataclasses.databundle import DataBundle
+from modacor.dataclasses.processing_data import ProcessingData
+from modacor.modules.base_modules.combine_uncertainties import CombineUncertainties
+
+
+def _make_processing_data() -> ProcessingData:
+    signal = np.array([[10.0, 12.0], [8.0, 9.0]], dtype=float)
+    poisson = 0.1 * np.ones_like(signal)
+    readout = 0.2 * np.ones_like(signal)
+    background = 0.05 * np.ones_like(signal)
+
+    basedata = BaseData(
+        signal=signal,
+        units=ureg.Unit("count"),
+        uncertainties={
+            "poisson": poisson,
+            "readout": readout,
+            "background": background,
+        },
+    )
+
+    databundle = DataBundle(signal=basedata)
+    processing_data = ProcessingData()
+    processing_data["sample"] = databundle
+    return processing_data
+
+
+def test_combine_uncertainties_creates_new_key():
+    processing_data = _make_processing_data()
+    step = CombineUncertainties()
+    step.modify_config_by_kwargs(
+        with_processing_keys=["sample"],
+        combinations={"stat_total": ["poisson", "readout"]},
+    )
+
+    step(processing_data)
+
+    bd = processing_data["sample"]["signal"]
+    expected = np.sqrt(0.1**2 + 0.2**2) * np.ones_like(bd.signal)
+    np.testing.assert_allclose(bd.uncertainties["stat_total"], expected)
+    assert "poisson" in bd.uncertainties
+    assert "readout" in bd.uncertainties
+
+
+def test_combine_uncertainties_can_drop_sources():
+    processing_data = _make_processing_data()
+    step = CombineUncertainties()
+    step.modify_config_by_kwargs(
+        with_processing_keys=["sample"],
+        combinations={"sigma_total": ["poisson", "readout"]},
+        drop_source_keys=True,
+    )
+
+    step(processing_data)
+
+    bd = processing_data["sample"]["signal"]
+    assert "sigma_total" in bd.uncertainties
+    assert "poisson" not in bd.uncertainties
+    assert "readout" not in bd.uncertainties
+    assert "background" in bd.uncertainties
+
+
+def test_combine_uncertainties_missing_sources_error():
+    processing_data = _make_processing_data()
+    step = CombineUncertainties()
+    step.modify_config_by_kwargs(
+        with_processing_keys=["sample"],
+        combinations={"sigma_total": ["poisson", "absent_key"]},
+    )
+
+    with pytest.raises(KeyError):
+        step(processing_data)
+
+
+def test_combine_uncertainties_ignore_missing_uses_available():
+    processing_data = _make_processing_data()
+    step = CombineUncertainties()
+    step.modify_config_by_kwargs(
+        with_processing_keys=["sample"],
+        combinations={"stat_total": ["poisson", "absent_key"]},
+        ignore_missing=True,
+    )
+
+    step(processing_data)
+
+    bd = processing_data["sample"]["signal"]
+    np.testing.assert_allclose(bd.uncertainties["stat_total"], bd.uncertainties["poisson"])

modacor/tests/modules/base_modules/test_combine_uncertainties_max.py

@@ -0,0 +1,109 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# /usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+from __future__ import annotations
+
+__coding__ = "utf-8"
+__authors__ = ["Brian R. Pauw"]  # add names to the list as appropriate
+__copyright__ = "Copyright 2026, The MoDaCor team"
+__date__ = "20/01/2026"
+__status__ = "Development"  # "Development", "Production"
+# end of header and standard imports
+
+import numpy as np
+import pytest
+
+from modacor import ureg
+from modacor.dataclasses.basedata import BaseData
+from modacor.dataclasses.databundle import DataBundle
+from modacor.dataclasses.processing_data import ProcessingData
+from modacor.modules.base_modules.combine_uncertainties_max import CombineUncertaintiesMax
+
+
+def _make_processing_data() -> ProcessingData:
+    signal = np.array([[10.0, 12.0], [8.0, 9.0]], dtype=float)
+    poisson = 0.1 * np.ones_like(signal)
+    readout = np.array([[0.2, 0.05], [0.15, 0.25]])
+    background = 0.05 * np.ones_like(signal)
+
+    basedata = BaseData(
+        signal=signal,
+        units=ureg.Unit("count"),
+        uncertainties={
+            "poisson": poisson,
+            "readout": readout,
+            "background": background,
+        },
+    )
+
+    databundle = DataBundle(signal=basedata)
+    processing_data = ProcessingData()
+    processing_data["sample"] = databundle
+    return processing_data
+
+
+def test_combine_uncertainties_maximum():
+    processing_data = _make_processing_data()
+    step = CombineUncertaintiesMax()
+    step.modify_config_by_kwargs(
+        with_processing_keys=["sample"],
+        combinations={"sigma_max": ["poisson", "readout", "background"]},
+    )
+
+    step(processing_data)
+
+    bd = processing_data["sample"]["signal"]
+    expected = np.maximum.reduce(
+        [
+            np.broadcast_to(bd.uncertainties["poisson"], bd.signal.shape),
+            np.broadcast_to(bd.uncertainties["readout"], bd.signal.shape),
+            np.broadcast_to(bd.uncertainties["background"], bd.signal.shape),
+        ]
+    )
+    np.testing.assert_allclose(bd.uncertainties["sigma_max"], expected)
+
+
+def test_combine_uncertainties_max_drop_sources():
+    processing_data = _make_processing_data()
+    step = CombineUncertaintiesMax()
+    step.modify_config_by_kwargs(
+        with_processing_keys=["sample"],
+        combinations={"sigma_max": ["poisson", "readout"]},
+        drop_source_keys=True,
+    )
+
+    step(processing_data)
+
+    bd = processing_data["sample"]["signal"]
+    assert "sigma_max" in bd.uncertainties
+    assert "poisson" not in bd.uncertainties
+    assert "readout" not in bd.uncertainties
+    assert "background" in bd.uncertainties
+
+
+def test_combine_uncertainties_max_missing_sources_error():
+    processing_data = _make_processing_data()
+    step = CombineUncertaintiesMax()
+    step.modify_config_by_kwargs(
+        with_processing_keys=["sample"],
+        combinations={"sigma_max": ["poisson", "absent_key"]},
+    )
+
+    with pytest.raises(KeyError):
+        step(processing_data)
+
+
+def test_combine_uncertainties_max_ignore_missing():
+    processing_data = _make_processing_data()
+    step = CombineUncertaintiesMax()
+    step.modify_config_by_kwargs(
+        with_processing_keys=["sample"],
+        combinations={"sigma_max": ["poisson", "absent_key"]},
+        ignore_missing=True,
+    )
+
+    step(processing_data)
+
+    bd = processing_data["sample"]["signal"]
+    np.testing.assert_allclose(bd.uncertainties["sigma_max"], bd.uncertainties["poisson"])