tomwer 1.3.26__py3-none-any.whl → 1.4.0__py3-none-any.whl

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)

tomwer/tests/test_ewoks/test_conversion.py

@@ -0,0 +1,104 @@
+import pytest
+from ewoksorange.bindings import owsconvert
+from tomwer.tests.datasets import TomwerCIDatasets
+
+
+ows_files_to_convert = ("from_nxtomo_to_volume.ows",)
+
+
+@pytest.mark.parametrize("orange_file_name", ows_files_to_convert)
+def test_conversion(orange_file_name):
+    """test orange file can be converted to ewoks Graph"""
+    scheme_file = TomwerCIDatasets.get_dataset(f"workflows/{orange_file_name}")
+    graph = owsconvert.ows_to_ewoks(scheme_file)
+    # make sure settings where correctly saved
+    assert len(graph.graph.nodes) == 7
+    assert len(graph.graph.edges) == 6
+    # make sure the settings are properly loaded
+    for node in graph.graph.nodes.values():
+        assert node["task_type"] == "class"
+        assert node["task_identifier"].startswith("tomwer")
+    # check settings of some specific nodes
+    # dark and flat
+    dark_flat_node = graph.graph.nodes["1"]
+    assert (
+        dark_flat_node["task_identifier"]
+        == "tomwer.core.process.reconstruction.darkref.darkrefscopy.DarkRefsCopy"
+    )
+    assert "default_inputs" in dark_flat_node
+
+    def fileter_dark_ref_params(my_dict):
+        return my_dict["name"] == "dark_ref_params"
+
+    dark_ref_params_settings = tuple(
+        filter(fileter_dark_ref_params, dark_flat_node["default_inputs"])
+    )
+    assert len(dark_ref_params_settings) == 1
+    dark_ref_params_as_dict = dark_ref_params_settings[0]["value"]
+
+    assert "DOWHEN" in dark_ref_params_as_dict
+    assert "DARKCAL" in dark_ref_params_as_dict
+    assert "DKFILE" in dark_ref_params_as_dict
+
+    # axis
+    axis_node = graph.graph.nodes["2"]
+    assert (
+        axis_node["task_identifier"]
+        == "tomwer.core.process.reconstruction.axis.axis.AxisTask"
+    )
+    assert "default_inputs" in axis_node
+    assert len(axis_node["default_inputs"]) == 2  # axis_params + gui metadata
+
+    def filter_axis_params(my_dict):
+        return my_dict["name"] == "axis_params"
+
+    axis_params_settings = tuple(
+        filter(filter_axis_params, axis_node["default_inputs"])
+    )
+    assert len(axis_params_settings) == 1
+    axis_params_as_dict = axis_params_settings[0]["value"]
+
+    assert "MODE" in axis_params_as_dict
+    assert "POSITION_VALUE" in axis_params_as_dict
+    assert "SINOGRAM_LINE" in axis_params_as_dict
+
+    # nabu slice
+    nabu_slice_node = graph.graph.nodes["3"]
+    assert (
+        nabu_slice_node["task_identifier"]
+        == "tomwer.core.process.reconstruction.nabu.nabuslices.NabuSlicesTask"
+    )
+    assert "default_inputs" in axis_node
+
+    def filter_nabu_params(my_dict):
+        return my_dict["name"] == "nabu_params"
+
+    nabu_params_settings = tuple(
+        filter(filter_nabu_params, nabu_slice_node["default_inputs"])
+    )
+    assert len(nabu_params_settings) == 1
+    nabu_params_as_dict = nabu_params_settings[0]["value"]
+
+    assert "preproc" in nabu_params_as_dict
+    assert "phase" in nabu_params_as_dict
+    assert "tomwer_slices" in nabu_params_as_dict
+
+    # nabu volume
+    nabu_volume_node = graph.graph.nodes["4"]
+    assert (
+        nabu_volume_node["task_identifier"]
+        == "tomwer.core.process.reconstruction.nabu.nabuvolume.NabuVolumeTask"
+    )
+    assert "default_inputs" in axis_node
+
+    def filter_nabu_volume_params(my_dict):
+        return my_dict["name"] == "nabu_volume_params"
+
+    nabu_volume_params_settings = tuple(
+        filter(filter_nabu_volume_params, nabu_volume_node["default_inputs"])
+    )
+    assert len(nabu_volume_params_settings) == 1
+    nabu_volume_params_as_dict = nabu_volume_params_settings[0]["value"]
+
+    assert "start_z" in nabu_volume_params_as_dict
+    assert "end_z" in nabu_volume_params_as_dict

tomwer/tests/test_ewoks/test_single_node_execution.py

@@ -0,0 +1,87 @@
+# coding: utf-8
+from __future__ import annotations
+
+
+import os
+import tempfile
+from glob import glob
+
+import pytest
+from ewokscore.graph import analysis, load_graph
+from ewokscore.graph.validate import validate_graph
+
+from tomwer.core.utils.scanutils import HDF5MockContext
+from nabu.pipeline.config import get_default_nabu_config
+from nabu.pipeline.fullfield.nabu_config import (
+    nabu_config as nabu_fullfield_default_config,
+)
+
+try:
+    from nabu.pipeline.fullfield.reconstruction import (  # noqa F401
+        FullFieldReconstructor,
+    )
+except ImportError:
+    try:
+        from nabu.pipeline.fullfield.local_reconstruction import (  # noqa F401
+            ChunkedReconstructor,
+        )
+    except ImportError:
+        has_nabu = False
+    else:
+        has_nabu = True
+else:
+    has_nabu = True
+
+pytest.mark.skipif(condition=not has_nabu, reason="nabu not installed")
+
+
+classes_to_test = {
+    "darkref": "tomwer.core.process.reconstruction.darkref.darkrefs.DarkRefs",
+    "axis": "tomwer.core.process.reconstruction.axis.axis.AxisTask",
+    "nabu slices": "tomwer.core.process.reconstruction.nabu.nabuslices.NabuSlices",
+}
+
+
+@pytest.mark.parametrize("node_name, node_qual_name", classes_to_test.items())
+def test_single_class_instanciation(node_name, node_qual_name):
+    with HDF5MockContext(
+        scan_path=os.path.join(tempfile.mkdtemp(), "scan_test"), n_proj=100
+    ) as scan:
+        # insure no cfg yet
+        assert len(glob(os.path.join(scan.path, "*.cfg"))) == 0
+
+        graph = load_graph(
+            {
+                "nodes": [
+                    {
+                        "id": node_name,
+                        "task_type": "class",
+                        "task_identifier": node_qual_name,
+                        "default_inputs": [
+                            {
+                                "name": "data",
+                                "value": scan,
+                            },
+                            {
+                                "name": "nabu_params",
+                                "value": get_default_nabu_config(
+                                    nabu_fullfield_default_config
+                                ),
+                            },
+                        ],
+                    },
+                ]
+            }
+        )
+
+        assert graph.is_cyclic is False, "graph is expected to be acyclic"
+        assert analysis.start_nodes(graph.graph) == {
+            node_name
+        }, "graph is expected to have only on start nodes"
+        validate_graph(graph.graph)
+        result = graph.execute(varinfo=None)
+
+        assert analysis.end_nodes(graph.graph) == {
+            node_name
+        }, "graph is expected to have only one end node"
+        assert "data" in result, "data is expected to be part of the output_values"