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

tomwer/gui/control/serie/test/test_creator.py

@@ -0,0 +1,451 @@
+# 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.
+#
+# ###########################################################################*/
+
+__authors__ = ["H. Payno"]
+__license__ = "MIT"
+__date__ = "12/01/2022"
+
+
+import os
+import shutil
+import tempfile
+
+from silx.gui import qt
+from silx.gui.utils.testutils import SignalListener, TestCaseQt
+from tomoscan.serie import Serie
+
+from tomwer.core.scan.nxtomoscan import NXtomoScan
+from tomwer.core.utils.scanutils import MockEDF, MockNXtomo
+from tomwer.core.volume.hdf5volume import HDF5Volume
+from tomwer.gui.control.serie.seriecreator import (
+    SerieDefinition,
+    SerieHistoryDialog,
+    SerieManualControlDialog,
+    SerieManualFromTomoObj,
+    SerieTree,
+    SerieWidget,
+)
+
+
+class _MockScanBase:
+    def init(self):
+        n_hdf5_scan = 11
+        self._scans = []
+        self._root_dir = tempfile.mkdtemp()
+        for i_scan in range(n_hdf5_scan):
+            scan_path = os.path.join(self._root_dir, f"scan_{i_scan}")
+            scan = MockNXtomo(scan_path=scan_path, n_proj=10, n_ini_proj=0).scan
+            self._scans.append(scan)
+        n_edf_scan = 4
+        for i_scan in range(n_edf_scan):
+            scan_path = os.path.join(self._root_dir, f"scan_{i_scan}")
+            scan = MockEDF.mockScan(
+                scanID=scan_path,
+                nRadio=10,
+                dim=10,
+            )
+            self._scans.append(scan)
+
+    def close(self):
+        shutil.rmtree(self._root_dir)
+
+
+class _MockSerieBase(_MockScanBase):
+    def init(self):
+        super().init()
+        self._series = [
+            Serie("serie1", self._scans[0:1], use_identifiers=True),
+            Serie("serie2", self._scans[1:5], use_identifiers=False),
+            Serie("serie3", self._scans[5:11], use_identifiers=True),
+            Serie("serie4", self._scans[8:11], use_identifiers=True),
+            Serie("serie5", self._scans[-2:-1], use_identifiers=False),
+            Serie("serie6", self._scans[-5:], use_identifiers=True),
+        ]
+
+    def close(self):
+        self._series.clear()
+        super().close()
+
+
+class TestSerieTree(TestCaseQt, _MockSerieBase):
+    """Test the SerieTree widget"""
+
+    def setUp(self):
+        super().setUp()
+        super().init()
+        self._widget = SerieTree()
+
+    def tearDown(self):
+        self._widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self._widget.close()
+        self._widget = None
+        super().close()
+        super().tearDown()
+
+    def test_add_remove(self):
+        """Test adding and removing serie"""
+        self._widget.show()
+        self.qWaitForWindowExposed(self._widget)
+        for serie in self._series:
+            self._widget.addSerie(serie)
+        assert self._widget.n_series == 6
+        self._widget.removeSerie(self._series[3])
+        assert self._widget.n_series == 5
+        self._widget.removeSerie(self._series[2])
+        self._widget.removeSerie(self._series[1])
+        self._widget.removeSerie(self._series[0])
+        # make sure no error is raised if we try to remove twine the same serie
+        self._widget.removeSerie(self._series[0])
+        assert self._widget.n_series == 2
+        self._widget.addSerie(self._series[1])
+        self._widget.addSerie(self._series[2])
+        assert self._widget.n_series == 4
+
+    def test_selection(self):
+        """Test selection of the SerieTree"""
+        self._widget.show()
+        self.qWaitForWindowExposed(self._widget)
+        for serie in self._series:
+            self._widget.addSerie(serie)
+
+        selection = (self._series[2], self._series[3])
+        self._widget.setSelectedSeries(selection)
+        assert self._widget.getSelectedSeries() == selection
+        self._widget.clearSelection()
+        assert self._widget.getSelectedSeries() == ()
+
+
+class TestSerieHistoryDialog(TestCaseQt, _MockSerieBase):
+    """Test the SerieHistoryDialog"""
+
+    def setUp(self):
+        super().setUp()
+        super().init()
+        self._widget = SerieHistoryDialog()
+
+        # create listener for the nabu widget
+        self.signal_listener = SignalListener()
+
+        # connect signal / slot
+        self._widget.sigSerieSend.connect(self.signal_listener)
+
+    def tearDown(self):
+        self._widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self._widget.close()
+        self._widget = None
+        super().close()
+        super().tearDown()
+
+    def test(self):
+        self._widget.show()
+        self.qWaitForWindowExposed(self._widget)
+        for serie in self._series:
+            self._widget.addSerie(serie)
+
+        selection = (self._series[0], self._series[4])
+        self._widget.setSelectedSeries(selection)
+        assert self._widget.getSelectedSeries() == selection
+        assert self.signal_listener.callCount() == 0
+        self._widget._sendButton.clicked.emit()
+        self.qapp.processEvents()
+        assert self.signal_listener.callCount() == 2
+        assert self._widget.getSelectedSeries() == selection
+        self.signal_listener.clear()
+        self._widget._clearButton.clicked.emit()
+        assert self._widget.getSelectedSeries() == ()
+        assert self.signal_listener.callCount() == 0
+        self._widget._sendButton.clicked.emit()
+        assert self.signal_listener.callCount() == 0
+
+
+class TestSerieDefinition(TestCaseQt):
+    def setUp(self):
+        super().setUp()
+        self._widget = SerieDefinition()
+
+    def tearDown(self):
+        self._widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self._widget.close()
+        self._widget = None
+        super().tearDown()
+
+    def test_manual_selection(self):
+        self._widget.setMode("manual")
+        self._widget.show()
+        self.qWaitForWindowExposed(self._widget)
+        assert not self._widget._automaticDefWidget.isVisible()
+        assert self._widget._manualDefWidget.isVisible()
+
+    def test_automatic_selection(self):
+        self._widget.setMode("auto")
+        self._widget.show()
+        self.qWaitForWindowExposed(self._widget)
+        assert self._widget._automaticDefWidget.isVisible()
+        assert not self._widget._manualDefWidget.isVisible()
+
+
+class TestSerieManualDefinitionDialog(TestCaseQt, _MockScanBase):
+    """Test interaction with the serie manual definition"""
+
+    def setUp(self):
+        self._widget = SerieManualControlDialog()
+        super().setUp()
+        super().init()
+
+    def tearDown(self):
+        self._widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self._widget.close()
+        self._widget = None
+        super().close()
+        super().tearDown()
+
+    def test(self):
+        self._widget.show()
+        self.qWaitForWindowExposed(self._widget)
+
+        self._widget.setSerieName("serie test")
+        self.qapp.processEvents()
+        assert self._widget.getSerieName() == "serie test"
+
+        self._widget._mainWidget._newSerieWidget._serieTree.rootItem.setText(
+            0, "new serie"
+        )
+        self.qapp.processEvents()
+        assert self._widget.getSerieName() == "new serie"
+
+        for scan in self._scans[:5]:
+            self._widget.addScan(scan)
+
+        self.assertEqual(self._widget.n_tomo_objs, len(self._scans[:5]))
+        self._widget.removeScan(self._scans[0])
+        self.assertEqual(self._widget.n_tomo_objs, len(self._scans[:5]) - 1)
+
+        series_scan = tuple(self._scans[1:5])
+        assert isinstance(series_scan, tuple)
+
+        current_serie = self._widget.getSerie(use_identifiers=True)
+        assert isinstance(current_serie, Serie)
+        serie_test_1 = Serie(
+            name="new serie", iterable=series_scan, use_identifiers=True
+        )
+
+        self.assertEqual(serie_test_1, current_serie)
+        serie_test_2 = Serie(name="test", iterable=series_scan, use_identifiers=True)
+        assert serie_test_2.name == "test"
+        assert current_serie.name == "new serie"
+        self.assertNotEqual(serie_test_2, current_serie)
+
+        self._widget.setSelectedScans([self._scans[2]])
+        self._widget.getSelectedScans() == (self._scans[2],)
+        self._widget.removeSelectedScans()
+        self.assertEqual(self._widget.n_tomo_objs, len(self._scans[:5]) - 2)
+        self._widget.getSelectedScans() == tuple()
+
+        self._widget.clearSerie()
+        self.assertEqual(self._widget.n_tomo_objs, 0)
+        self.assertEqual(Serie(name="new serie"), self._widget.getSerie())
+
+        # test adding an nx file
+        hdf5_scan = self._scans[0]
+        assert isinstance(hdf5_scan, NXtomoScan)
+        self._widget.addScanFromNxFile(hdf5_scan.master_file)
+        self.assertEqual(self._widget.n_tomo_objs, 1)
+
+
+class TestSerieWidget(TestCaseQt, _MockSerieBase):
+    """
+    Test the SerieWidget
+    """
+
+    def setUp(self):
+        super().setUp()
+        super().init()
+        self._widget = SerieWidget()
+        # create listeners
+        self.signal_send_serie_listener = SignalListener()
+        self.signal_serie_changed_listener = SignalListener()
+        self.signal_history_changed_listener = SignalListener()
+
+        # connect signal / slot
+        self._widget.sigSerieSend.connect(self.signal_send_serie_listener)
+        self._widget.sigCurrentSerieChanged.connect(self.signal_serie_changed_listener)
+        self._widget.sigHistoryChanged.connect(self.signal_history_changed_listener)
+
+    def tearDown(self):
+        self._widget.sigSerieSend.disconnect(self.signal_send_serie_listener)
+        self._widget.sigCurrentSerieChanged.disconnect(
+            self.signal_serie_changed_listener
+        )
+        self._widget.sigHistoryChanged.disconnect(self.signal_history_changed_listener)
+
+        self.signal_send_serie_listener = None
+        self.signal_serie_changed_listener = None
+        self.signal_history_changed_listener = None
+
+        self._widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self._widget.close()
+        self._widget = None
+        super().close()
+        super().tearDown()
+
+    def test(self):
+        self._widget.show()
+        self.qWaitForWindowExposed(self._widget)
+        self._series[3].name = "toto serie"
+        for serie in self._series[2:5]:
+            self._widget.getHistoryWidget().addSerie(serie)
+        self._widget.setMode("history")
+        self._widget.setMode("serie definition", "manual")
+        self._widget.getDefinitionWidget().getManualDefinitionWidget().setSerieName(
+            "new serie"
+        )
+
+        self.assertEqual(
+            len(
+                self._widget.getDefinitionWidget()
+                .getManualDefinitionWidget()
+                .getSerie()
+            ),
+            0,
+        )
+
+        self._widget.getHistoryWidget().setSelectedSeries(
+            [
+                self._series[3],
+            ]
+        )
+        assert len(self._widget.getHistoryWidget().getSelectedSeries()) == 1
+
+        self.signal_serie_changed_listener.clear()
+        self._widget.getHistoryWidget().editSelected()
+        self.qapp.processEvents()
+        assert self.signal_serie_changed_listener.callCount() == 1
+
+        self.assertEqual(
+            self._widget.getDefinitionWidget()
+            .getManualDefinitionWidget()
+            .getSerie()
+            .name,
+            "toto serie",
+        )
+
+        self.assertEqual(
+            self._widget.getDefinitionWidget()
+            .getManualDefinitionWidget()
+            .getSerie(use_identifiers=True),
+            self._series[3],
+        )
+
+        self.signal_serie_changed_listener.clear()
+        self._widget.getDefinitionWidget().getManualDefinitionWidget().addToCurrentSerie(
+            self._scans[0]
+        )
+        self.qapp.processEvents()
+        assert self.signal_serie_changed_listener.callCount() == 1
+
+        expected_scans = self._scans[8:11]
+        expected_scans.append(self._scans[0])
+        expected_serie = Serie("toto serie", expected_scans, use_identifiers=True)
+
+        self.assertEqual(
+            self._widget.getDefinitionWidget()
+            .getManualDefinitionWidget()
+            .getSerie(use_identifiers=True),
+            expected_serie,
+        )
+
+        # check send edited serie
+        self.signal_history_changed_listener.clear()
+        self.signal_send_serie_listener.clear()
+        self.qapp.processEvents()
+
+        # check send selected from the history
+        self.signal_send_serie_listener.clear()
+        self._widget.getHistoryWidget().setSelectedSeries(
+            [
+                self._series[4],
+            ]
+        )
+        assert len(self._widget.getHistoryWidget().getSelectedSeries()) == 1
+        self._widget.getHistoryWidget().sendSelected()
+        assert self.signal_send_serie_listener.callCount() == 1
+
+
+class TestSerieManualFromTomoObj(TestCaseQt):
+    """
+    test the SerieManualFromTomoObj widget
+    """
+
+    def setUp(self):
+        super().setUp()
+        self._tmp_dir = tempfile.mkdtemp()
+        self._widget = SerieManualFromTomoObj()
+        self._volume_1 = HDF5Volume(
+            file_path=os.path.join(self._tmp_dir, "vol1.hdf5"),
+            data_path="data",
+        )
+        self._volume_2 = HDF5Volume(
+            file_path=os.path.join(self._tmp_dir, "vol2.hdf"),
+            data_path="data",
+        )
+        self._volume_3 = HDF5Volume(
+            file_path=os.path.join(self._tmp_dir, "vol3.nx"),
+            data_path="data",
+        )
+        self._scan_1 = MockNXtomo(
+            scan_path=os.path.join(self._tmp_dir, "scan_1"), n_proj=10, n_ini_proj=10
+        ).scan
+        self._scan_2 = MockNXtomo(
+            scan_path=os.path.join(self._tmp_dir, "scan_2"), n_proj=10, n_ini_proj=10
+        ).scan
+
+    def tearDown(self):
+        shutil.rmtree(self._tmp_dir)
+        self._widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self._widget.close()
+        self._widget = None
+        return super().tearDown()
+
+    def test(self):
+        self._widget.show()
+        for tomo_obj in (
+            self._volume_1,
+            self._volume_2,
+            self._volume_3,
+            self._scan_1,
+            self._scan_2,
+        ):
+            self._widget.addTomoObj(tomo_obj)
+
+        current_serie = self._widget.getSerie()
+        assert isinstance(current_serie, Serie)
+        assert len(current_serie) == 0
+
+        for tomo_obj in (self._volume_1, self._volume_2):
+            self._widget.addToCurrentSerie(tomo_obj)
+
+        current_serie = self._widget.getSerie()
+        assert isinstance(current_serie, Serie)
+        assert len(current_serie) == 2

tomwer/gui/control/serie/test/test_nxtomo_concatenate.py

@@ -0,0 +1,21 @@
+from tomwer.tests.conftest import qtapp  # noqa F401
+from tomwer.gui.control.serie.nxtomoconcatenate import NXtomoConcatenateWidget
+
+
+def test_NXtomoConcatenateWidget(
+    qtapp,  # noqa F811
+):
+    """simple test of the NXtomoConcatenateWidget"""
+    widget = NXtomoConcatenateWidget()
+    assert widget.getConfiguration() == {
+        "output_file": "{common_path}/concatenate.nx",
+        "output_entry": "entry0000",
+        "overwrite": False,
+    }
+    config = {
+        "output_file": "helical.hdf5",
+        "output_entry": "my_entry",
+        "overwrite": True,
+    }
+    widget.setConfiguration(config=config)
+    assert widget.getConfiguration() == config

tomwer/gui/edit/dkrfpatch.py

@@ -36,8 +36,8 @@ from silx.gui import qt
 from silx.gui.dialog.DataFileDialog import DataFileDialog
 from silx.io.url import DataUrl
 from silx.io.utils import h5py_read_dataset
+from silx.io.utils import open as open_hdf5
 from nxtomo.nxobject.nxdetector import ImageKey
-from tomoscan.io import HDF5File, get_swmr_mode
 
 import tomwer.core.utils.nxtomoutils as nxtomo_utils
 from tomwer.core.scan.nxtomoscan import NXtomoScan
@@ -83,7 +83,7 @@ class _DarkOrFlatUrl(qt.QWidget):
         url = self._redirectDataPath(url, logger=_logger)
 
         def dataset_invalid(url):
-            with HDF5File(url.file_path(), mode="r", swmr=get_swmr_mode()) as h5s:
+            with open_hdf5(url.file_path()) as h5s:
                 if not isinstance(h5s[url.data_path()], h5py.Dataset):
                     return True
             return False
@@ -113,7 +113,7 @@ class _DarkOrFlatUrl(qt.QWidget):
 
     def _redirectDataPath(self, url, logger=None):
         try:
-            with HDF5File(url.file_path(), mode="r", swmr=get_swmr_mode()) as h5s:
+            with open_hdf5(url.file_path()) as h5s:
                 node = h5s[url.data_path()]
 
                 if NXtomoScan.entry_is_nx_tomo(node):
@@ -188,7 +188,7 @@ class _DarkOrFlatUrl(qt.QWidget):
     def _getImageKey(self, url):
         # if we are on a 'detector / data dataset' then we can try to reach
         # image_key information
-        with HDF5File(url.file_path(), mode="r", swmr=get_swmr_mode()) as h5s:
+        with open_hdf5(url.file_path()) as h5s:
             dataset = h5s[url.data_path()]
             grp_parent = dataset.parent
             if grp_parent is not None and NXtomoScan.is_nxdetector(grp_parent):

tomwer/gui/edit/nxtomowarmer.py

@@ -1,9 +1,10 @@
 from typing import Optional
 import h5py
 from silx.gui import qt
+from silx.io.utils import open as open_hdf5
+
 from tomwer.core.scan.nxtomoscan import NXtomoScan
 from tomwer.gui import icons
-from tomoscan.io import HDF5File, get_swmr_mode
 
 
 class NXtomoProxyWarmer(qt.QWidget):
@@ -44,7 +45,7 @@ class NXtomoProxyWarmer(qt.QWidget):
         if scan is None:
             self._activateWarning(False)
         elif isinstance(scan, NXtomoScan):
-            with HDF5File(scan.master_file, mode="r", swmr=get_swmr_mode()) as h5f:
+            with open_hdf5(scan.master_file) as h5f:
                 entry = h5f.get(
                     name=scan.entry, getclass=True, getlink=True, default=None
                 )

tomwer/gui/icat/test/test_create_screenshots_gui.py

@@ -0,0 +1,23 @@
+from tomwer.tests.conftest import qtapp  # noqa F401
+from tomwer.gui.icat.createscreenshots import CreateRawDataScreenshotsWidget
+
+
+def test_CreateRawDataScreenshotsWidget(qtapp):  # noqa F811
+    widget = CreateRawDataScreenshotsWidget()
+
+    assert widget.getConfiguration() == {
+        "raw_projections_required": True,
+        "raw_projections_each": 90,
+        "raw_darks_required": True,
+        "raw_flats_required": True,
+    }
+
+    new_config = {
+        "raw_projections_required": True,
+        "raw_projections_each": 26,
+        "raw_darks_required": False,
+        "raw_flats_required": False,
+    }
+    widget.setConfiguration(new_config)
+
+    assert widget.getConfiguration() == new_config

tomwer/gui/icat/test/test_gallery_gui.py

@@ -0,0 +1,37 @@
+from tomwer.tests.conftest import qtapp  # noqa F401
+from tomwer.gui.icat.gallery import GalleryWidget
+
+
+def test_GalleryWidget(
+    qtapp,  # noqa F811
+):
+    widget = GalleryWidget()
+    assert widget.getConfiguration() == {
+        "beamline": "bm05",
+        "beamline_auto_update": True,
+        "dataset": "",
+        "dataset_auto_update": True,
+        "proposal": "",
+        "proposal_auto_update": True,
+        "output_format": "png",
+        "output_location_mode": "dataset gallery",
+        "custom_output": "",
+        "overwrite": True,
+        "binning": "16x16",
+    }
+
+    new_config = {
+        "beamline": "id19",
+        "beamline_auto_update": False,
+        "dataset": "my_dataset",
+        "dataset_auto_update": False,
+        "proposal": "inh99",
+        "proposal_auto_update": False,
+        "output_location_mode": "custom",
+        "output_format": "jpg",
+        "custom_output": "",
+        "overwrite": False,
+        "binning": "4x4",
+    }
+    widget.setConfiguration(new_config)
+    assert widget.getConfiguration() == new_config

tomwer/gui/imagefromfile.py

@@ -34,7 +34,7 @@ import logging
 
 from silx.gui import qt
 from silx.io.url import DataUrl
-from tomoscan.io import HDF5File, get_swmr_mode
+from silx.io.utils import open as open_hdf5
 
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.synctools.imageloaderthread import ImageLoaderThread
@@ -71,7 +71,7 @@ class ImageFromFile(_Image):
 
                 def get_nabu_entry():
                     try:
-                        with HDF5File(_file, mode="r", swmr=get_swmr_mode()) as h5s:
+                        with open_hdf5(_file) as h5s:
                             for node in h5s:
                                 if "reconstruction" in h5s[node]:
                                     return "/".join(