tomwer 1.3.5__py3-none-any.whl → 1.3.7__py3-none-any.whl

tomwer/gui/stitching/tests/test_z_stitching.py

@@ -0,0 +1,67 @@
+import os
+import tempfile
+
+from silx.gui import qt
+from silx.gui.utils.testutils import TestCaseQt
+from tomoscan.serie import Serie
+
+from tomwer.gui.stitching.stitching import ZStitchingWindow
+from tomwer.gui.stitching.tests.utils import create_scans_z_serie
+
+
+class TestAxis_N_Params(TestCaseQt):
+    """
+    Test definition of an axis shift research parameters
+    """
+
+    def setUp(self):
+        super().setUp()
+        self._window = ZStitchingWindow()
+
+        self._tmp_path = tempfile.mkdtemp()
+        self.axis_0_positions = (90, 0.0, -90.0)
+        self.axis_2_positions = (0.0, 0.0, 0.0)
+        pixel_size = 1.0
+
+        self.output_file_path = os.path.join(self._tmp_path, "output", "stitched.nx")
+        self._input_dir = os.path.join(self._tmp_path, "input")
+
+        self._scans = create_scans_z_serie(
+            output_dir=self._input_dir,
+            z_positions_m=self.axis_0_positions,
+            x_positions_m=self.axis_2_positions,
+            shifts=((0.0, 0.0), (-90.0, 0.0), (-180.0, 0.0)),
+            pixel_size=pixel_size,
+            raw_frame_width=280,
+            final_frame_width=100,
+        )
+        self._serie = Serie("z-serie", self._scans)
+
+    def tearDown(self):
+        self._window.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self._window.close()
+        self._window = None
+        while self.qapp.hasPendingEvents():
+            self.qapp.processEvents()
+
+    def test(self):
+        self._window.show()
+        for scan in self._scans:
+            self._window.addTomoObj(scan)
+        self._window.clean()
+        self._window.setSerie(self._serie)
+
+        # test dumping and loading configuration to a file
+        with tempfile.TemporaryDirectory() as dump_dir:
+            config_file = os.path.join(dump_dir, "configuration.cfg")
+            self._window._saveSettings(file_path=config_file)
+            assert os.path.exists(config_file)
+            self._window._loadSettings(config_file)
+            # remove configuration
+            self._window.clean()
+            assert len(self._window._widget._mainWidget.getTomoObjs()) == 0
+            # reload it
+            self._window._loadSettings(file_path=config_file)
+            assert len(self._window._widget._mainWidget.getTomoObjs()) == len(
+                self._serie
+            )

tomwer/gui/stitching/tests/utils.py

@@ -0,0 +1,79 @@
+import os
+
+import numpy
+from nxtomo.application.nxtomo import NXtomo
+from scipy.ndimage import shift as shift_scipy
+from silx.image.phantomgenerator import PhantomGenerator
+from nxtomo.nxobject.nxdetector import ImageKey
+
+from tomwer.core.scan.nxtomoscan import NXtomoScan
+
+
+def create_scans_z_serie(
+    output_dir,
+    z_positions_m,
+    x_positions_m=None,
+    pixel_size=10e-6,
+    n_proj=20,
+    raw_frame_width=100,
+    final_frame_width=100,
+    shifts=None,
+    z_rois=None,
+):
+    """
+    :param Optioanl tuple: shift to be applied on the 2D frame
+    """
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+    frame = (
+        PhantomGenerator.get2DPhantomSheppLogan(n=raw_frame_width).astype(numpy.float32)
+        * 256.0
+    )
+    if x_positions_m is None:
+        x_positions_m = [None] * len(z_positions_m)
+    if shifts is None:
+        shifts = [None] * len(z_positions_m)
+    if z_rois is None:
+        z_rois = [None] * len(z_positions_m)
+    scans = []
+    for i_frame, (z_pos, x_pos, z_roi, shift) in enumerate(
+        zip(z_positions_m, x_positions_m, z_rois, shifts)
+    ):
+        nx_tomo = NXtomo()
+        if z_pos is not None:
+            nx_tomo.sample.z_translation = [z_pos] * n_proj
+        if x_pos is not None:
+            nx_tomo.sample.x_translation = [x_pos] * n_proj
+        nx_tomo.sample.rotation_angle = numpy.linspace(
+            0, 180, num=n_proj, endpoint=False
+        )
+        nx_tomo.instrument.detector.image_key_control = [ImageKey.PROJECTION] * n_proj
+        if pixel_size is not None:
+            if isinstance(pixel_size, (tuple, list)):
+                y_pix_size, x_pix_size = pixel_size
+            else:
+                y_pix_size, x_pix_size = pixel_size, pixel_size
+            nx_tomo.instrument.detector.x_pixel_size = x_pix_size
+            nx_tomo.instrument.detector.y_pixel_size = y_pix_size
+        nx_tomo.instrument.detector.distance = 2.3
+        nx_tomo.energy = 19.2
+
+        if shift is not None:
+            sub_frame = shift_scipy(
+                input=frame.copy(), shift=shift, order=1, mode="constant"
+            )[:final_frame_width]
+        else:
+            sub_frame = frame
+        if z_roi is not None:
+            roi_start, roi_end = z_roi
+            sub_frame = sub_frame[roi_start:roi_end]
+        else:
+            sub_frame = sub_frame
+        nx_tomo.instrument.detector.data = numpy.asarray([sub_frame] * n_proj)
+
+        file_path = os.path.join(output_dir, f"nxtomo_{i_frame}.nx")
+        entry = f"entry000{i_frame}"
+        nx_tomo.save(file_path=file_path, data_path=entry)
+        scans.append(NXtomoScan(scan=file_path, entry=entry))
+
+    return scans

tomwer/gui/stitching/z_stitching/tests/test_fine_estimation.py

@@ -0,0 +1,35 @@
+from nabu.stitching.utils import ShiftAlgorithm as _NabuShiftAlgorithm
+from silx.gui import qt
+from silx.gui.utils.testutils import TestCaseQt
+
+from tomwer.gui.stitching.z_stitching.fineestimation import Axis_N_Params
+
+
+class TestAxis_N_Params(TestCaseQt):
+    """
+    Test definition of an axis shift research parameters
+    """
+
+    def setUp(self):
+        super().setUp()
+        self._widget = Axis_N_Params("axis n", None)
+
+    def tearDown(self):
+        self._widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self._widget.close()
+        self._widget = None
+        while self.qapp.hasPendingEvents():
+            self.qapp.processEvents()
+
+    def test(self):
+        self._widget.show()
+        assert self._widget.getCurrentMethod() == _NabuShiftAlgorithm.NONE
+        opts1 = self._widget.getOptsLine()
+        assert opts1 == "img_reg_method=None"
+        self._widget.setCurrentMethod(_NabuShiftAlgorithm.NABU_FFT)
+        opts2 = self._widget.getOptsLine()
+        assert opts2 == "img_reg_method=nabu-fft"
+        self._widget.setOptsLine(opts1)
+        assert self._widget.getOptsLine() == opts1
+        self._widget.setOptsLine(opts2)
+        assert self._widget.getOptsLine() == opts2

tomwer/gui/stitching/z_stitching/tests/test_raw_estimation.py

@@ -0,0 +1,215 @@
+import os
+import shutil
+import tempfile
+
+from silx.gui import qt
+from silx.gui.utils.testutils import TestCaseQt
+
+from tomwer.core.process.stitching.metadataholder import StitchingMetadata
+from tomwer.gui.stitching.metadataholder import QStitchingMetadata
+from tomwer.gui.stitching.tests.utils import create_scans_z_serie
+from tomwer.gui.stitching.config.tomoobjdetails import TomoObjectPositionInfos
+from tomwer.gui.stitching.axisorderedlist import AxisOrderedTomoObjsModel
+
+
+class TestTomoObjectPositionInfos(TestCaseQt):
+    """
+    Test edition of the tomo object position information
+    """
+
+    def setUp(self):
+        super().setUp()
+        self._tmp_path = tempfile.mkdtemp()
+        self._y_pixel_size = 0.002
+        self._x_pixel_size = 0.001
+        self.scans = create_scans_z_serie(
+            self._tmp_path,
+            z_positions_m=(0.200, 0.205, 0.210),
+            x_positions_m=(0.0, 0.0, None),
+            pixel_size=(self._y_pixel_size, self._x_pixel_size),
+            raw_frame_width=100,
+        )
+        self.scan_0_metadata = QStitchingMetadata(tomo_obj=self.scans[0])
+        assert self.scan_0_metadata.get_raw_position_m(axis=0) == 0.20
+        assert self.scan_0_metadata.get_raw_position_m(axis=2) == 0.0
+        self.scan_2_metadata = QStitchingMetadata(tomo_obj=self.scans[2])
+        assert self.scan_2_metadata.get_raw_position_m(axis=0) == 0.21
+        self._widget = TomoObjectPositionInfos()
+
+    def tearDown(self):
+        self._widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self._widget.close()
+        self._widget = None
+        while self.qapp.hasPendingEvents():
+            self.qapp.processEvents()
+        shutil.rmtree(self._tmp_path)
+
+    def testEdition(self):
+        # test QStitchingMetadata are correctly read
+        self._widget.show()
+        self._widget.setStitchingMetadata(self.scan_0_metadata)
+        self.qapp.processEvents()
+        assert self._widget._axis_0_pos.get_final_px_position() == int(0.20 / 0.002)
+        assert self._widget._axis_2_pos.get_final_px_position() == 0
+        self._widget.setStitchingMetadata(self.scan_2_metadata)
+        while self.qapp.hasPendingEvents():
+            self.qapp.processEvents()
+        assert self._widget._axis_0_pos.get_final_px_position() == int(0.21 / 0.002)
+        assert self._widget._axis_2_pos.get_final_px_position() is None
+        # test editing some parameters from the GUI. Make sure GUI is updated as the underlying metadata object
+        self._widget._axis_0_pos._overrideMetricPositionCB.setChecked(True)
+        self._widget._axis_0_pos.setRawMetricPosition(
+            position_m=0.4, displayed_unit="nm"
+        )
+        while self.qapp.hasPendingEvents():
+            self.qapp.processEvents()
+        assert self._widget._axis_0_pos.get_final_px_position() == int(
+            0.4 * 10e-6 / 0.002
+        )
+        self._widget._axis_0_pos._overridePixelPositionCB.setChecked(True)
+        self._widget._axis_0_pos.setOverrridePxPosition(position_px=120)
+        while self.qapp.hasPendingEvents():
+            self.qapp.processEvents()
+        assert self._widget._axis_0_pos.get_final_px_position() == int(120)
+        assert self.scan_2_metadata.get_abs_position_px(axis=0) == int(120)
+
+
+class TestAxisOrderedTomoObjsModel(TestCaseQt):
+    """
+    test the behavior of the z ordered model used for stitching
+    """
+
+    def setUp(self):
+        super().setUp()
+        self._tmp_path = tempfile.mkdtemp()
+        self.scans_with_pos_and_pixel_size = create_scans_z_serie(
+            os.path.join(self._tmp_path, "case1"),
+            z_positions_m=(0.200, 0.205, 0.210),
+            pixel_size=0.001,
+            raw_frame_width=100,
+        )
+        self.scans_with_pixel_size = create_scans_z_serie(
+            os.path.join(self._tmp_path, "case2"),
+            z_positions_m=(None, None, None),
+            pixel_size=0.001,
+            raw_frame_width=100,
+        )
+        self.scans_without_metadata = create_scans_z_serie(
+            os.path.join(self._tmp_path, "case3"),
+            z_positions_m=(None, None, None),
+            pixel_size=None,
+            raw_frame_width=100,
+        )
+        self._widget = qt.QTableView()
+        self._widget.setModel(AxisOrderedTomoObjsModel(parent=self._widget, axis=0))
+
+    def tearDown(self):
+        self._widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self._widget.close()
+        self._widget = None
+        while self.qapp.hasPendingEvents():
+            self.qapp.processEvents()
+        shutil.rmtree(self._tmp_path)
+
+    def testWithMetadata(self):
+        """
+        make sure z ordering works in the best case scenario
+        """
+        first_expected_scan = (
+            self.scans_with_pos_and_pixel_size[2].get_identifier().short_description()
+        )
+        # try giving it ordered
+        for scan in self.scans_with_pos_and_pixel_size[::-1]:
+            self._widget.model().addTomoObj(scan)
+        assert (
+            self._widget.model().data(
+                self._widget.model().index(0, 1), qt.Qt.DisplayRole
+            )
+            == first_expected_scan
+        )
+        self._widget.model().clearTomoObjs()
+        # try giving it ordered (but inverted)
+        for scan in self.scans_with_pos_and_pixel_size:
+            self._widget.model().addTomoObj(scan)
+        assert (
+            self._widget.model().data(
+                self._widget.model().index(0, 1), qt.Qt.DisplayRole
+            )
+            == first_expected_scan
+        )
+
+    def testWithPixelSizeOnly(self):
+        """
+        make sure z ordering works when we are only aware about pixel size
+        """
+        for scan in self.scans_with_pixel_size[::-1]:
+            self._widget.model().addTomoObj(scan)
+
+        # try adding some metadata to object
+        scans = self._widget.model()._objs
+        scans = self._widget.model()._objs
+        scans[0].stitching_metadata = StitchingMetadata(tomo_obj=scans[0])
+        scans[1].stitching_metadata = QStitchingMetadata(tomo_obj=scans[1])
+
+        scans[0].stitching_metadata._pos_as_m = (0.1, 1, 2)
+        scans[1].stitching_metadata._pos_as_m = (-0.03, 1, 2)
+        scans[2].stitching_metadata._pos_as_m = (0.23, 1, 2)
+
+        self._widget.model().reorder_objs()
+        self._widget.model().layoutChanged.emit()
+
+        assert (
+            self._widget.model().data(
+                self._widget.model().index(0, 1), qt.Qt.DisplayRole
+            )
+            == scans[2].get_identifier().short_description()
+        )
+        assert (
+            self._widget.model().data(
+                self._widget.model().index(1, 1), qt.Qt.DisplayRole
+            )
+            == scans[0].get_identifier().short_description()
+        )
+        assert (
+            self._widget.model().data(
+                self._widget.model().index(2, 1), qt.Qt.DisplayRole
+            )
+            == scans[1].get_identifier().short_description()
+        )
+
+    def testWithoutMetadata(self):
+        """
+        make sure tomo obj are still displayed even if there is no metadata at all
+        """
+        for scan in self.scans_without_metadata[::-1]:
+            self._widget.model().addTomoObj(scan)
+        # try adding some metadata to object
+        scans = self._widget.model()._objs
+        scans[0].stitching_metadata = StitchingMetadata(tomo_obj=scans[0])
+        scans[1].stitching_metadata = QStitchingMetadata(tomo_obj=scans[1])
+
+        scans[0].stitching_metadata._pos_as_px = (12, None, 2)
+        scans[1].stitching_metadata._pos_as_px = (-12, None, None)
+        scans[2].stitching_metadata._pos_as_px = (9999, None, None)
+
+        self._widget.model().reorder_objs()
+        self._widget.model().layoutChanged.emit()
+
+        assert (
+            self._widget.model().data(
+                self._widget.model().index(0, 1), qt.Qt.DisplayRole
+            )
+            == scans[2].get_identifier().short_description()
+        )
+        assert (
+            self._widget.model().data(
+                self._widget.model().index(1, 1), qt.Qt.DisplayRole
+            )
+            == scans[0].get_identifier().short_description()
+        )
+        assert (
+            self._widget.model().data(
+                self._widget.model().index(2, 1), qt.Qt.DisplayRole
+            )
+            == scans[1].get_identifier().short_description()
+        )

tomwer/gui/stitching/z_stitching/tests/test_stitching_window.py

@@ -0,0 +1,51 @@
+import os
+import shutil
+import tempfile
+
+from silx.gui import qt
+from silx.gui.utils.testutils import TestCaseQt
+
+from tomwer.gui.stitching.tests.utils import create_scans_z_serie
+from tomwer.gui.stitching.stitching import ZStitchingWindow
+
+
+class TestZStichingWindow(TestCaseQt):
+    """
+    Test high level z stitching definition
+    """
+
+    def setUp(self):
+        super().setUp()
+        self._tmp_path = tempfile.mkdtemp()
+        self.scans = create_scans_z_serie(
+            os.path.join(self._tmp_path, "case1"),
+            z_positions_m=(0.200, 0.205, 0.210),
+            pixel_size=0.001,
+            raw_frame_width=100,
+        )
+
+        self._widget = ZStitchingWindow()
+
+    def tearDown(self):
+        self._widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self._widget.close()
+        self._widget = None
+        while self.qapp.hasPendingEvents():
+            self.qapp.processEvents()
+        shutil.rmtree(self._tmp_path)
+
+    @staticmethod
+    def checkNbReceivers(scan, nb_receivers):
+        return (
+            scan.stitching_metadata.receivers(scan.stitching_metadata.sigChanged)
+            == nb_receivers
+        )
+
+    def test(self):
+        self._widget.show()
+        # fill the widget with scans
+
+        scan_0, scan_1, scan_2 = self.scans
+        for scan in self.scans:
+            self._widget.addTomoObj(scan)
+            # note: add the sigChanged to the z oredred list 'update z' slot

tomwer/gui/utils/test/test_completer.py

@@ -0,0 +1,67 @@
+# coding: utf-8
+# /*##########################################################################
+#
+# Copyright (c) 2016-2017 European Synchrotron Radiation Facility
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# ###########################################################################*/
+
+"""module defining dedicated completer"""
+
+
+__authors__ = ["H. Payno"]
+__license__ = "MIT"
+__date__ = "23/03/2022"
+
+
+import pytest
+from silx.gui import qt
+from silx.gui.utils.testutils import TestCaseQt
+
+from tomwer.gui.utils.completer import UrlCompleterDialog
+from tomwer.tests.utils import skip_gui_test
+
+
+@pytest.mark.skipif(skip_gui_test(), reason="skip gui test")
+class TestUrlCompleterDialog(TestCaseQt):
+    def setUp(self):
+        super().setUp()
+        self._urls = (
+            "test",
+            "test1",
+            "test2",
+        )
+        self._dialog = UrlCompleterDialog(
+            urls=self._urls,
+            current_url="test",
+        )
+
+    def tearDown(self):
+        self._dialog.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self._dialog.close()
+        self._dialog = None
+        super().tearDown()
+
+    def test(self):
+        """simple test on the dialog behavior"""
+        assert self._dialog._buttons.button(qt.QDialogButtonBox.Ok).isEnabled()
+        self._dialog._completerWidget.setText("toto")
+        self.qapp.processEvents()
+        assert not self._dialog._buttons.button(qt.QDialogButtonBox.Ok).isEnabled()

tomwer/gui/utils/test/test_line_selector.py

@@ -0,0 +1,21 @@
+import numpy
+
+from tomwer.gui.utils.lineselector.lineselector import QSliceSelectorDialog
+from tomwer.tests.conftest import qtapp  # noqa F401
+
+
+def test_line_selector(
+    qtapp,  # noqa F811
+):
+    dialog = QSliceSelectorDialog(parent=None)
+    dialog.setData(
+        numpy.ones((100, 100)),
+    )
+    dialog.mainWidget.addSlice(2)
+    dialog.mainWidget.addSlice(12)
+    assert dialog.getSelection() == (2, 12)
+    dialog.mainWidget.removeSlice(12)
+    assert dialog.getSelection() == (2,)
+    dialog.setSelection((12, 23))
+    assert dialog.getSelection() == (12, 23)
+    assert dialog.mainWidget.nSelected() == 2

tomwer/gui/utils/test/test_splashscreen.py

@@ -0,0 +1,8 @@
+from silx.gui import qt
+
+from tomwer.gui.utils.splashscreen import getMainSplashScreen
+from tomwer.tests.conftest import qtapp  # noqa F401
+
+
+def test_get_splash_screen(qtapp):  # noqa F401
+    assert isinstance(getMainSplashScreen(), qt.QSplashScreen)

tomwer/gui/utils/test/test_vignettes.py

@@ -0,0 +1,68 @@
+"""
+test vignettes
+"""
+
+import time
+import numpy
+import pytest
+from silx.gui import qt
+from silx.gui.utils.testutils import TestCaseQt
+
+from tomwer.core.process.reconstruction.scores.scores import ComputedScore, ScoreMethod
+from tomwer.gui.utils.vignettes import VignettesQDialog
+from tomwer.tests.utils import skip_gui_test
+
+
+@pytest.mark.skipif(skip_gui_test(), reason="skip gui test")
+class TestVignettes(TestCaseQt):
+    def setUp(self):
+        super().setUp()
+        self._window = VignettesQDialog(
+            value_name="cor",
+            score_name="score",
+        )
+
+    def tearDown(self):
+        self._window.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self._window.close()
+        self._window = None
+        super().tearDown()
+
+    def test(self):
+        self._window.setScores(
+            scores={
+                "3": (numpy.ones((100, 100)), ComputedScore(tv=2.0, std=3.2)),
+                "7": (numpy.zeros((100, 100)), ComputedScore(tv=25, std=0.6)),
+            },
+            score_method="standard deviation",
+        )
+        self._window.show()
+        self.qWaitForWindowExposed(self._window)
+
+        def assert_scores_are_equal(scores_1, scores_2):
+            assert scores_1.keys() == scores_2.keys()
+            for key, (data_1, computed_score_1) in scores_1.items():
+                data_2, computed_score_2 = scores_2[key]
+                numpy.testing.assert_array_almost_equal(data_1, data_2)
+                assert computed_score_1 == computed_score_2
+
+        scores, score_method = self._window._vignettesWidget.getScores()
+        assert_scores_are_equal(
+            scores_1=scores,
+            scores_2={
+                "3": (numpy.ones((100, 100)), ComputedScore(std=3.2, tv=None)),
+                "7": (numpy.zeros((100, 100)), ComputedScore(std=0.6, tv=None)),
+            },
+        )
+        assert score_method is ScoreMethod.STD
+
+        self._window.setNbColumn(4)
+        self._window.setNbColumn(2)
+        with pytest.raises(ValueError):
+            self._window.setNbColumn(20)
+        self._window.setNbColumn("auto")
+
+        self._window.resize(qt.QSize(400, 400))
+        self.qapp.processEvents()
+        time.sleep(VignettesQDialog.RESIZE_MAX_TIME * 2 / 1000)
+        self.qapp.processEvents()

tomwer/io/utils/h5pyutils.py

@@ -35,7 +35,7 @@ import contextlib
 
 import h5py
 from silx.io.url import DataUrl
-from tomoscan.io import HDF5File, get_swmr_mode
+from silx.io.utils import open as open_hdf5
 
 
 class _BaseReader(contextlib.AbstractContextManager):
@@ -60,9 +60,7 @@ class EntryReader(_BaseReader):
     """Context manager used to read a bliss node"""
 
     def __enter__(self):
-        self._file_handler = HDF5File(
-            filename=self._url.file_path(), mode="r", swmr=get_swmr_mode()
-        )
+        self._file_handler = open_hdf5(filename=self._url.file_path())
         entry = self._file_handler[self._url.data_path()]
         if not isinstance(entry, h5py.Group):
             raise ValueError("Data path should point to a bliss node (h5py.Group)")
@@ -73,9 +71,7 @@ class DatasetReader(_BaseReader):
     """Context manager used to read a bliss node"""
 
     def __enter__(self):
-        self._file_handler = HDF5File(
-            filename=self._url.file_path(), mode="r", swmr=get_swmr_mode()
-        )
+        self._file_handler = open_hdf5(filename=self._url.file_path())
         entry = self._file_handler[self._url.data_path()]
         if not isinstance(entry, h5py.Dataset):
             raise ValueError("Data path should point to a dtaset (h5py.Dataset)")

tomwer/io/utils/test/test_raw_and_processed_data.py

@@ -0,0 +1,10 @@
+from tomwer.io.utils.raw_and_processed_data import file_is_on_processed_data
+
+
+def test_file_is_on_processed_data():
+    """test file_is_on_processed_data function"""
+    assert file_is_on_processed_data("/path/to/file") == False
+    assert file_is_on_processed_data("/path/to/PROCESSED_DATA/file") == True
+    assert file_is_on_processed_data("/path/to/RAW_DATA/file") == False
+    assert file_is_on_processed_data("/path/to/RAW_DATA/PROCESSED_DATA/file") == True
+    assert file_is_on_processed_data("/path/to/PROCESSED_DATA/RAW_DATA/file") == False