tomwer 1.3.5__py3-none-any.whl → 1.3.7__py3-none-any.whl

orangecontrib/tomwer/test/TestAcquisition.py

@@ -0,0 +1,246 @@
+# coding: utf-8
+# /*##########################################################################
+#
+# Copyright (c) 2015-2016 European Synchrotron Radiation Facility
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# ###########################################################################*/
+"""Full tomwer test suite.
+
+"""
+
+__authors__ = ["H.Payno"]
+__license__ = "MIT"
+__date__ = "19/01/2017"
+
+import logging
+import os
+import shutil
+
+from silx.gui import qt
+
+from tomwer.core.scan.edfscan import EDFTomoScan
+from tomwer.tests.datasets import TomwerCIDatasets
+
+logger = logging.getLogger(__name__)
+
+
+class Simulation(qt.QThread):
+    """Simulation is a simple class able to simulate an acquisition by copying
+    files on a targetted directory.
+
+    :param str: targetdir the folder where the acquisition is stored
+    :param str: manipulationId the id of the simulation we want to simulate
+    :param str: finalState when launched, the state to reach before stopping
+
+    :warning: the targetted directory won't be removed or cleaned during class
+        destruction. This is to be managed by callers.
+    """
+
+    advancement = {
+        "not started": -1,
+        "starting-s0": 0,
+        "starting-s1": 1,
+        "acquisitionRunning": 2,
+        "acquisitionDone": 3,
+        "reconstructionLaunched": 4,
+    }
+    sigAdvancementChanged = qt.Signal(int)
+
+    __definedDataset = ["test01", "test10"]
+
+    def __init__(self, targetdir, manipulationId, finalState=4):
+        assert type(manipulationId) is str
+        assert type(targetdir) is str
+        assert manipulationId in self.__definedDataset
+        super(Simulation, self).__init__()
+
+        self.targetdir = targetdir
+        self.outputFolder = os.path.sep.join((targetdir, manipulationId))
+        self.finalState = finalState
+        self.currentState = "not started"
+        self._createFinalXML = False
+        (
+            self.originalFolder,
+            self.nbSlices,
+            self.manipulationId,
+        ) = self.__getOriginalDataSet(manipulationId)
+        self.stopFileCreationForRunningState = int(self.nbSlices / 2)
+        self.srcPattern = None
+        self.destPattern = None
+
+    def __getOriginalDataSet(self, dataSetID):
+        """Return paths to the requested scan"""
+        assert dataSetID in self.__definedDataset
+        dataDir = TomwerCIDatasets.get_dataset(os.path.join("edf_datasets", dataSetID))
+
+        assert os.path.isdir(dataDir)
+        assert os.path.isfile(os.path.join(dataDir, dataSetID + ".info"))
+        slices = EDFTomoScan(dataDir).projections
+        nbSlices = len(slices)
+        manipulationID = dataSetID
+
+        return dataDir, nbSlices, manipulationID
+
+    def advanceTo(self, state):
+        """Reset the new advancement targetted
+
+        :param str state: the new state to reach when run will be executed
+        """
+        assert state in Simulation.advancement
+        assert type(state) is str
+        self.finalState = Simulation.advancement[state]
+
+    def setSrcDestPatterns(self, srcPattern, destPattern):
+        """
+        If setted, will set the .info and .xml files into a different folder
+        """
+        self.srcPattern = srcPattern
+        self.destPattern = destPattern
+        if srcPattern is not None or destPattern is not None:
+            assert os.path.isdir(srcPattern)
+            assert os.path.isdir(destPattern)
+            targettedFolder = self.outputFolder.replace(
+                self.srcPattern, self.destPattern, 1
+            )
+            if not os.path.isdir(targettedFolder):
+                os.makedirs(targettedFolder)
+
+    def __shouldExecStep(self, step):
+        """Return True if the thread should exec this step to advance taking
+        into consideration is current state and his final state
+        """
+        return self.finalState >= self.advancement[step] and (
+            Simulation.advancement[self.currentState] + 1 == self.advancement[step]
+        )
+
+    def run(self):
+        """Main function, run the acquisition through all states until
+        finalState is reached
+        """
+        if self.__shouldExecStep("starting-s0") is True:
+            logger.info("starting-s0")
+            self._startAcquisition()
+            self.currentState = "starting-s0"
+            self.signalCurrentState()
+
+        if self.__shouldExecStep("starting-s1") is True:
+            self.copyInitialFiles()
+            logger.info("starting-s1")
+            self.currentState = "starting-s1"
+            self.signalCurrentState()
+
+        if self.__shouldExecStep("acquisitionRunning") is True:
+            self._copyScans((0, self.stopFileCreationForRunningState))
+            logger.info("acquisitionRunning")
+            self.currentState = "acquisitionRunning"
+            self.signalCurrentState()
+
+        if self.__shouldExecStep("acquisitionDone") is True:
+            self._copyScans((self.stopFileCreationForRunningState, self.nbSlices))
+            if self._createFinalXML is True:
+                inputXMLFile = os.path.join(
+                    self.originalFolder, self.manipulationId + ".xml"
+                )
+                assert os.path.isfile(inputXMLFile)
+                ouputXMLFile = os.path.join(
+                    self.outputFolder, self.manipulationId + ".xml"
+                )
+                shutil.copyfile(inputXMLFile, ouputXMLFile)
+
+            logger.info("acquisitionDone")
+            self.currentState = "acquisitionDone"
+            self.signalCurrentState()
+
+    def signalCurrentState(self):
+        """Signal the actual state of the simulation"""
+        self.sigAdvancementChanged.emit(self.currentState)
+
+    def _startAcquisition(self):
+        """create needed data dir"""
+        for newFolder in (self.targetdir, self.outputFolder):
+            if not os.path.exists(self.outputFolder):
+                os.makedirs(self.outputFolder)
+
+    def _copyScans(self, _slicesRange):
+        """copy the .edf file from the original directory to the outputFolder
+
+        :_slicesRange tuple: the _range of slices data we want to copy
+        """
+        logger.info("copying files from %s to %s" % (_slicesRange[0], _slicesRange[1]))
+        for iSlice in list(range(_slicesRange[0], _slicesRange[1])):
+            filename = "".join((self.manipulationId, format(iSlice, "04d"), ".edf"))
+            srcFile = os.path.join(self.originalFolder, filename)
+            outputFile = os.path.join(self.outputFolder, filename)
+            assert os.path.isfile(srcFile)
+            assert os.path.isdir(self.outputFolder)
+            shutil.copyfile(srcFile, outputFile)
+
+    def copyInitialFiles(self):
+        """copy the .info file"""
+        assert os.path.isdir(self.originalFolder)
+        logger.info(
+            "copying initial files (.info, .xml...) from %s to %s"
+            % (self.originalFolder, self.manipulationId)
+        )
+        for extension in (".info", ".db", ".cfg"):
+            filename = "".join((self.manipulationId, extension))
+            srcFile = os.path.join(self.originalFolder, filename)
+
+            targettedFolder = self.outputFolder
+            if self.srcPattern is not None or self.destPattern is not None:
+                targettedFolder = self.outputFolder.replace(
+                    self.srcPattern, self.destPattern, 1
+                )
+            assert os.path.isfile(srcFile)
+            assert os.path.isdir(targettedFolder)
+            assert os.path.isdir(self.originalFolder)
+            shutil.copy2(srcFile, targettedFolder)
+
+    def createFinalXML(self, val):
+        """If activated, once all the file will be copied, this will create
+        an .xml file into the output directory
+        """
+        self._createFinalXML = val
+
+    def createParFile(self):
+        pass
+
+    def createReconstructedFile(self):
+        pass
+
+    def createOARJob(self):
+        pass
+
+    def createDark(self):
+        pass
+
+    def createJPG(self):
+        pass
+
+    def createVolfloat(self):
+        pass
+
+    def createVolraw(self):
+        pass
+
+    def __createFileTo(self, filePath):
+        assert type(filePath) is str
+        open(filePath, "a").close()

orangecontrib/tomwer/widgets/cluster/test/test_future_supervisorow.py

@@ -0,0 +1,87 @@
+# coding: utf-8
+# /*##########################################################################
+#
+# Copyright (c) 2017-2019 European Synchrotron Radiation Facility
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# ###########################################################################*/
+__authors__ = ["H. Payno"]
+__license__ = "MIT"
+__date__ = "10/12/2021"
+
+
+import asyncio
+import os
+import shutil
+import tempfile
+
+import pytest
+from silx.gui import qt
+from silx.gui.utils.testutils import TestCaseQt
+
+from orangecontrib.tomwer.widgets.cluster.FutureSupervisorOW import FutureSupervisorOW
+from tomwer.core.futureobject import FutureTomwerObject
+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 TestFutureSupervisorOW(TestCaseQt):
+    """Test that the axis widget work correctly"""
+
+    def setUp(self):
+        super().setUp()
+        self._window = FutureSupervisorOW()
+        self.tempdir = tempfile.mkdtemp()
+
+        # set up scans
+        self._scans = []
+        self._future_tomo_objs = []
+        for i in range(5):
+            # create scan
+            scan = MockNXtomo(
+                scan_path=os.path.join(self.tempdir, f"scan_test{i}"),
+                n_proj=10,
+                n_ini_proj=10,
+                create_ini_dark=False,
+                create_ini_flat=False,
+                dim=10,
+            ).scan
+            self._scans.append(scan)
+
+            # create future
+            future = asyncio.Future()
+            if i == 1:
+                future.set_result(None)
+            self._future_tomo_objs.append(
+                FutureTomwerObject(
+                    tomo_obj=scan,
+                    futures=(future,),
+                )
+            )
+
+    def tearDown(self):
+        self._window.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self._window.close()
+        self._window = None
+        shutil.rmtree(self.tempdir)
+        self._scans.clear()
+        self._future_tomo_objs.clear()
+        super().tearDown()

orangecontrib/tomwer/widgets/cluster/test/test_slurm_clusterow.py

@@ -0,0 +1,67 @@
+# coding: utf-8
+# /*##########################################################################
+#
+# Copyright (c) 2017-2019 European Synchrotron Radiation Facility
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# ###########################################################################*/
+__authors__ = ["H. Payno"]
+__license__ = "MIT"
+__date__ = "10/12/2021"
+
+
+import gc
+import pickle
+
+import pytest
+from orangecanvas.scheme.readwrite import literal_dumps
+from silx.gui import qt
+from silx.gui.utils.testutils import TestCaseQt
+
+from orangecontrib.tomwer.widgets.cluster.SlurmClusterOW import SlurmClusterOW
+from tomwer.core.cluster.cluster import SlurmClusterConfiguration
+from tomwer.tests.utils import skip_gui_test
+
+
+@pytest.mark.skipif(skip_gui_test(), reason="skip gui test")
+class TestSlurmClusterOW(TestCaseQt):
+    """Test that the axis widget work correctly"""
+
+    def setUp(self):
+        super().setUp()
+        self._window = SlurmClusterOW()
+
+    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)
+        configuration = self._window.getConfiguration()
+        assert isinstance(configuration, SlurmClusterConfiguration)
+
+    def test_serializing(self):
+        pickle.dumps(self._window.getConfiguration().to_dict())
+
+    def test_literal_dumps(self):
+        literal_dumps(self._window.getConfiguration().to_dict())

orangecontrib/tomwer/widgets/control/test/test_advancement.py

@@ -0,0 +1,51 @@
+# coding: utf-8
+# /*##########################################################################
+#
+# Copyright (c) 2017 European Synchrotron Radiation Facility
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# ###########################################################################*/
+
+__authors__ = ["H. Payno"]
+__license__ = "MIT"
+__date__ = "17/06/2021"
+
+
+import gc
+
+from silx.gui import qt
+from silx.gui.utils.testutils import TestCaseQt
+
+from orangecontrib.tomwer.widgets.control.AdvancementOW import AdvancementOW
+
+
+class TestAdvancementOw(TestCaseQt):
+    def setUp(self):
+        super().setUp()
+        self.widget = AdvancementOW()
+
+    def tearDown(self):
+        self.widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self.widget.close()
+        self.widget = None
+        gc.collect()
+
+    def test(self):
+        self.widget.show()

orangecontrib/tomwer/widgets/control/test/test_data_validator.py

@@ -0,0 +1,55 @@
+import gc
+import os
+import shutil
+import tempfile
+
+from silx.gui import qt
+from silx.gui.utils.testutils import TestCaseQt
+
+from orangecontrib.tomwer.widgets.control.DataValidatorOW import DataValidatorOW
+from tomwer.core.utils.scanutils import MockNXtomo
+
+
+class TestDataValidatorOW(TestCaseQt):
+    """
+    simple test on the DataValidatorOW widget
+    """
+
+    def setUp(self):
+        super().setUp()
+        self.window = DataValidatorOW()
+        self.folder = tempfile.mkdtemp()
+        self.scan_1 = MockNXtomo(
+            scan_path=os.path.join(self.folder, "scan_1"),
+            n_proj=20,
+            n_ini_proj=20,
+            dim=10,
+        ).scan
+        self.scan_2 = MockNXtomo(
+            scan_path=os.path.join(self.folder, "scan_2"),
+            n_proj=20,
+            n_ini_proj=20,
+            dim=10,
+        ).scan
+
+    def tearDown(self):
+        self.window.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self.window.close()
+        self.window = None
+        shutil.rmtree(self.folder)
+        gc.collect()
+
+    def test(self):
+        def wait_processing():
+            while self.qapp.hasPendingEvents():
+                self.qapp.processEvents()
+
+        assert self.window.getNScanToValidate() == 0
+        self.window.addScan(self.scan_1)
+        wait_processing()
+        self.window.addScan(self.scan_2)
+        wait_processing()
+        assert self.window.getNScanToValidate() == 2
+        self.window._widget.validateCurrentScan()
+        wait_processing()
+        assert self.window.getNScanToValidate() == 1

orangecontrib/tomwer/widgets/control/test/test_datadiscovery.py

@@ -0,0 +1,131 @@
+__authors__ = ["H. Payno"]
+__license__ = "MIT"
+__date__ = "27/03/2023"
+
+
+import gc
+import os
+import pickle
+import tempfile
+
+from orangecanvas.scheme.readwrite import literal_dumps
+from silx.gui import qt
+from silx.gui.utils.testutils import SignalListener, TestCaseQt
+
+from orangecontrib.tomwer.widgets.control.DataDiscoveryOW import DataDiscoveryOW
+from tomwer.core.scan.scantype import ScanType
+from tomwer.core.utils.scanutils import MockBlissAcquisition
+from tomoscan.esrf.scan.mock import MockNXtomo, MockEDF
+
+
+class TestDataDiscovery(TestCaseQt):
+    WAIT_TIME = 5000  # thread processing wait time in ms
+
+    def setUp(self):
+        super().setUp()
+        self.widget = DataDiscoveryOW()
+        self.widget.setConfiguration(self.default_settings)
+        self.signal_listener = SignalListener()
+        self.widget.getProcessingThread().sigDataFound.connect(self.signal_listener)
+
+    def tearDown(self):
+        self.widget.getProcessingThread().sigDataFound.disconnect(self.signal_listener)
+        self.signal_listener = None
+        self.widget.setAttribute(qt.Qt.WA_DeleteOnClose)
+        self.widget.close()
+        self.widget = None
+        gc.collect()
+
+    @property
+    def default_settings(self):
+        return {
+            "start_folder": "/my/folder",
+            "file_filter": "*.h5",
+            "scan_type_searched": ScanType.NX_TOMO,
+        }
+
+    def testSerialization(self):
+        """make sure pickling works for the settings"""
+        pickle.dumps(self.widget.getConfiguration())
+
+    def testLiteralDumps(self):
+        """make sure literal dumps (from orangecanvas) works for the settings"""
+        literal_dumps(self.widget.getConfiguration())
+
+    def testProcessingNXtomo(self):
+        """Test the widget can find NXtomos"""
+        n_scan = 3
+        with tempfile.TemporaryDirectory() as root_dir:
+            for i_scan in range(n_scan):
+                MockNXtomo(
+                    scan_path=os.path.join(root_dir, f"sub_folder_{i_scan}", "scan"),
+                    n_proj=10,
+                    n_ini_proj=10,
+                    dim=10,
+                )
+            self.widget.setFolderObserved(root_dir)
+            self.widget.start_discovery(wait=self.WAIT_TIME)
+            while self.qapp.hasPendingEvents():
+                self.qapp.processEvents()
+
+            assert self.signal_listener.callCount() == n_scan
+
+    def testProcessingBlissRawScan(self):
+        """Test the widget can find bliss raw scans"""
+        with tempfile.TemporaryDirectory() as root_dir:
+            n_scan = 2
+            for i_scan in range(n_scan):
+                MockBlissAcquisition(
+                    n_sample=1,
+                    n_sequence=1,
+                    n_scan_per_sequence=1,
+                    n_darks=1,
+                    n_flats=1,
+                    with_nx=True,
+                    output_dir=os.path.join(root_dir, f"sub_folder_{i_scan}", "scan"),
+                )
+
+            self.widget.setFilePattern("*.edf")
+            self.widget.setSearchScanType(ScanType.BLISS)
+            self.widget.setFolderObserved(root_dir)
+            self.widget.start_discovery(wait=self.WAIT_TIME)
+            while self.qapp.hasPendingEvents():
+                self.qapp.processEvents()
+
+            assert (
+                self.signal_listener.callCount() == 0
+            )  # because of the filtering on files
+            self.widget.setFilePattern(None)
+            self.widget.start_discovery(wait=self.WAIT_TIME)
+            while self.qapp.hasPendingEvents():
+                self.qapp.processEvents()
+
+            assert self.signal_listener.callCount() == n_scan
+
+    def testProcessingSpecScan(self):
+        """Test the widget can find bliss raw scans"""
+        with tempfile.TemporaryDirectory() as root_dir:
+            n_scan = 4
+            for i_scan in range(n_scan):
+                MockEDF(
+                    n_radio=4,
+                    n_ini_radio=4,
+                    scan_path=os.path.join(root_dir, f"sub_folder_{i_scan}", "scan"),
+                )
+
+            self.widget.setSearchScanType(ScanType.BLISS)
+            self.widget.setFilePattern(None)
+            self.widget.setFolderObserved(root_dir)
+            self.widget.start_discovery(wait=self.WAIT_TIME)
+            while self.qapp.hasPendingEvents():
+                self.qapp.processEvents()
+
+            assert (
+                self.signal_listener.callCount() == 0
+            )  # because of the scan type searched
+            self.widget.setSearchScanType(ScanType.SPEC)
+            self.widget.setFilePattern(None)
+            self.widget.start_discovery(wait=self.WAIT_TIME)
+            while self.qapp.hasPendingEvents():
+                self.qapp.processEvents()
+            assert self.signal_listener.callCount() == n_scan