tomwer 1.4.0rc6__py3-none-any.whl → 1.4.1__py3-none-any.whl

tomwer/tests/orangecontrib/tomwer/widgets/reconstruction/tests/test_saaxis.py

@@ -1,28 +1,21 @@
 # coding: utf-8
 from __future__ import annotations
 
-import gc
-import logging
 import os
+import logging
 import pickle
-import shutil
-import tempfile
 import time
-import uuid
 
-import h5py
 import numpy
 from orangecanvas.scheme.readwrite import literal_dumps
 from processview.core.manager import DatasetState, ProcessManager
-from silx.gui import qt
-from silx.gui.utils.testutils import TestCaseQt
 from silx.io.url import DataUrl
+from silx.gui import qt
 
 from orangecontrib.tomwer.widgets.reconstruction.SAAxisOW import SAAxisOW as _SAAxisOW
-from tomwer.core import settings
-from tomwer.core.utils.lbsram import mock_low_memory
 from tomwer.core.process.reconstruction.scores import ComputedScore
 from tomwer.core.utils.scanutils import MockNXtomo
+from tomwer.tests.conftest import qtapp  # noqa F401
 
 logger = logging.getLogger(__name__)
 
@@ -33,7 +26,6 @@ class SAAxisOW(_SAAxisOW):
         super().__init__(parent)
 
     def processing_finished(self, scan):
-        # TODO: add message processing finished
         self._scans_finished.append(scan)
 
     @property
@@ -45,150 +37,123 @@ class SAAxisOW(_SAAxisOW):
         super().close()
 
 
-class TestProcessing(TestCaseQt):
-    DIM = 100
-
-    def setUp(self):
-        super().setUp()
-        self._source_dir = tempfile.mkdtemp()
-
-        def create_scan(folder_name):
-            _dir = os.path.join(self._source_dir, folder_name)
-            return MockNXtomo(
-                scan_path=_dir,
-                n_ini_proj=20,
-                n_proj=20,
-                n_alignement_proj=2,
-                create_final_flat=False,
-                create_ini_dark=True,
-                create_ini_flat=True,
-                n_refs=1,
-                dim=self.DIM,
-            ).scan
-
-        # create scans
-        self.scan_1 = create_scan("scan_1")
-        self.scan_2 = create_scan("scan_2")
-        self.scan_3 = create_scan("scan_3")
-        self._process_manager = ProcessManager()
-
-        self.widget = SAAxisOW()
-        self.widget.show()
-
-        def patch_score(*args, **kwargs):
-            data = numpy.random.random(TestProcessing.DIM * TestProcessing.DIM)
-            data = data.reshape(TestProcessing.DIM, TestProcessing.DIM)
-            slice_file_path = os.path.join(
-                self._source_dir, str(uuid.uuid1()) + ".hdf5"
-            )
-            data_url = DataUrl(
-                file_path=slice_file_path, data_path="data", scheme="silx"
-            )
-            with h5py.File(slice_file_path, mode="a") as h5f:
-                h5f["data"] = data
-            return data_url, ComputedScore(
-                tv=numpy.random.random(),
-                std=numpy.random.random(),
-            )
-
-        self.widget._widget._processing_stack.patch_processing(patch_score)
-
-    def tearDown(self):
-        mock_low_memory(False)
-        settings.mock_lsbram(False)
-        self.widget.setAttribute(qt.Qt.WA_DeleteOnClose)
-        self.widget.close()
-        self.widget = None
-        self.qapp.processEvents()
-        shutil.rmtree(self._source_dir)
-        gc.collect()
-
-    def test_serializing(self):
-        pickle.dumps(self.widget.getConfiguration())
-
-    def test_literal_dumps(self):
-        literal_dumps(self.widget.getConfiguration())
-
-    def testAutoFocusUnlock(self):
-        self.widget.lockAutofocus(False)
-
-        def manual_processing():
-            self.widget.load_sinogram()
-            self.widget.compute()
-            self.qapp.processEvents()
-            self.widget.wait_processing(5000)
-            self.qapp.processEvents()
-
-        self.widget.process(self.scan_1)
-        manual_processing()
-        self.assertEqual(
-            self._process_manager.get_dataset_state(
-                dataset_id=self.scan_1.get_identifier(),
-                process=self.widget,
-            ),
-            DatasetState.WAIT_USER_VALIDATION,
+FRAME_DIM = 100
+
+
+def create_scan(output_dir):
+    return MockNXtomo(
+        scan_path=output_dir,
+        n_ini_proj=20,
+        n_proj=20,
+        n_alignement_proj=2,
+        create_final_flat=False,
+        create_ini_dark=True,
+        create_ini_flat=True,
+        n_refs=1,
+        dim=FRAME_DIM,
+    ).scan
+
+
+def patch_score(*args, **kwargs):
+    """Function to save some result"""
+    return DataUrl(
+        file_path="/no_existing/path.hdf5",
+        data_path="/no_existing_data_path",
+        scheme="silx",
+    ), ComputedScore(
+        tv=numpy.random.random(),
+        std=numpy.random.random(),
+    )
+
+
+def test_SAAxisOW(
+    qtapp,  # noqa F811
+    tmp_path,
+):
+    source_dir = tmp_path / "source"
+    source_dir.mkdir()
+
+    # create scans
+    scan_1 = create_scan(os.path.join(source_dir, "scan_1"))
+    scan_2 = create_scan(os.path.join(source_dir, "scan_2"))
+    scan_3 = create_scan(os.path.join(source_dir, "scan_3"))
+    process_manager = ProcessManager()
+
+    widget = SAAxisOW()
+    widget.show()
+
+    widget._widget._processing_stack.patch_processing(patch_score)
+
+    # test configuration serialization
+    pickle.dumps(widget.getConfiguration())
+
+    # test configuration is compatible with 'litteral dumps'
+    literal_dumps(widget.getConfiguration())
+
+    # test behavior when 'auto focus' is lock (so widget is automated, should take the value with the higher score)
+    widget.lockAutofocus(False)
+
+    def manual_processing():
+        widget.load_sinogram()
+        widget.compute()
+        qt.QApplication.processEvents()
+        widget.wait_processing(5000)
+        qt.QApplication.processEvents()
+
+    widget.process(scan_1)
+    manual_processing()
+    assert (
+        process_manager.get_dataset_state(
+            dataset_id=scan_1.get_identifier(),
+            process=widget,
         )
-
-        self.widget.process(self.scan_2)
-        manual_processing()
-        self.assertEqual(len(self.widget.scans_finished), 0)
-        self.assertEqual(
-            self._process_manager.get_dataset_state(
-                dataset_id=self.scan_1.get_identifier(),
-                process=self.widget,
-            ),
-            DatasetState.SKIPPED,
+        == DatasetState.WAIT_USER_VALIDATION
+    )
+
+    widget.process(scan_2)
+    manual_processing()
+    assert len(widget.scans_finished) == 0
+    assert (
+        process_manager.get_dataset_state(
+            dataset_id=scan_1.get_identifier(),
+            process=widget,
         )
-        self.assertEqual(
-            self._process_manager.get_dataset_state(
-                dataset_id=self.scan_2.get_identifier(),
-                process=self.widget,
-            ),
-            DatasetState.WAIT_USER_VALIDATION,
+        == DatasetState.SKIPPED
+    )
+    assert (
+        process_manager.get_dataset_state(
+            dataset_id=scan_2.get_identifier(),
+            process=widget,
         )
-        self.widget.process(self.scan_3)
-        manual_processing()
-        self.widget.validateCurrentScan()
-        self.assertEqual(
-            self._process_manager.get_dataset_state(
-                dataset_id=self.scan_3.get_identifier(),
-                process=self.widget,
-            ),
-            DatasetState.SUCCEED,
+        == DatasetState.WAIT_USER_VALIDATION
+    )
+
+    widget.process(scan_3)
+    manual_processing()
+    widget.validateCurrentScan()
+    assert (
+        process_manager.get_dataset_state(
+            dataset_id=scan_3.get_identifier(),
+            process=widget,
         )
-        # insure a cor has been registered
-        self.assertNotEqual(self.scan_3.axis_params.relative_cor_value, None)
-
-    def testTestLbsram(self):
-        mock_low_memory(True)
-        settings.mock_lsbram(True)
-        for scan in (self.scan_1, self.scan_2, self.scan_3):
-            self.widget.process(scan)
-            self.widget.wait_processing(5000)
-            self.qapp.processEvents()
-
-        for scan in (self.scan_1, self.scan_2, self.scan_3):
-            with self.subTest(scan=str(scan)):
-                self.assertEqual(
-                    self._process_manager.get_dataset_state(
-                        dataset_id=scan.get_identifier(),
-                        process=self.widget,
-                    ),
-                    DatasetState.SKIPPED,
-                )
-
-    def testAutoFocusLock(self):
-        self.widget.lockAutofocus(True)
-        for scan in (self.scan_1, self.scan_2, self.scan_3):
-            self.widget.process(scan)
-            self.widget.wait_processing(10000)
-            self.qapp.processEvents()
+        == DatasetState.SUCCEED
+    )
+
+    # insure a cor has been registered
+    assert scan_3.axis_params.relative_cor_value is not None
+
+    # test autofocus is unlocked
+    widget.lockAutofocus(True)
+    for scan in (scan_1, scan_2, scan_3):
+        widget.process(scan)
+        widget.wait_processing(10000)
+        while qt.QApplication.hasPendingEvents():
             time.sleep(0.1)
-            self.qapp.processEvents()
-            self.assertEqual(
-                self._process_manager.get_dataset_state(
-                    dataset_id=scan.get_identifier(),
-                    process=self.widget,
-                ),
-                DatasetState.SUCCEED,
+            qt.QApplication.processEvents()
+        assert (
+            process_manager.get_dataset_state(
+                dataset_id=scan.get_identifier(),
+                process=widget,
             )
+            == DatasetState.SUCCEED
+        )

tomwer/tests/orangecontrib/tomwer/widgets/{tests/test_darkref.py → test_darkref.py}

@@ -170,7 +170,6 @@ class TestDarkRefCopyWithEDFAndHDF5(TestCaseQt):
         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 (
@@ -178,7 +177,6 @@ class TestDarkRefCopyWithEDFAndHDF5(TestCaseQt):
             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)
@@ -188,14 +186,12 @@ class TestDarkRefCopyWithEDFAndHDF5(TestCaseQt):
         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)
@@ -218,8 +214,3 @@ class TestDarkRefCopyWithEDFAndHDF5(TestCaseQt):
 
         # 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 → test_foldertransfert.py}

@@ -100,6 +100,6 @@ class TestEDFFolderTransfertWidget(TestCaseQt):
 
         return (
             (len(inputFile) == 0)
-            and (len(outputFiles) == (self.n_file + 3))
+            and (len(outputFiles) == (self.n_file + 2))
             and (not os.path.isdir(self.sourcedir))
         )

tomwer/tests/test_ewoks/test_workflows.py

@@ -40,9 +40,6 @@ def test_simple_workflow_nabu():
     ) as scan:
         # insure no cfg yet
         assert len(glob(os.path.join(scan.path, "*.cfg"))) == 0
-        assert not os.path.exists(
-            scan.process_file
-        ), "check tomwer should not have been processed yet"
 
         graph = load_graph(
             source={
@@ -130,7 +127,6 @@ def test_simple_workflow_nabu():
             "nabu volume"
         }, "should only have one result nodes"
         assert "data" in result, f"cannot find `nabu volume` in {result}"
-        assert os.path.exists(scan.process_file), "check tomwer has been processed"
         assert os.path.exists(
             os.path.join(
                 scan.path, PROCESS_FOLDER_RECONSTRUCTED_VOLUMES, "nabu_cfg_files"

tomwer/version.py

@@ -77,9 +77,9 @@ RELEASE_LEVEL_VALUE = {
 
 MAJOR = 1
 MINOR = 4
-MICRO = 0
-RELEV = "rc"  # <16
-SERIAL = 6  # <16
+MICRO = 1
+RELEV = "final"  # <16
+SERIAL = 0  # <16
 
 date = __date__
 

{tomwer-1.4.0rc6.dist-info → tomwer-1.4.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tomwer
-Version: 1.4.0rc6
+Version: 1.4.1
 Summary: "tomography workflow tools"
 Home-page: https://gitlab.esrf.fr/tomotools/tomwer
 Author: Henri Payno, Pierre Paleo, Pierre-Olivier Autran, Jérôme Lesaint, Alessandro Mirone
@@ -32,7 +32,6 @@ Requires-Dist: processview>=1.4.3
 Requires-Dist: ewoks>=0.1.1
 Requires-Dist: sluurp>=0.4.1
 Requires-Dist: packaging
-Requires-Dist: flufl-lock
 Requires-Dist: pyunitsystem>=2.0.0a
 Requires-Dist: tqdm
 Provides-Extra: full-base