modacor 1.0.0__py3-none-any.whl

modacor/tests/integration/test_pipeline_run.py

@@ -0,0 +1,238 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# /usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+from __future__ import annotations
+
+__coding__ = "utf-8"
+__authors__ = ["Anja Hörmann", "Brian R. Pauw"]  # add names to the list as appropriate
+__copyright__ = "Copyright 2025, The MoDaCor team"
+__date__ = "18/06/2025"
+__status__ = "Development"  # "Development", "Production"
+# end of header and standard imports
+
+import tempfile
+import unittest
+from os import unlink
+
+import h5py
+import numpy as np
+import pytest
+
+from modacor import ureg
+
+from ...dataclasses.basedata import BaseData
+from ...dataclasses.databundle import DataBundle
+from ...dataclasses.process_step import ProcessStep
+from ...dataclasses.processing_data import ProcessingData
+from ...io.hdf.hdf_source import HDFSource
+from ...io.io_sources import IoSources
+from ...io.yaml.yaml_source import YAMLSource
+from ...modules.base_modules.poisson_uncertainties import PoissonUncertainties
+from ...runner.pipeline import Pipeline
+
+TEST_IO_SOURCES = IoSources()
+TEST_DATA = ProcessingData()
+TEST_DATA["data"] = DataBundle()
+
+
+@pytest.fixture
+def flat_data():
+    data = ProcessingData()
+    data["bundle1"] = DataBundle()
+    data["bundle2"] = DataBundle()
+    data["bundle1"]["signal"] = BaseData(signal=np.arange(50), units=ureg.Unit("count"))
+    data["bundle2"]["signal"] = BaseData(signal=np.ones((10, 10)), units=ureg.Unit("count"))
+    return data
+
+
+class DummyProcessStep(ProcessStep):
+    def calculate(self):
+        return {"test": DataBundle()}
+
+
+def test_processstep_pipeline(flat_data):
+    "tests execution of a linear processstep pipeline (not actually doing anything)"
+    steps = [DummyProcessStep(io_sources=TEST_IO_SOURCES, step_id=i) for i in range(3)]
+    graph = {steps[i]: {steps[i + 1]} for i in range(len(steps) - 1)}
+
+    pipeline = Pipeline(graph=graph)
+    pipeline.prepare()
+    sequence = []
+    while pipeline.is_active():
+        for node in pipeline.get_ready():
+            node.processing_data = flat_data
+            sequence.append(node)
+            node.execute(flat_data)
+            pipeline.done(node)
+    assert pipeline._nfinished == len(steps)
+
+
+def test_actual_processstep(flat_data):
+    "test running the PoissonUncertainties Process step"
+    step = PoissonUncertainties(io_sources=TEST_IO_SOURCES)
+    # we need to supply a list of values here
+    step.modify_config_by_kwargs(with_processing_keys=["bundle2"])
+    graph = {step: {}}
+
+    pipeline = Pipeline(graph=graph)
+    pipeline.prepare()
+    while pipeline.is_active():
+        for node in pipeline.get_ready():
+            node.processing_data = flat_data
+            node.execute(flat_data)
+            pipeline.done(node)
+    assert node.produced_outputs["bundle2"]["signal"].variances["Poisson"].mean().astype(int) == 1
+
+
+class TestRealisticPipeline(unittest.TestCase):
+    """Tests using yaml files as input for both data and pipeline.
+
+    the yaml loader needs an actual path to load, can't take a string.
+
+    """
+
+    def setUp(self):
+        # setup yaml static input file
+        self.temp_file_handle = tempfile.NamedTemporaryFile(delete=False, delete_on_close=False)
+        self.temp_file_path = self.temp_file_handle.name
+        self.temp_file_handle.close()
+        with open(self.temp_file_path, "w") as yaml_file:
+            yaml_file.write(
+                """
+            instrument:
+              name: "SAXSess I"
+              type: "X-ray scattering"
+              manufacturer: "Anton Paar"
+              model: "SAXSess"
+            wavelength:
+              value: 0.1542
+              units: "nm"
+              uncertainty: 0.0005
+            detector:
+              name: "Mythen2"
+              type: "1D strip detector"
+              manufacturer: "Dectris"
+              n_pixels: 1280
+              darkcurrent:
+                value: 1e-5
+                units: "counts/second"
+                uncertainty: 0.1e-5
+              """
+            )
+        # setup two small hdf5 files for sample and background
+        self.temp_dataset_shape = (10, 2)
+        self.temp_time_handle = "frame_exposure_time"
+        self.temp_hdf_file_sample = tempfile.NamedTemporaryFile(delete=False, delete_on_close=False)
+        self.temp_hdf_path_sample = self.temp_hdf_file_sample.name
+        self.temp_hdf_file_sample.close()
+        self.temp_hdf_file_background = tempfile.NamedTemporaryFile(delete=False, delete_on_close=False)
+        self.temp_hdf_path_background = self.temp_hdf_file_background.name
+        self.temp_hdf_file_background.close()
+
+        self.temp_data = {
+            "sample": 10 * np.ones(self.temp_dataset_shape),
+            "sample_background": np.ones(self.temp_dataset_shape),
+        }
+        self.temp_hdf_paths = {"sample": self.temp_hdf_path_sample, "sample_background": self.temp_hdf_path_background}
+        for key, path in self.temp_hdf_paths.items():
+            with h5py.File(path, "w") as hdf_file:
+                data = hdf_file.create_dataset("data", data=self.temp_data[key], dtype="float64", compression="gzip")
+                data.attrs["units"] = "counts"
+                detector = hdf_file.create_group("detector")
+                time = detector.create_dataset(self.temp_time_handle, data=10.0)
+                time.attrs["units"] = "s"
+                time.attrs["uncertainties"] = f"{self.temp_time_handle}_uncertainty"
+                time_uncertainty = detector.create_dataset(f"{self.temp_time_handle}_uncertainty", data=0.1)
+                time_uncertainty.attrs["units"] = "s"
+
+        self.yaml_semirealistic_linear_pipeline = """
+        name: freestanding_solid
+        steps:
+          1:
+            name: poisson
+            module: PoissonUncertainties
+            requires_steps: []
+            configuration:
+              with_processing_keys:
+                - sample
+                - sample_background
+          2:
+            name: normalize_by_time
+            module: Divide
+            requires_steps: [1]
+            configuration:
+              divisor_source: sample::detector/frame_exposure_time
+              divisor_uncertainties_sources:
+                propagate_to_all: sample::detector/frame_exposure_time_uncertainty
+              divisor_units_source: sample::detector/frame_exposure_time@units
+              with_processing_keys:
+                - sample
+                - sample_background
+          3:
+            name: subtract_dark_current
+            module: Subtract
+            requires_steps: [2]
+            configuration:
+              subtrahend_source: yaml::detector/darkcurrent/value
+              subtrahend_uncertainties_sources:
+                propagate_to_all: yaml::detector/darkcurrent/uncertainty
+              subtrahend_units_source: yaml::detector/darkcurrent/units
+              with_processing_keys:
+              - sample
+              - sample_background
+          bg:
+            name: subtract_background
+            module: SubtractDatabundles
+            requires_steps: [3]
+            configuration:
+              with_processing_keys:
+                - sample
+                - sample_background
+        """
+
+    def tearDown(self):
+        unlink(self.temp_file_path)
+        unlink(self.temp_hdf_path_sample)
+        unlink(self.temp_hdf_path_background)
+
+    def test_semirealistic_pipeline(self):
+        metadata_source = YAMLSource(source_reference="yaml", resource_location=self.temp_file_path)
+        sources = IoSources()
+        sources.register_source(source=metadata_source)
+        sources.register_source(HDFSource(source_reference="sample", resource_location=self.temp_hdf_path_sample))
+        sources.register_source(
+            HDFSource(source_reference="sample_background", resource_location=self.temp_hdf_path_background)
+        )
+
+        source = "sample"
+        _ = [
+            print(f"{source}::{key} with shape {val}")  # noqa: E231
+            for key, val in sources.get_source(source)._file_datasets_shapes.items()
+        ]
+
+        processingdata = ProcessingData()
+        for key in ["sample", "sample_background"]:
+            processingdata[key] = DataBundle()
+            processingdata[key]["signal"] = BaseData(
+                sources.get_data(f"{key}::data"),  # noqa: E231
+                units=sources.get_data_attributes(f"{key}::data")["units"],  # noqa: E231
+            )
+
+        pipeline = Pipeline.from_yaml(self.yaml_semirealistic_linear_pipeline)
+        pipeline.prepare()
+        sequence = []
+        while pipeline.is_active():
+            for node in pipeline.get_ready():
+                node.processing_data = processingdata
+                node.io_sources = sources
+                sequence.append(node)
+                node.execute(processingdata)
+                pipeline.done(node)
+
+        assert np.isclose(np.mean(processingdata["sample"]["signal"].signal), 0.9)
+        # rough estimate for poisson error
+        expected_error = np.sqrt((np.sqrt(10) / 10.0) ** 2 + (np.sqrt(1) / 10.0) ** 2)
+        assert np.isclose(
+            np.mean(processingdata["sample"]["signal"].uncertainties["Poisson"]), expected_error, atol=2e-4
+        )

modacor/tests/io/__init__.py

@@ -0,0 +1,27 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright 2025 MoDaCor Authors
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+# 3. Neither the name of the copyright holder nor the names of its contributors
+#    may be used to endorse or promote products derived from this software without
+#    specific prior written permission.
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+__license__ = "BSD-3-Clause"
+__copyright__ = "Copyright 2025 MoDaCor Authors"
+__status__ = "Alpha"

modacor/tests/io/csv/test_csv_source.py

@@ -0,0 +1,156 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# /usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+from __future__ import annotations
+
+__coding__ = "utf-8"
+__authors__ = ["Brian R. Pauw"]
+__copyright__ = "Copyright 2025, The MoDaCor team"
+__date__ = "12/12/2025"
+__status__ = "Development"  # "Development", "Production"
+# end of header and standard imports
+
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+# Adjust this import to match your actual module layout:
+# here we assume: modacor/io/csv/csv_source.py
+from modacor.io.csv.csv_source import CSVSource
+
+
+def write_text_file(path: Path, content: str) -> None:
+    path.write_text(content, encoding="utf-8")
+
+
+def test_csvsource_genfromtxt_names_true(tmp_path):
+    """
+    CSVSource should work with np.genfromtxt(names=True) where the first row
+    contains column names.
+    """
+    csv_content = "q,I,I_sigma\n1.0,2.0,0.1\n3.0,4.0,0.2\n"
+    file_path = tmp_path / "data_names_true.csv"
+    write_text_file(file_path, csv_content)
+
+    src = CSVSource(
+        source_reference="test_genfromtxt_names_true",
+        resource_location=file_path,
+        iosource_method_kwargs={"delimiter": ",", "names": True},
+        method=np.genfromtxt,
+    )
+
+    # dtype.names should be populated
+    assert src._data_cache.dtype.names == ("q", "I", "I_sigma")
+
+    # Data access
+    q = src.get_data("q")
+    I = src.get_data("I")  # noqa: E741
+    I_sigma = src.get_data("I_sigma")
+
+    assert np.allclose(q, [1.0, 3.0])
+    assert np.allclose(I, [2.0, 4.0])
+    assert np.allclose(I_sigma, [0.1, 0.2])
+
+    # Shape / dtype helpers
+    assert src.get_data_shape("q") == (2,)
+    assert src.get_data_dtype("q") == src._data_cache["q"].dtype
+
+
+def test_csvsource_genfromtxt_explicit_names(tmp_path):
+    """
+    CSVSource should work with np.genfromtxt(names=[...]) on data without a header row.
+    """
+    csv_content = "1.0,2.0,0.1\n3.0,4.0,0.2\n"
+    file_path = tmp_path / "data_explicit_names.csv"
+    write_text_file(file_path, csv_content)
+
+    src = CSVSource(
+        source_reference="test_genfromtxt_explicit_names",
+        resource_location=file_path,
+        iosource_method_kwargs={
+            "delimiter": ",",
+            "names": ["q", "I", "I_sigma"],
+        },
+        method=np.genfromtxt,
+    )
+
+    assert src._data_cache.dtype.names == ("q", "I", "I_sigma")
+
+    q = src.get_data("q")
+    I = src.get_data("I")  # noqa: E741
+    I_sigma = src.get_data("I_sigma")
+
+    assert np.allclose(q, [1.0, 3.0])
+    assert np.allclose(I, [2.0, 4.0])
+    assert np.allclose(I_sigma, [0.1, 0.2])
+
+
+def test_csvsource_loadtxt_structured_dtype(tmp_path):
+    """
+    CSVSource should support np.loadtxt when a structured dtype with field names
+    is provided.
+    """
+    csv_content = "1.0 2.0 0.1\n3.0 4.0 0.2\n"
+    file_path = tmp_path / "data_loadtxt_structured.csv"
+    write_text_file(file_path, csv_content)
+
+    structured_dtype = [("q", float), ("I", float), ("I_sigma", float)]
+
+    src = CSVSource(
+        source_reference="test_loadtxt_structured",
+        resource_location=file_path,
+        iosource_method_kwargs={
+            "delimiter": " ",
+            "dtype": structured_dtype,
+        },
+        method=np.loadtxt,
+    )
+
+    assert src._data_cache.dtype.names == ("q", "I", "I_sigma")
+
+    q = src.get_data("q")
+    I = src.get_data("I")  # noqa: E741
+    I_sigma = src.get_data("I_sigma")
+
+    assert np.allclose(q, [1.0, 3.0])
+    assert np.allclose(I, [2.0, 4.0])
+    assert np.allclose(I_sigma, [0.1, 0.2])
+
+
+def test_csvsource_raises_if_no_dtype_names(tmp_path):
+    """
+    CSVSource should raise a ValueError if the resulting array has no dtype.names,
+    e.g. when using np.loadtxt with a plain dtype.
+    """
+    csv_content = "1.0,2.0,3.0\n4.0,5.0,6.0\n"
+    file_path = tmp_path / "data_no_names.csv"
+    write_text_file(file_path, csv_content)
+
+    with pytest.raises(ValueError, match="dtype.names is None"):
+        CSVSource(
+            source_reference="test_no_names",
+            resource_location=file_path,
+            iosource_method_kwargs={"delimiter": ","},  # no structured dtype, no names
+            method=np.loadtxt,
+        )
+
+
+def test_csvsource_get_data_invalid_key_raises(tmp_path):
+    """
+    Requesting a non-existent data_key should raise a KeyError with a helpful message.
+    """
+    csv_content = "q,I\n1.0,2.0\n3.0,4.0\n"
+    file_path = tmp_path / "data_invalid_key.csv"
+    write_text_file(file_path, csv_content)
+
+    src = CSVSource(
+        source_reference="test_invalid_key",
+        resource_location=file_path,
+        iosource_method_kwargs={"delimiter": ",", "names": True},
+        method=np.genfromtxt,
+    )
+
+    with pytest.raises(KeyError, match="Data key 'nonexistent' not found"):
+        src.get_data("nonexistent")

modacor/tests/io/hdf/__init__.py

@@ -0,0 +1,27 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright 2025 MoDaCor Authors
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+# 3. Neither the name of the copyright holder nor the names of its contributors
+#    may be used to endorse or promote products derived from this software without
+#    specific prior written permission.
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+__license__ = "BSD-3-Clause"
+__copyright__ = "Copyright 2025 MoDaCor Authors"
+__status__ = "Alpha"

modacor/tests/io/hdf/test_hdf_source.py

@@ -0,0 +1,92 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# /usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+from __future__ import annotations
+
+__coding__ = "utf-8"
+__authors__ = ["Brian R. Pauw"]
+__copyright__ = "Copyright 2025, The MoDaCor team"
+__date__ = "06/06/2025"
+__status__ = "Development"  # "Development", "Production"
+# end of header and standard imports
+
+import tempfile
+import unittest
+from os import unlink
+from pathlib import Path
+
+import h5py
+import numpy as np
+
+from ....io.hdf.hdf_source import HDFSource
+
+
+class TestHDFSource(unittest.TestCase):
+    """Testing class for modacor/io/hdf/hdf_source.py"""
+
+    def setUp(self):
+        self.temp_file_handle = tempfile.NamedTemporaryFile(delete=False, delete_on_close=False)
+        self.temp_file_path = self.temp_file_handle.name
+        self.temp_file_handle.close()
+        self.temp_dataset_name = "dataset"
+        self.temp_dataset_shape = (10, 2)
+        with h5py.File(self.temp_file_path, "w") as hdf_file:
+            hdf_file.create_dataset(
+                self.temp_dataset_name, data=np.zeros(self.temp_dataset_shape), dtype="float64", compression="gzip"
+            )
+
+        self.test_hdf_source = HDFSource(source_reference="Test Data", resource_location=self.temp_file_path)
+
+    def tearDown(self):
+        self.test_hdf_source = None
+        self.test_file_path = None
+        self.test_dataset_name = None
+        self.test_dataset_shape = None
+        unlink(self.temp_file_path)
+
+    def test_open_file(self):
+        self.test_hdf_source._file_path = Path(self.temp_file_path)
+        self.test_hdf_source._preload()
+        self.assertEqual(Path(self.temp_file_path), self.test_hdf_source._file_path)
+        # self.assertEqual(self.temp_dataset_name, list(self.test_hdf_source._data_cache.keys())[0])
+        self.assertEqual(self.temp_dataset_shape, self.test_hdf_source._file_datasets_shapes[self.temp_dataset_name])
+
+    def test_get_data(self):
+        self.test_hdf_source._file_path = Path(self.temp_file_path)
+        self.test_hdf_source._preload()
+        data_array = self.test_hdf_source.get_data(self.temp_dataset_name)
+        self.assertTrue(isinstance(data_array, np.ndarray))
+        self.assertEqual(self.temp_dataset_shape, data_array.shape)
+
+    def test_get_data_with_slice(self):
+        self.test_hdf_source._file_path = Path(self.temp_file_path)
+        self.test_hdf_source._preload()
+        data_array = self.test_hdf_source.get_data(self.temp_dataset_name, load_slice=(slice(0, 5), slice(None)))
+        self.assertTrue(isinstance(data_array, np.ndarray))
+        self.assertEqual((5, 2), data_array.shape)
+
+    def test_get_data_shape(self):
+        self.test_hdf_source._file_path = Path(self.temp_file_path)
+        self.test_hdf_source._preload()
+        data_shape = self.test_hdf_source.get_data_shape(self.temp_dataset_name)
+        self.assertEqual(self.temp_dataset_shape, data_shape)
+
+    def test_get_data_dtype(self):
+        self.test_hdf_source._file_path = Path(self.temp_file_path)
+        self.test_hdf_source._preload()
+        data_dtype = self.test_hdf_source.get_data_dtype(self.temp_dataset_name)
+        self.assertEqual(np.dtype("float64"), data_dtype)
+
+    def test_get_static_metadata(self):
+        self.test_hdf_source._file_path = Path(self.temp_file_path)
+        self.test_hdf_source._preload()
+        static_metadata = self.test_hdf_source.get_static_metadata(self.temp_dataset_name)
+        self.assertTrue(isinstance(static_metadata, np.ndarray))
+        self.assertEqual(self.temp_dataset_shape, static_metadata.shape)
+
+    def test_get_data_attributes(self):
+        self.test_hdf_source._file_path = Path(self.temp_file_path)
+        self.test_hdf_source._preload()
+        data_attributes = self.test_hdf_source.get_data_attributes(self.temp_dataset_name)
+        self.assertEqual({}, data_attributes)  # No attributes set, should return empty dict

modacor/tests/io/test_io_sources.py

@@ -0,0 +1,119 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# /usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+from __future__ import annotations
+
+__coding__ = "utf-8"
+__authors__ = ["Malte Storm"]  # add names to the list as appropriate
+__copyright__ = "Copyright 2025, The MoDaCor team"
+__date__ = "16/11/2025"
+__status__ = "Development"  # "Development", "Production"
+# end of header and standard imports
+
+import numpy as np
+import pytest
+
+from modacor.io import IoSources
+from modacor.io.io_source import IoSource
+
+data_shape = (20, 20)
+
+
+class OnesSource(IoSource):
+    type_reference = "ones_source"
+
+    def __attrs_post_init__(self):
+        self.configuration["shape"] = data_shape
+
+    def get_data(self, index, key):
+        return np.ones(self.configuration["shape"])
+
+    def get_metadata(self, key):
+        return key
+
+
+class IndexSource(IoSource):
+    type_reference = "index_source"
+
+    def __attrs_post_init__(self):
+        self.configuration["shape"] = data_shape
+
+    def get_data(self, index, key):
+        return index * np.ones(self.configuration["shape"])
+
+    def get_metadata(self, key):
+        return key
+
+
+@pytest.fixture
+def io_sources():
+    return IoSources()
+
+
+def configure_test_sources(io_sources):
+    _source_30x10 = OnesSource()
+    _source_30x10.configuration["shape"] = (30, 10)
+    io_sources.register_source(source_reference="ones_30x10", source=_source_30x10)
+
+    _source_20x20 = OnesSource()
+    _source_20x20.configuration["shape"] = (20, 20)
+    io_sources.register_source(source_reference="ones_20x20", source=_source_20x20)
+
+    _index_source_25x25 = IndexSource()
+    _index_source_25x25.configuration["shape"] = (25, 25)
+    io_sources.register_source(source_reference="index_25x25", source=_index_source_25x25)
+    return io_sources
+
+
+@pytest.mark.parametrize("ref", [42, ["a", "ref2"]])
+def test_register_source__wrong_ref_type(io_sources, ref):
+    with pytest.raises(TypeError):
+        io_sources.register_source(source_reference=ref, source=OnesSource())
+
+
+@pytest.mark.parametrize("source", [IoSource, object()])
+def test_register_source__wrong_source_type(io_sources, source):
+    with pytest.raises(TypeError):
+        io_sources.register_source(source_reference="source", source=source)
+
+
+def test_register_source__duplicate_ref(io_sources):
+    io_sources.register_source(source_reference="source", source=OnesSource())
+    with pytest.raises(ValueError):
+        io_sources.register_source(source_reference="source", source=OnesSource())
+
+
+def test_register_source__valid(io_sources):
+    _source = OnesSource()
+    io_sources.register_source(source_reference="ones", source=_source)
+    assert "ones" in io_sources.defined_sources
+    assert io_sources.defined_sources["ones"] == _source
+
+
+def test_get_source__invalid(io_sources):
+    with pytest.raises(KeyError):
+        io_sources.get_source("invalid_source")
+
+
+def test_get_source__valid(io_sources):
+    io_sources = configure_test_sources(io_sources)
+    for _key in io_sources.defined_sources:
+        source = io_sources.get_source(_key)
+        assert isinstance(source, IoSource)
+
+
+def test_split_data_reference__invalid(io_sources):
+    with pytest.raises(ValueError):
+        io_sources.split_data_reference("invalid_reference")
+
+
+@pytest.mark.parametrize("ref", ["test::ref", "test::ref::extra", "test::/entry/data", "test::/entry/data::extra"])
+def test_split_data_reference__valid(io_sources, ref):
+    source_ref, data_key = io_sources.split_data_reference(ref)
+    assert source_ref == "test"
+    assert data_key == ref.lstrip("test::")
+
+
+if __name__ == "__main__":
+    pytest.main()

modacor/tests/io/tiled/__init__.py

@@ -0,0 +1,12 @@
+# 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