tomwer 1.3.27__py3-none-any.whl → 1.4.0rc0__py3-none-any.whl

tomwer/tests/orangecontrib/tomwer/widgets/tests/test_darkref.py

@@ -0,0 +1,225 @@
+# coding: utf-8
+from __future__ import annotations
+
+import gc
+import logging
+import os
+import shutil
+import tempfile
+import time
+
+import pytest
+from silx.gui import qt
+from silx.gui.utils.testutils import TestCaseQt
+
+from orangecontrib.tomwer.widgets.reconstruction.DarkRefAndCopyOW import (
+    DarkRefAndCopyOW,
+)
+from tomwer.core.process.reconstruction.darkref.darkrefs import DarkRefsTask
+from tomwer.core.process.reconstruction.darkref.params import ReduceMethod as DkrfMethod
+from tomwer.core.process.reconstruction.darkref.settings import (
+    DARKHST_PREFIX,
+    REFHST_PREFIX,
+)
+from tomwer.core.scan.edfscan import EDFTomoScan
+from tomwer.core.utils.scanutils import MockEDF, MockNXtomo
+from tomwer.synctools.darkref import QDKRFRP
+
+logging.disable(logging.INFO)
+
+
+class TestEDFDarkRefWidget(TestCaseQt):
+    """class testing the DarkRefWidget"""
+
+    def setUp(self):
+        TestCaseQt.setUp(self)
+        self._recons_params = QDKRFRP()
+        self.widget = DarkRefAndCopyOW(parent=None, reconsparams=self._recons_params)
+
+    def tearDown(self):
+        self.widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self.widget.close()
+        self.widget = None
+        self.qapp.processEvents()
+        gc.collect()
+
+    def testSyncRead(self):
+        """Make sure any modification on the self._reconsParams is
+        applied on the GUI"""
+        rp = self._recons_params
+        self.assertTrue(rp["REFSRMV"] is False)
+        self.assertFalse(
+            self.widget.widget.mainWidget.tabGeneral._rmOptionCB.isChecked()
+        )
+        rp["REFSRMV"] = True
+        self.assertTrue(
+            self.widget.widget.mainWidget.tabGeneral._rmOptionCB.isChecked()
+        )
+
+        pattern = self.widget.widget.mainWidget.tabExpert._refLE.text()
+        newText = "popo.*"
+        assert pattern != newText
+        rp["RFFILE"] = newText
+        self.assertTrue(
+            self.widget.widget.mainWidget.tabExpert._refLE.text() == newText
+        )
+
+    def testSyncWrite(self):
+        """Test that if we edit through the :class:`DarkRefWidget` then the
+        modification are fall back into the self._reconsParams"""
+        rp = self._recons_params
+
+        # test patterns
+        pattern = self.widget.widget.mainWidget.tabExpert._refLE.text()
+        newText = "popo.*"
+        assert pattern != newText
+        self.widget.widget.mainWidget.tabExpert._refLE.setText(newText)
+        self.widget.widget.mainWidget.tabExpert._refLE.editingFinished.emit()
+        qt.QApplication.instance().processEvents()
+        self.assertTrue(rp["RFFILE"] == newText)
+        self.widget.widget.mainWidget.tabExpert._darkLE.setText(newText)
+        self.widget.widget.mainWidget.tabExpert._darkLE.editingFinished.emit()
+        qt.QApplication.instance().processEvents()
+        self.assertTrue(rp["DKFILE"] == newText)
+
+        # test calc mode
+        self.widget.widget.mainWidget.tabGeneral._darkWCB.setMode(DkrfMethod.NONE)
+        self.widget.widget.mainWidget.tabGeneral._refWCB.setMode(DkrfMethod.MEDIAN)
+        self.assertTrue(rp["DARKCAL"] == DkrfMethod.NONE)
+        self.assertTrue(rp["REFSCAL"] == DkrfMethod.MEDIAN)
+
+        # test options
+        cuRm = self.widget.widget.mainWidget.tabGeneral._rmOptionCB.isChecked()
+        self.widget.widget.mainWidget.tabGeneral._rmOptionCB.setChecked(not cuRm)
+        self.assertTrue(rp["REFSRMV"] == (not cuRm))
+        self.assertTrue(rp["DARKRMV"] == (not cuRm))
+
+        cuSkip = self.widget.widget.mainWidget.tabGeneral._skipOptionCB.isChecked()
+        self.widget.widget.mainWidget.tabGeneral._skipOptionCB.setChecked(not cuSkip)
+        # warning : here value of skip and overwrite are of course inverse
+        self.assertTrue(rp["DARKOVE"] == cuSkip)
+        self.assertTrue(rp["REFSOVE"] == cuSkip)
+
+
+@pytest.mark.skip("Fail on CI")
+class TestDarkRefCopyWithEDFAndHDF5(TestCaseQt):
+    """Test the DarkRefCopy orange widget behaviour"""
+
+    def setUp(self) -> None:
+        TestCaseQt.setUp(self)
+        self._folder = tempfile.mkdtemp()
+
+        # define scans to be treated
+        hdf5_mock_with_refs = MockNXtomo(
+            scan_path=os.path.join(self._folder, "h5_with_refs"),
+            n_proj=10,
+            n_ini_proj=10,
+            dim=20,
+            create_ini_flat=True,
+            create_ini_dark=True,
+            create_final_flat=False,
+        )
+        self.hdf5_acquisition_with_refs = hdf5_mock_with_refs.scan
+
+        hdf5_mock_without_refs = MockNXtomo(
+            scan_path=os.path.join(self._folder, "h5_without_refs"),
+            n_proj=10,
+            n_ini_proj=10,
+            dim=20,
+            create_ini_flat=False,
+            create_ini_dark=False,
+        )
+        self.hdf5_acquisition_without_refs = hdf5_mock_without_refs.scan
+
+        hdf5_mock_without_refs_incoherent_dim = MockNXtomo(
+            scan_path=os.path.join(self._folder, "h5_without_refs_different_dim"),
+            n_proj=10,
+            n_ini_proj=10,
+            dim=21,
+            create_ini_flat=False,
+            create_ini_dark=False,
+        )
+        self.hdf5_acquisition_without_refs_incoherent_dim = (
+            hdf5_mock_without_refs_incoherent_dim.scan
+        )
+
+        edf_mock_without_ref = MockEDF(
+            scan_path=os.path.join(self._folder, "edf_without_refs"), dim=20, n_radio=20
+        )
+        self.edf_acquisition_without_ref = EDFTomoScan(
+            scan=edf_mock_without_ref.scan_path
+        )
+
+        # processes set up
+        self._recons_params = QDKRFRP()
+        self.widget = DarkRefAndCopyOW(parent=None, reconsparams=self._recons_params)
+        self.widget.setForceSync(True)
+        self.widget.show()
+
+    def tearDown(self) -> None:
+        time.sleep(0.5)
+        while self.qapp.hasPendingEvents():
+            self.qapp.processEvents()
+        self.widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self.widget.close()
+        self.widget = None
+        shutil.rmtree(self._folder)
+        gc.collect()
+
+    def testCopyInactive(self):
+        self.widget.setCopyActive(False)
+
+        self.widget.process(self.hdf5_acquisition_with_refs)
+        self.assertTrue(os.path.exists(self.hdf5_acquisition_with_refs.process_file))
+
+        # make sure no dark or flats exists for the hdf5 without refs
+        for scan in (
+            self.hdf5_acquisition_without_refs_incoherent_dim,
+            self.hdf5_acquisition_without_refs,
+        ):
+            self.widget.process(scan)
+            self.assertFalse(os.path.exists(scan.process_file))
+
+        # make sure no dark or flats exists for the edf one
+        self.widget.process(self.edf_acquisition_without_ref)
+
+    def testCopyActive(self):
+        self.widget.setCopyActive(True)
+        self.widget.setModeAuto(True)
+
+        self.widget.process(self.hdf5_acquisition_with_refs)
+        self.assertTrue(os.path.exists(self.hdf5_acquisition_with_refs.process_file))
+        # 1. make sure dark has been processed for the one with ref
+        self.assertTrue(self.widget.hasDarkStored())
+        self.assertTrue(self.widget.hasFlatStored())
+
+        # 2. make sure copy has been processed for the the 'compatible hdf5'
+        self.widget.process(self.hdf5_acquisition_without_refs)
+        self.assertTrue(os.path.exists(self.hdf5_acquisition_without_refs.process_file))
+
+        # 3. make sure copy has been processed for the the 'compatible edf'
+        self.widget.process(self.edf_acquisition_without_ref)
+        self.assertEqual(
+            len(
+                DarkRefsTask.getRefHSTFiles(
+                    self.edf_acquisition_without_ref.path, prefix=REFHST_PREFIX
+                )
+            ),
+            2,
+        )
+        self.assertEqual(
+            len(
+                DarkRefsTask.getDarkHSTFiles(
+                    self.edf_acquisition_without_ref.path, prefix=DARKHST_PREFIX
+                )
+            ),
+            1,
+        )
+
+        # 4. make sure process but no copy made if incompatible size
+        self.widget.process(self.hdf5_acquisition_without_refs_incoherent_dim)
+        self.assertFalse(
+            os.path.exists(
+                self.hdf5_acquisition_without_refs_incoherent_dim.process_file
+            )
+        )

tomwer/tests/orangecontrib/tomwer/widgets/tests/test_foldertransfert.py

@@ -0,0 +1,105 @@
+# coding: utf-8
+from __future__ import annotations
+
+
+import gc
+import logging
+import os
+import shutil
+import tempfile
+import time
+from glob import glob
+
+from silx.gui import qt
+from silx.gui.utils.testutils import TestCaseQt
+
+from orangecontrib.tomwer.widgets.control.DataTransfertOW import DataTransfertOW
+from tomwer.core.scan.scanfactory import ScanFactory
+from tomwer.core.utils.scanutils import MockEDF
+
+logging.disable(logging.INFO)
+
+
+class TestEDFFolderTransfertWidget(TestCaseQt):
+    """class testing the DataTransfertOW within an EDF acquisition"""
+
+    def setUp(self):
+        TestCaseQt.setUp(self)
+        self.n_file = 10
+        self.sourcedir = tempfile.mkdtemp()
+        os.makedirs(self.sourcedir, exist_ok=True)
+        self.targettedir = tempfile.mkdtemp()
+        os.makedirs(self.targettedir, exist_ok=True)
+        MockEDF.fastMockAcquisition(self.sourcedir, n_radio=self.n_file)
+        self.scan = ScanFactory.create_scan_object(self.sourcedir)
+
+        self.folderTransWidget = DataTransfertOW()
+        self.folderTransWidget.turn_off_print = True
+        self.folderTransWidget.setDestDir(self.targettedir)
+        self.folderTransWidget._copying = False
+        self.folderTransWidget.setForceSync(True)
+
+    def tearDown(self):
+        self.folderTransWidget.settingsHandler.removeCallback(
+            self.folderTransWidget._updateSettingsVals
+        )
+        self.folderTransWidget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self.folderTransWidget.close()
+        self.folderTransWidget = None
+
+        if os.path.isdir(self.sourcedir):
+            shutil.rmtree(self.sourcedir)
+        if os.path.isdir(self.targettedir):
+            shutil.rmtree(self.targettedir)
+        gc.collect()
+
+    def testMoveFiles(self):
+        """
+        simple test that files are correctly moved
+        """
+        self.folderTransWidget._process(self.scan, move=True, noRsync=True)
+
+        outputdir = os.path.join(self.targettedir, os.path.basename(self.sourcedir))
+        timeout = 1
+        while (
+            (os.path.isdir(self.sourcedir))
+            and timeout > 0
+            or self.folderTransWidget.isCopying()
+        ):
+            timeout = timeout - 0.1
+            time.sleep(0.1)
+            self.qapp.processEvents()
+
+        self.assertTrue(os.path.isdir(outputdir))
+        self.assertTrue(self.checkDataCopied())
+
+    def testCopyFiles(self):
+        """
+        Simple test that file are copy and deleted
+        """
+        self.folderTransWidget._process(self.scan, move=False, noRsync=True)
+
+        timeout = 1
+        outputdir = os.path.join(self.targettedir, os.path.basename(self.sourcedir))
+        while (
+            os.path.isdir(self.sourcedir) and timeout > 0
+        ) or self.folderTransWidget.isCopying():
+            timeout = timeout - 0.1
+            time.sleep(0.1)
+            self.qapp.processEvents()
+
+        time.sleep(1)
+
+        self.assertTrue(os.path.isdir(outputdir))
+        self.assertTrue(self.checkDataCopied())
+
+    def checkDataCopied(self):
+        outputdir = os.path.join(self.targettedir, os.path.basename(self.sourcedir))
+        outputFiles = os.listdir(outputdir)
+        inputFile = glob(self.sourcedir)
+
+        return (
+            (len(inputFile) == 0)
+            and (len(outputFiles) == (self.n_file + 3))
+            and (not os.path.isdir(self.sourcedir))
+        )

tomwer/tests/orangecontrib/tomwer/widgets/visualization/tests/test_dataviewerow.py

@@ -0,0 +1,57 @@
+# coding: utf-8
+from __future__ import annotations
+
+
+import gc
+import os
+import shutil
+import tempfile
+
+from orangecanvas.scheme.readwrite import literal_dumps
+from silx.gui import qt
+from silx.gui.utils.testutils import TestCaseQt
+
+from orangecontrib.tomwer.widgets.visualization.DataViewerOW import DataViewerOW
+from tomwer.core.utils.scanutils import MockNXtomo
+
+
+class TestDataViewerOW(TestCaseQt):
+    def setUp(self):
+        self.tmp_dir = tempfile.mkdtemp()
+        self.scan = MockNXtomo(
+            scan_path=os.path.join(self.tmp_dir, "myscan"),
+            n_proj=20,
+            n_ini_proj=20,
+            dim=10,
+        ).scan
+        self.widget = DataViewerOW()
+
+    def tearDown(self):
+        self.widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self.widget.close()
+        self.widget = None
+        shutil.rmtree(self.tmp_dir)
+        self.qapp.processEvents()
+        gc.collect()
+
+    def test(self):
+        self.widget.addScan(self.scan)
+        for mode in (
+            "projections-radios",
+            "slices",
+            "raw darks",
+            "raw flats",
+            "reduced darks",
+            "reduced flats",
+        ):
+            self.widget.viewer.setDisplayMode(mode)
+            self.qapp.processEvents()
+
+    def test_literal_dumps(self):
+        """
+        test settings are correcly dump to literals (and load)
+        """
+        self.widget._updateSettings()
+        config = self.widget._viewer_config
+        literal_dumps(config)
+        self.widget._setSettings(config)

tomwer/tests/orangecontrib/tomwer/widgets/visualization/tests/test_diffviewerow.py

@@ -0,0 +1,39 @@
+# coding: utf-8
+from __future__ import annotations
+
+
+import gc
+import os
+import shutil
+import tempfile
+
+from silx.gui import qt
+from silx.gui.utils.testutils import TestCaseQt
+
+from orangecontrib.tomwer.widgets.visualization.DiffViewerOW import DiffViewerOW
+from tomwer.core.utils.scanutils import MockNXtomo
+
+
+class TestDiffViewerOW(TestCaseQt):
+    def setUp(self):
+        super().setUp()
+        self.tmp_dir = tempfile.mkdtemp()
+        os.makedirs(self.tmp_dir, exist_ok=True)
+        self.scan = MockNXtomo(
+            scan_path=os.path.join(self.tmp_dir, "myscan"),
+            n_proj=20,
+            n_ini_proj=20,
+            dim=10,
+        ).scan
+        self.widget = DiffViewerOW()
+
+    def tearDown(self):
+        self.widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self.widget.close()
+        self.widget = None
+        self.qapp.processEvents()
+        shutil.rmtree(self.tmp_dir)
+        gc.collect()
+
+    def test(self):
+        self.widget.addScan(self.scan)

tomwer/tests/orangecontrib/tomwer/widgets/visualization/tests/test_nxtomo_metadata_viewer.py

@@ -0,0 +1,29 @@
+import gc
+
+import pytest
+from silx.gui import qt
+from silx.gui.utils.testutils import TestCaseQt
+
+from orangecontrib.tomwer.widgets.visualization.NXtomoMetadataViewerOW import (
+    NXtomoMetadataViewerOW,
+)
+from tomwer.tests.utils import skip_gui_test
+
+
+@pytest.mark.skipif(skip_gui_test(), reason="skip gui test")
+class TestNXtomoMetadataViewerOW(TestCaseQt):
+    """Test that the NXtomoEditorOW widget work correctly. Processing test are done in the core module. gui test are done in the tomwer.gui.edit module"""
+
+    def setUp(self):
+        super().setUp()
+        self._window = NXtomoMetadataViewerOW()
+
+    def tearDown(self):
+        self._window.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self._window.close()
+        self._window = None
+        gc.collect()
+
+    def test(self):
+        self._window.show()
+        self.qWaitForWindowExposed(self._window)

tomwer/tests/orangecontrib/tomwer/widgets/visualization/tests/test_radio_stackow.py

@@ -0,0 +1,31 @@
+# coding: utf-8
+from __future__ import annotations
+
+
+import gc
+
+import pytest
+from silx.gui import qt
+from silx.gui.utils.testutils import TestCaseQt
+
+from orangecontrib.tomwer.widgets.visualization.RadioStackOW import RadioStackOW
+from tomwer.tests.utils import skip_gui_test
+
+
+@pytest.mark.skipif(skip_gui_test(), reason="skip gui test")
+class TestRadioStack(TestCaseQt):
+    """Test that the axis widget work correctly"""
+
+    def setUp(self):
+        super().setUp()
+        self._window = RadioStackOW()
+
+    def tearDown(self):
+        self._window.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self._window.close()
+        self._window = None
+        gc.collect()
+
+    def test(self):
+        self._window.show()
+        self.qWaitForWindowExposed(self._window)

tomwer/tests/orangecontrib/tomwer/widgets/visualization/tests/test_sample_movedow.py

@@ -0,0 +1,46 @@
+# coding: utf-8
+from __future__ import annotations
+
+import gc
+import tempfile
+
+import pytest
+from silx.gui import qt
+from silx.gui.utils.testutils import TestCaseQt
+
+from orangecontrib.tomwer.widgets.visualization.SampleMovedOW import SampleMovedOW
+from tomwer.core.utils.scanutils import MockNXtomo
+from tomwer.tests.utils import skip_gui_test
+
+
+@pytest.mark.skipif(skip_gui_test(), reason="skip gui test")
+class TestSampleMoved(TestCaseQt):
+    """Test that the axis widget work correctly"""
+
+    def setUp(self):
+        super().setUp()
+        self._window = SampleMovedOW()
+        self._tmp_path = tempfile.mkdtemp()
+
+        self._scan = MockNXtomo(
+            scan_path=self._tmp_path,
+            create_ini_dark=True,
+            create_ini_flat=True,
+            create_final_flat=False,
+            n_proj=10,
+            n_ini_proj=10,
+            dim=12,
+        ).scan
+
+    def tearDown(self):
+        self._window.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self._window.close()
+        self._window = None
+        gc.collect()
+
+    def test(self):
+        self._window.show()
+        self.qWaitForWindowExposed(self._window)
+
+        self._window.updateScan(self._scan)
+        self.qapp.processEvents()

tomwer/tests/orangecontrib/tomwer/widgets/visualization/tests/test_sinogram_viewerow.py

@@ -0,0 +1,31 @@
+# coding: utf-8
+from __future__ import annotations
+
+
+import gc
+
+import pytest
+from silx.gui import qt
+from silx.gui.utils.testutils import TestCaseQt
+
+from orangecontrib.tomwer.widgets.visualization.SinogramViewerOW import SinogramViewerOW
+from tomwer.tests.utils import skip_gui_test
+
+
+@pytest.mark.skipif(skip_gui_test(), reason="skip gui test")
+class TestSinogramViewerOW(TestCaseQt):
+    """Test that the axis widget work correctly"""
+
+    def setUp(self):
+        super().setUp()
+        self._window = SinogramViewerOW()
+
+    def tearDown(self):
+        self._window.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self._window.close()
+        self._window = None
+        gc.collect()
+
+    def test(self):
+        self._window.show()
+        self.qWaitForWindowExposed(self._window)

tomwer/tests/orangecontrib/tomwer/widgets/visualization/tests/test_slice_stackow.py

@@ -0,0 +1,31 @@
+# coding: utf-8
+from __future__ import annotations
+
+import gc
+
+import pytest
+from silx.gui import qt
+from silx.gui.utils.testutils import TestCaseQt
+
+from orangecontrib.tomwer.widgets.visualization.SliceStackOW import SlicesStackOW
+from tomwer.tests.utils import skip_gui_test
+
+
+@pytest.mark.skip("Fail on CI")
+@pytest.mark.skipif(skip_gui_test(), reason="skip gui test")
+class TestSliceStackOW(TestCaseQt):
+    """Test that the axis widget work correctly"""
+
+    def setUp(self):
+        super().setUp()
+        self._window = SlicesStackOW()
+
+    def tearDown(self):
+        self._window.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self._window.close()
+        self._window = None
+        gc.collect()
+
+    def test(self):
+        self._window.show()
+        self.qWaitForWindowExposed(self._window)

tomwer/tests/orangecontrib/tomwer/widgets/visualization/tests/test_volume_viewerow.py

@@ -0,0 +1,32 @@
+# coding: utf-8
+from __future__ import annotations
+
+
+import gc
+
+import pytest
+from silx.gui import qt
+from silx.gui.utils.testutils import TestCaseQt
+
+from orangecontrib.tomwer.widgets.visualization.VolumeViewerOW import VolumeViewerOW
+from tomwer.tests.utils import skip_gui_test
+
+
+@pytest.mark.skipif(skip_gui_test(), reason="skip gui test")
+class TestVolumeViewerOW(TestCaseQt):
+    """Test that the axis widget work correctly"""
+
+    def setUp(self):
+        super().setUp()
+        self._window = VolumeViewerOW()
+
+    def tearDown(self):
+        self._window.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self._window.close()
+        del self._window.viewer
+        self._window = None
+        gc.collect()
+
+    def test(self):
+        self._window.show()
+        self.qWaitForWindowExposed(self._window)