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

tomwer/tests/orangecontrib/tomwer/widgets/control/tests/test_datawatcher.py

@@ -0,0 +1,411 @@
+# coding: utf-8
+from __future__ import annotations
+
+import gc
+import logging
+import os
+import shutil
+import tempfile
+import time
+from time import sleep
+
+from silx.gui import qt
+from silx.gui.utils.testutils import SignalListener, TestCaseQt
+
+from orangecontrib.tomwer.tests.TestAcquisition import Simulation
+from orangecontrib.tomwer.widgets.control.DataWatcherOW import DataWatcherOW
+from tomwer.core.process.control.datawatcher import status as datawatcherstatus
+from tomwer.core.utils.scanutils import MockBlissAcquisition, MockNXtomo
+
+logging.disable(logging.INFO)
+
+
+class DataWatcherWaiter(TestCaseQt):
+    """Define a simple objecy able to wait for some state of the DataWatcher
+    arrive"""
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.reset()
+        self.lastStatus = []
+
+    def tearDown(self):
+        pass
+
+    def reset(self):
+        self.lastStatus = []
+
+    def stateHasChanged(self, val):
+        """Register all status"""
+        if val not in self.lastStatus:
+            self.lastStatus.append(val)
+
+    def waitForState(self, state, maxWaiting):
+        """simple function wich wait until the DataWatcherWidget reach the given
+        state.
+        If the widget doesn't reach this state after maxWaiting second. Then fail.
+
+        :param state: the state we are waiting for
+        :param maxWaiting: the maximal number of second to wait until failling.
+        """
+        while state not in self.lastStatus:
+            time.sleep(1.0)
+            self.qapp.processEvents()
+            maxWaiting -= 1
+            if maxWaiting <= 0:
+                return False
+        return state in self.lastStatus
+
+
+class TestDataWatcherAcquisition(DataWatcherWaiter):
+    """Functions testing the classical behavior of data watcher
+    - signal acquisition is over only when all files are copied
+    """
+
+    def tearDown(self):
+        while self.qapp.hasPendingEvents():
+            self.qapp.processEvents()
+        self.dataWatcherWidget.setObservation(False)
+        self.dataWatcherWidget.close()
+        del self.dataWatcherWidget
+        self.dataWatcherWidget = None
+        self.s.wait()
+        del self.s
+        if os.path.isdir(self.inputdir):
+            shutil.rmtree(self.inputdir)
+        gc.collect()
+        super().tearDown()
+
+    def setUp(self):
+        self.manipulationId = "test10"
+
+        super().setUp()
+        self.inputdir = tempfile.mkdtemp()
+        DataWatcherWaiter.reset(self)
+        self.dataWatcherWidget = DataWatcherOW(displayAdvancement=False)
+        self.dataWatcherWidget.srcPattern = ""
+        self.dataWatcherWidget.sigTMStatusChanged.connect(self.stateHasChanged)
+        self.dataWatcherWidget.setAttribute(qt.Qt.WA_DeleteOnClose)
+
+        self.s = Simulation(
+            self.inputdir,
+            self.manipulationId,
+            finalState=Simulation.advancement["acquisitionRunning"],
+        )
+
+    def testStartAcquisition(self):
+        """Make sure the data watch detect the acquisition of started"""
+        observeDir = os.path.join(self.inputdir, self.manipulationId)
+        for folder in (self.inputdir, observeDir):
+            if not os.path.exists(folder):
+                os.makedirs(folder)
+
+        self.assertTrue(os.path.isdir(observeDir))
+
+        self.s.createFinalXML(True)
+        self.dataWatcherWidget.setFolderObserved(observeDir)
+
+        self.assertTrue(self.dataWatcherWidget.currentStatus == "not processing")
+        self.s.start()
+        self.s.advanceTo("acquisitionDone")
+        self.s.start()
+        self.s.wait()
+        self.dataWatcherWidget.startObservation()
+        self.dataWatcherWidget._widget.observationThread.wait()
+        self.dataWatcherWidget._widget.observationThread.observations.dict[
+            observeDir
+        ].wait()
+        self.qapp.processEvents()
+        finishedAcqui = (
+            self.dataWatcherWidget._widget.observationThread.observations.ignoredFolders
+        )
+        self.qapp.processEvents()
+        self.assertTrue(observeDir in finishedAcqui)
+
+
+class TestDataWatcherInteraction(TestCaseQt):
+    """Simple unit test to test the start/stop observation button action"""
+
+    def setUp(self):
+        super().setUp()
+        self.inputdir = tempfile.mkdtemp()
+        self.dataWatcherWidget = DataWatcherOW(displayAdvancement=False)
+        self.dataWatcherWidget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self.dataWatcherWidget.srcPattern = ""
+
+    def tearDown(self):
+        while self.qapp.hasPendingEvents():
+            self.qapp.processEvents()
+        self.dataWatcherWidget.close()
+        del self.dataWatcherWidget
+        if os.path.isdir(self.inputdir):
+            shutil.rmtree(self.inputdir)
+        gc.collect()
+
+    def testStartAndStopAcquisition(self):
+        """test multiple start and stop action on the start observation to
+        make sure no crash are appearing
+        """
+        try:
+            self.dataWatcherWidget.setFolderObserved(self.inputdir)
+            self.dataWatcherWidget.show()
+            self.dataWatcherWidget.setObservation(True)
+            for _ in range(5):
+                self.dataWatcherWidget._widget._qpbstartstop.pressed.emit()
+            self.assertTrue(True)
+        except Exception:
+            self.assertTrue(False)
+
+
+class WaitForXMLOption(DataWatcherWaiter):
+    """test the behavior of datawatcher when the option 'wait for xml copy'
+    Basically in this case DataWatcherDirObserver will wait until an .xml
+    arrived
+    """
+
+    @classmethod
+    def setUpClass(cls):
+        cls.dataWatcherWidget = DataWatcherOW(displayAdvancement=False)
+        cls.dataWatcherWidget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        cls.dataWatcherWidget.obsMethod = datawatcherstatus.DET_END_XML
+        cls.dataWatcherWidget.srcPattern = ""
+        cls.manipulationId = "test10"
+        super().setUpClass()
+
+    def setUp(self):
+        self.inputdir = tempfile.mkdtemp()
+        self.reset()
+        self.dataWatcherWidget.setObservation(False)
+        self.dataWatcherWidget.resetStatus()
+        super().setUp()
+
+    def tearDown(self):
+        while self.qapp.hasPendingEvents():
+            self.qapp.processEvents()
+        if os.path.isdir(self.inputdir):
+            shutil.rmtree(self.inputdir)
+        gc.collect()
+        super().tearDown()
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.dataWatcherWidget.close()
+        del cls.dataWatcherWidget
+        if hasattr(cls, "s"):
+            cls.s.quit()
+            del cls.s
+        super().tearDownClass()
+
+    def testAcquistionNotEnding(self):
+        """Check behavior if an acquisition never end"""
+        observeDir = os.path.join(self.inputdir, self.manipulationId)
+        for folder in (self.inputdir, observeDir):
+            if not os.path.exists(folder):
+                os.makedirs(folder)
+
+        self.assertTrue(os.path.isdir(observeDir))
+
+        self.s = Simulation(
+            self.inputdir,
+            self.manipulationId,
+            finalState=Simulation.advancement["acquisitionRunning"],
+        )
+        self.dataWatcherWidget.setFolderObserved(observeDir)
+        self.dataWatcherWidget.show()
+        self.dataWatcherWidget.sigTMStatusChanged.connect(self.stateHasChanged)
+
+        self.assertTrue(self.dataWatcherWidget.currentStatus == "not processing")
+        self.s.start()
+        self.s.wait()
+        self.dataWatcherWidget.setObservation(True)
+        self.dataWatcherWidget._widget.observationThread.wait()
+        self.dataWatcherWidget._widget.observationThread.observations.dict[
+            observeDir
+        ].wait()
+        finishedAcqui = (
+            self.dataWatcherWidget._widget.observationThread.observations.ignoredFolders
+        )
+        self.qapp.processEvents()
+        self.assertFalse(observeDir in finishedAcqui)
+
+    def testAcquistionEnded(self):
+        """Check behavior if an acquisition is ending"""
+        manipulationId = "test10"
+        observeDir = os.path.join(self.inputdir, self.manipulationId)
+        for folder in (self.inputdir, observeDir):
+            if not os.path.exists(folder):
+                os.makedirs(folder)
+
+        self.assertTrue(os.path.isdir(observeDir))
+
+        self.s = Simulation(
+            self.inputdir,
+            manipulationId,
+            finalState=Simulation.advancement["acquisitionDone"],
+        )
+        self.s.createFinalXML(True)
+        self.dataWatcherWidget.setFolderObserved(observeDir)
+        self.dataWatcherWidget.show()
+        self.dataWatcherWidget.sigTMStatusChanged.connect(self.stateHasChanged)
+
+        self.assertTrue(self.dataWatcherWidget.currentStatus == "not processing")
+        self.s.start()
+        self.s.wait()
+        self.dataWatcherWidget.setObservation(True)
+        self.dataWatcherWidget._widget.observationThread.wait()
+        self.dataWatcherWidget._widget.observationThread.observations.dict[
+            observeDir
+        ].wait()
+        finishedAcqui = (
+            self.dataWatcherWidget._widget.observationThread.observations.ignoredFolders
+        )
+        self.qapp.processEvents()
+        self.assertTrue(observeDir in finishedAcqui)
+
+
+class TestRSync(DataWatcherWaiter):
+    """test that the synchronization using RSyncManager is working"""
+
+    def setUp(self):
+        super().setUp()
+        self.inputdir = tempfile.mkdtemp()
+        self.outputdir = tempfile.mkdtemp()
+        DataWatcherWaiter.reset(self)
+        self.dataWatcherWidget = DataWatcherOW(displayAdvancement=False)
+        self.dataWatcherWidget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self.dataWatcherWidget._widget.setSrcAndDestPattern(
+            self.inputdir, self.outputdir
+        )
+
+    def tearDown(self):
+        while self.qapp.hasPendingEvents():
+            self.qapp.processEvents()
+        self.dataWatcherWidget.close()
+        del self.dataWatcherWidget
+        if hasattr(self, "s"):
+            self.s.quit()
+            del self.s
+        super(TestRSync, self).tearDown()
+        for d in (self.inputdir, self.outputdir):
+            if os.path.isdir(d):
+                shutil.rmtree(d, ignore_errors=True)
+        gc.collect()
+
+    def testStartAcquisition(self):
+        """Test that rsync is launched when an acquisition is discovered"""
+        manipulationId = "test10"
+        observeDir = os.path.join(self.inputdir, manipulationId)
+        for folder in (self.inputdir, observeDir):
+            if not os.path.exists(folder):
+                os.makedirs(folder)
+
+        self.assertTrue(os.path.isdir(observeDir))
+
+        self.s = Simulation(
+            self.inputdir,
+            manipulationId,
+            finalState=Simulation.advancement["acquisitionRunning"],
+        )
+
+        self.s.setSrcDestPatterns(self.inputdir, self.outputdir)
+        self.s.createFinalXML(True)
+        self.dataWatcherWidget.setFolderObserved(self.inputdir)
+        self.dataWatcherWidget.show()
+        self.dataWatcherWidget.sigTMStatusChanged.connect(self.stateHasChanged)
+        self.assertTrue(self.dataWatcherWidget.currentStatus == "not processing")
+        self.dataWatcherWidget.setObservation(True)
+        self.s.start()
+        # check state scanning
+        time.sleep(0.5)
+
+        self.dataWatcherWidget.stopObservation()
+
+        # in this case the .info should be in the output dir also
+        test10_output = os.path.join(self.outputdir, "test10")
+        test10_input = os.path.join(self.inputdir, "test10")
+        self.assertTrue(os.path.isfile(os.path.join(test10_output, "test10.info")))
+
+        # make sure file transfert have been started (using rsync)
+        # all file in outputdir should be in input dir
+        time.sleep(2)
+        # check that some .edf file have already been copied
+        self.assertTrue(len(test10_output) > 5)
+
+        # xml shouldn't be there because we are righting it at the end
+        self.assertFalse(os.path.isfile(os.path.join(test10_output, "test10.xml")))
+        self.assertFalse(os.path.isfile(os.path.join(test10_input, "test10.xml")))
+
+
+class TestDataWatcherBlissScan(TestCaseQt):
+    def setUp(self):
+        self._widget = DataWatcherOW(self)
+        self.tempdir = tempfile.mkdtemp()
+        MockBlissAcquisition(
+            n_sample=1,
+            n_sequence=1,
+            n_scan_per_sequence=3,
+            n_darks=2,
+            n_flats=2,
+            output_dir=os.path.join(self.tempdir, "folder_1"),
+        )
+
+        MockBlissAcquisition(
+            n_sample=2,
+            n_sequence=1,
+            n_scan_per_sequence=3,
+            n_darks=2,
+            n_flats=2,
+            output_dir=os.path.join(self.tempdir, "test", "with", "some", "depth"),
+        )
+        self._listener = SignalListener()
+        self._widget._widget.sigScanReady.connect(self._listener)
+
+    def tearDown(self):
+        self._widget._widget.sigScanReady.disconnect(self._listener)
+        self._widget.stopObservation()
+        self._listener = None
+        shutil.rmtree(self.tempdir)
+        self._widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self._widget.close()
+        self._widget = None
+        gc.collect()
+
+
+class TestDataWatcherNXtomo(TestCaseQt):
+    def setUp(self):
+        self._widget = DataWatcherOW(self)
+        self.tempdir = tempfile.mkdtemp()
+        MockNXtomo(
+            scan_path=os.path.join(self.tempdir, "folder_1"),
+            n_proj=10,
+        )
+
+        MockNXtomo(
+            scan_path=os.path.join(self.tempdir, "test", "with", "some", "depth"),
+            n_proj=10,
+        )
+        self._listener = SignalListener()
+        self._widget._widget.sigScanReady.connect(self._listener)
+
+    def tearDown(self):
+        self._widget._widget.sigScanReady.disconnect(self._listener)
+        self._widget.stopObservation()
+        self._listener = None
+        shutil.rmtree(self.tempdir)
+        self._widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self._widget.close()
+        self._widget = None
+        gc.collect()
+
+    def test(self):
+        self._widget.setFolderObserved(self.tempdir)
+        self._widget._widget.getConfigWindow().setMode((datawatcherstatus.NXtomo_END,))
+        self._widget.show()
+        self._widget.startObservation()
+        processing_time = 2
+        sleep_time = 0.005
+        while processing_time > 0:
+            self.qapp.processEvents()
+            sleep(sleep_time)
+            processing_time -= sleep_time
+        assert self._listener.callCount() == 2

tomwer/tests/orangecontrib/tomwer/widgets/control/tests/test_emailow.py

@@ -0,0 +1,29 @@
+import gc
+import pickle
+
+from silx.gui import qt
+from silx.gui.utils.testutils import TestCaseQt
+
+from orangecontrib.tomwer.widgets.control.EmailOW import EmailOW
+from orangecanvas.scheme.readwrite import literal_dumps
+
+
+class TestEmailOW(TestCaseQt):
+    def setUp(self):
+        super().setUp()
+        self.widget = EmailOW()
+
+    def tearDown(self):
+        self.widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self.widget.close()
+        self.widget = None
+        gc.collect()
+
+    def test(self):
+        self.widget.show()
+
+    def test_serializing(self):
+        pickle.dumps(self.widget.getConfiguration())
+
+    def test_literal_dumps(self):
+        literal_dumps(self.widget.getConfiguration())

tomwer/tests/orangecontrib/tomwer/widgets/control/tests/test_notifier.py

@@ -0,0 +1,24 @@
+# coding: utf-8
+from __future__ import annotations
+
+import gc
+
+from silx.gui import qt
+from silx.gui.utils.testutils import TestCaseQt
+
+from orangecontrib.tomwer.widgets.control.NotifierOW import NotifierWidgetOW
+
+
+class TestTimerOW(TestCaseQt):
+    def setUp(self):
+        super().setUp()
+        self.widget = NotifierWidgetOW()
+
+    def tearDown(self):
+        self.widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self.widget.close()
+        self.widget = None
+        gc.collect()
+
+    def test(self):
+        self.widget.show()

tomwer/tests/orangecontrib/tomwer/widgets/control/tests/test_nxtomo_concatenate_ow.py

@@ -0,0 +1,64 @@
+import os
+from tomoscan.series import Series
+import pickle
+
+from ewoksorange.bindings.qtapp import QtEvent
+
+from orangecanvas.scheme.readwrite import literal_dumps
+
+from tomwer.tests.conftest import qtapp  # noqa F401
+from tomwer.core.utils.scanutils import MockNXtomo
+
+from orangecontrib.tomwer.widgets.control.NXtomoConcatenate import NXtomoConcatenateOW
+
+
+def test_NabuHelicalPrepareWeightsDoubleOW(
+    qtapp,  # noqa F811
+    tmp_path,
+):
+    """simple test of the _DeltaBetaSelectorDialog"""
+    widget = NXtomoConcatenateOW()
+    widget._loadSettings()
+    # test settings serialization
+    pickle.dumps(widget._ewoks_default_inputs)
+    literal_dumps(widget._ewoks_default_inputs)
+
+    scan_1 = MockNXtomo(
+        scan_path=os.path.join(tmp_path, "scan1"),
+        n_proj=10,
+        n_ini_proj=10,
+        scan_range=180,
+        dim=20,
+        energy=12.3,
+    ).scan
+    scan_2 = MockNXtomo(
+        scan_path=os.path.join(tmp_path, "scan2"),
+        n_proj=10,
+        n_ini_proj=10,
+        scan_range=180,
+        dim=20,
+        energy=12.3,
+    ).scan
+
+    output_scan_file = os.path.join(tmp_path, "concatenation.nx")
+    assert not os.path.exists(output_scan_file)
+
+    widget.widget.setConfiguration(
+        {
+            "output_file": output_scan_file,
+        }
+    )
+
+    # process task
+    finished = QtEvent()
+
+    def finished_callback():
+        finished.set()
+
+    executor = widget.task_executor_queue
+    executor.sigComputationEnded.connect(finished_callback)
+    widget._process_series(series=Series(iterable=[scan_1, scan_2]))
+
+    # wait until processing is finished
+    assert finished.wait(timeout=10)
+    assert os.path.exists(output_scan_file)

tomwer/tests/orangecontrib/tomwer/widgets/control/tests/test_nxtomomill.py

@@ -0,0 +1,133 @@
+# coding: utf-8
+from __future__ import annotations
+
+import gc
+import os
+import shutil
+import tempfile
+import time
+
+from orangecanvas.scheme.readwrite import literal_dumps
+from processview.core.manager.manager import DatasetState, ProcessManager
+from silx.gui import qt
+from silx.gui.utils.testutils import TestCaseQt
+from tomoscan.esrf.scan.mock import MockEDF
+
+from orangecontrib.tomwer.widgets.control.EDF2NXTomomillOW import EDF2NXOW
+from orangecontrib.tomwer.widgets.control.NXTomomillOW import NXTomomillOW
+from tomwer.core.scan.blissscan import BlissScan
+from tomwer.core.scan.nxtomoscan import NXtomoScan
+from tomwer.core.utils.scanutils import MockBlissAcquisition
+
+
+class TestNXTomomillOw(TestCaseQt):
+    """
+    Test the NXTomomillOW widget
+    """
+
+    def setUp(self):
+        super().setUp()
+        self.tempdir = tempfile.mkdtemp()
+        mock = MockBlissAcquisition(
+            n_sample=1,
+            n_sequence=1,
+            n_scan_per_sequence=3,
+            n_darks=2,
+            n_flats=2,
+            output_dir=self.tempdir,
+        )
+        self.scan = BlissScan(
+            master_file=mock.samples[0].sample_file,
+            proposal_file=mock.proposal_file,
+            entry="1.1",
+        )
+        self.widget = NXTomomillOW()
+
+    def tearDown(self):
+        self.widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self.widget.close()
+        self.widget = None
+        shutil.rmtree(self.tempdir)
+        gc.collect()
+
+    def test(self):
+        self.widget.add(self.scan.master_file)
+        self.widget._sendAll()
+
+    def test_literal_dumps(self):
+        self.widget._saveNXTomoCfgFile(cfg_file="")
+        literal_dumps(self.widget._ewoks_default_inputs)
+
+
+class TestEDF2NXOW(TestCaseQt):
+    """
+    Test the EDF2NXOW widget
+    """
+
+    def setUp(self):
+        super().setUp()
+        self.tempdir = tempfile.mkdtemp()
+        self._edf_folder_1 = os.path.join(self.tempdir, "edf_scan_1")
+        self._edf_folder_2 = os.path.join(self.tempdir, "edf_scan_2_")
+        MockEDF(
+            scan_path=self._edf_folder_1,
+            n_radio=10,
+            n_ini_radio=10,
+            n_extra_radio=0,
+            dim=128,
+            dark_n=1,
+            flat_n=1,
+        )
+        MockEDF(
+            scan_path=self._edf_folder_2,
+            n_radio=10,
+            n_ini_radio=10,
+            n_extra_radio=0,
+            dim=128,
+            dark_n=1,
+            flat_n=1,
+        )
+        self.widget = EDF2NXOW()
+        self._process_manager = ProcessManager()
+
+    def tearDown(self):
+        self.widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self.widget.close()
+        self.widget = None
+        shutil.rmtree(self.tempdir)
+        gc.collect()
+
+    def test(self):
+        self.widget.add(self._edf_folder_1)
+        self.widget.add(self._edf_folder_2)
+        self.widget._sendAll()
+        self.qapp.processEvents()
+        timeout = 10
+        processing_queue = self.widget.task_executor_queue
+        while not processing_queue.is_available and not processing_queue.empty():
+            self.qapp.processEvents()
+            time.sleep(0.1)
+            timeout -= 0.1
+            if timeout <= 0:
+                raise TimeoutError
+        # need to call one more time the processEvents tpo call callbacks and status notification
+        for i in range(3):
+            self.qapp.processEvents()
+            time.sleep(0.1)
+
+        # check the two output files exists and status of the processing is done...
+        for folder in (self._edf_folder_1, self._edf_folder_2):
+            scan = NXtomoScan(scan=folder + ".nx", entry="entry")
+            self.assertTrue(os.path.exists(scan.master_file))
+
+            self.assertEqual(
+                self._process_manager.get_dataset_state(
+                    dataset_id=scan.get_identifier(),
+                    process=self.widget,
+                ),
+                DatasetState.SUCCEED,
+            )
+
+    def test_literal_dumps(self):
+        self.widget._saveNXTomoCfgFile(cfg_file="")
+        literal_dumps(self.widget._ewoks_default_inputs)

tomwer/tests/orangecontrib/tomwer/widgets/control/tests/test_reduce_dark_flat_selector.py

@@ -0,0 +1,40 @@
+import gc
+import pickle
+import numpy
+
+from silx.gui import qt
+from silx.gui.utils.testutils import TestCaseQt
+
+from orangecontrib.tomwer.widgets.control.ReduceDarkFlatSelectorOW import (
+    ReduceDarkFlatSelectorOW,
+)
+from orangecanvas.scheme.readwrite import literal_dumps
+
+
+class TestEmailOW(TestCaseQt):
+    def setUp(self):
+        super().setUp()
+        self.widget = ReduceDarkFlatSelectorOW()
+        self.widget._dialog.addReduceFrames(
+            {
+                "reduce_frames_name": "new dict",
+                -1: numpy.random.random(100 * 100).reshape(100, 100),
+                2: numpy.random.random(100 * 100).reshape(100, 100),
+            },
+            selected=(-1, 2),
+        )
+
+    def tearDown(self):
+        self.widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self.widget.close()
+        self.widget = None
+        gc.collect()
+
+    def test(self):
+        self.widget.show()
+
+    def test_serializing(self):
+        pickle.dumps(self.widget.getConfiguration())
+
+    def test_literal_dumps(self):
+        literal_dumps(self.widget.getConfiguration())