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

tomwer/synctools/stacks/reconstruction/axis.py

@@ -11,7 +11,6 @@ from silx.gui import qt
 from tomwer.core.process.reconstruction.axis import AxisTask
 from tomwer.core.process.reconstruction.axis.axis import NoAxisUrl
 from tomwer.core.process.reconstruction.axis.mode import AxisMode
-from tomwer.core.scan.nxtomoscan import NXtomoScan
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.core.settings import get_lbsram_path, isOnLbsram
 from tomwer.core.utils.lbsram import is_low_on_memory
@@ -63,23 +62,6 @@ class AxisProcessStack(FIFO, qt.QObject):
                 cor = 0
             data._axis_params.set_relative_value(cor)
             cor = data._axis_params.relative_cor_value
-            if isinstance(data, NXtomoScan):
-                entry = data.entry
-            else:
-                entry = "entry"
-            try:
-                with data.acquire_process_file_lock():
-                    AxisTask._register_process(
-                        process_file=data.process_file,
-                        entry=entry,
-                        process=AxisTask,
-                        results={"center_of_rotation": cor if cor is not None else "-"},
-                        configuration=self._axis_params.to_dict(),
-                        process_index=data.pop_process_index(),
-                        overwrite=True,
-                    )
-            except Exception as e:
-                _logger.warning(f"Fail to register Axis process. Reason is {e}")
             # If mode is read or manual the position_value is not computed and
             # we will keep the actual one (should have been defined previously)
             self._end_computation(data=data, future_tomo_obj=None, callback=callback)

tomwer/synctools/tests/test_foldertransfer.py

@@ -195,10 +195,10 @@ class TestEDFDataTransfert(TestCaseQt):
     def checkDataCopied(self):
         outputFiles = os.listdir(self.outputdir)
         inputFile = glob(self.sourcedir)
-        # + 3 because .info and .xml are count + one tomwer_processes file
+        # + 3 because .info and .xml are count
         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))
         )
 
@@ -247,23 +247,6 @@ class TestHDFDataTransfert(TestCaseQt):
         assert os.path.isfile(output_file_path)
         self.scan = NXtomoScan(scan=output_file_path, entry=entry)
 
-        # register information regarding origin of the file
-        from tomwer.core.process.control.datalistener import DataListener
-
-        DataListener._register_process(
-            process_file=self.scan.process_file,
-            process=DataListener,
-            entry=self.scan.entry,
-            results={"output_file": self.scan.master_file, "entry": self.scan.entry},
-            configuration={
-                "sample_file": self._sample_file,
-                "entry": self._sample_file_entry,
-                "file_proposal": self._proposal_file,
-            },
-            process_index=self.scan.pop_process_index(),
-            overwrite=True,
-        )
-
     def tearDown(self):
         for dir_ in (self.input_dir, self.output_dir):
             shutil.rmtree(dir_)

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

@@ -12,16 +12,13 @@ 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.utils import h5py_read_dataset
 
 from orangecontrib.tomwer.widgets.reconstruction.SinoNormOW import (
     SinoNormOW as _NormIOW,
 )
 from tomwer.core import settings
 from tomwer.core.utils.lbsram import mock_low_memory
-from tomwer.core.process.reconstruction.normalization import SinoNormalizationTask
 from tomwer.core.utils.scanutils import MockNXtomo
-from tomwer.io.utils.h5pyutils import EntryReader
 
 logger = logging.getLogger(__name__)
 
@@ -191,10 +188,3 @@ class TestProcessing(TestCaseQt):
                     ),
                     DatasetState.SUCCEED,
                 )
-            # test process file has been updated
-            with EntryReader(scan.process_file_url) as entry:
-                self.assertTrue("tomwer_process_0" in entry)
-                self.assertEqual(
-                    h5py_read_dataset(entry["tomwer_process_0"]["program"]),
-                    SinoNormalizationTask.program_name(),
-                )

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

@@ -1,37 +1,31 @@
-import gc
 import logging
 import os
 import pickle
-import shutil
-import tempfile
-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.SADeltaBetaOW import (
     SADeltaBetaOW as _SADeltaBetaOW,
 )
-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__)
 
 
 class SADeltaBetaOW(_SADeltaBetaOW):
+    """class saving scan finished to keep a trace on those."""
+
     def __init__(self, parent=None):
         self._scans_finished = []
         super().__init__(parent)
 
     def processing_finished(self, scan):
-        # TODO: add message processing finished
         self._scans_finished.append(scan)
 
     @property
@@ -43,152 +37,108 @@ class SADeltaBetaOW(_SADeltaBetaOW):
         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 = SADeltaBetaOW()
-        self.widget.show()
-
-        def patch_score(cor):
-            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.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_SADeltaBetaOW(
+    qtapp,  # noqa F811
+    tmp_path,
+):
+    source_dir = tmp_path / "source"
+    source_dir.mkdir()
 
-        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,
+    # 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 = SADeltaBetaOW()
+    widget.show()
+
+    widget._widget._processing_stack.patch_processing(patch_score)
+
+    # make sure the configuration is serializable
+    pickle.dumps(widget.getConfiguration())
+
+    # make sure this is compatible with 'literal dumps'
+    literal_dumps(widget.getConfiguration())
+
+    # test behavior when 'autofocus' is lock. (in this case we expect to take the dataset with the higher score) and continue
+    widget.lockAutofocus(False)
+
+    def manual_processing():
+        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.assertEqual(
-            self._process_manager.get_dataset_state(
-                dataset_id=self.scan_2.get_identifier(),
-                process=self.widget,
-            ),
-            DatasetState.WAIT_USER_VALIDATION,
+        == 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.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.SKIPPED
+    )
+
+    assert (
+        process_manager.get_dataset_state(
+            dataset_id=scan_2.get_identifier(),
+            process=widget,
         )
-        # insure a cor has been registered
-        self.assertNotEqual(
-            self.scan_3.sa_delta_beta_params.selected_delta_beta_value, None
+        == 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,
         )
+        == DatasetState.SUCCEED
+    )
 
-    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(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.SUCCEED,
-                )
+    # ensure a cor has been registered
+    assert scan_3.sa_delta_beta_params.selected_delta_beta_value is not None