tomwer 1.2.1__py3-none-any.whl → 1.3.12__py3-none-any.whl

tomwer/gui/cluster/slurm.py

@@ -28,13 +28,23 @@ __license__ = "MIT"
 __date__ = "11/10/2021"
 
 
+import logging
 from typing import Optional
+from functools import lru_cache as cache
 
 from silx.gui import qt
-from sluurp.utils import get_partitions
+from sluurp.utils import get_partitions, get_partition_gpus
 
 from tomwer.core.settings import SlurmSettings, SlurmSettingsMode
 from tomwer.gui.utils.qt_utils import block_signals
+from tomwer.gui.configuration.action import (
+    BasicConfigurationAction,
+    ExpertConfigurationAction,
+)
+from tomwer.gui.configuration.level import ConfigurationLevel
+from nxtomomill.io.utils import convert_str_to_tuple
+
+_logger = logging.getLogger(__name__)
 
 
 class SlurmSettingsDialog(qt.QDialog):
@@ -58,10 +68,7 @@ class SlurmSettingsDialog(qt.QDialog):
         self._buttons.button(qt.QDialogButtonBox.Close).clicked.connect(self.close)
 
         # connect signal /slot
-        self._mainWidget.sigConfigChanged.connect(self._configChanged)
-
-    def _configChanged(self, *args, **kwargs):
-        self.sigConfigChanged.emit()
+        self._mainWidget.sigConfigChanged.connect(self.sigConfigChanged)
 
     def isSlurmActive(self):
         return self._mainWidget.isSlurmActive()
@@ -84,6 +91,29 @@ class SlurmSettingsWindow(qt.QMainWindow):
 
     def __init__(self, parent: Optional[qt.QWidget] = None) -> None:
         super().__init__(parent)
+
+        # define toolbar
+        toolbar = qt.QToolBar(self)
+        self.addToolBar(qt.Qt.TopToolBarArea, toolbar)
+
+        self.__configurationModesAction = qt.QAction(self)
+        self.__configurationModesAction.setCheckable(False)
+        menu = qt.QMenu(self)
+        self.__configurationModesAction.setMenu(menu)
+        toolbar.addAction(self.__configurationModesAction)
+
+        self.__configurationModesGroup = qt.QActionGroup(self)
+        self.__configurationModesGroup.setExclusive(True)
+        self.__configurationModesGroup.triggered.connect(self._userModeChanged)
+
+        self._basicConfigAction = BasicConfigurationAction(toolbar)
+        menu.addAction(self._basicConfigAction)
+        self.__configurationModesGroup.addAction(self._basicConfigAction)
+        self._expertConfiguration = ExpertConfigurationAction(toolbar)
+        menu.addAction(self._expertConfiguration)
+        self.__configurationModesGroup.addAction(self._expertConfiguration)
+
+        # define maini widget
         self._mainWidget = qt.QWidget(self)
         self._mainWidget.setLayout(qt.QFormLayout())
 
@@ -92,13 +122,15 @@ class SlurmSettingsWindow(qt.QMainWindow):
         self._modeCombox.addItems(SlurmSettingsMode.values())
         self._modeCombox.setCurrentText(SlurmSettingsMode.GENERIC.value)
 
-        self._settingsWidget = SlurmSettingsWidget(self)
+        self._settingsWidget = SlurmSettingsWidget(self, jobLimitation=None)
         self._mainWidget.layout().addRow(self._settingsWidget)
 
         self.setCentralWidget(self._mainWidget)
 
         # set up
         self._reloadPredefinedSettings()
+        self._basicConfigAction.setChecked(True)
+        self._userModeChanged(self._basicConfigAction)
 
         # connect signal / slot
         self._modeCombox.currentIndexChanged.connect(self._reloadPredefinedSettings)
@@ -106,6 +138,17 @@ class SlurmSettingsWindow(qt.QMainWindow):
         # when the settings widget is edited them we automatically move to 'manual' settings. To notify visually the user
         self._settingsWidget.sigConfigChanged.connect(self._switchToManual)
 
+    def _userModeChanged(self, action):
+        self.__configurationModesAction.setIcon(action.icon())
+        self.__configurationModesAction.setToolTip(action.tooltip())
+        if action is self._basicConfigAction:
+            level = ConfigurationLevel.OPTIONAL
+        elif action is self._expertConfiguration:
+            level = ConfigurationLevel.ADVANCED
+        else:
+            raise NotImplementedError
+        self._settingsWidget.setConfigurationLevel(level)
+
     def _reloadPredefinedSettings(self, *args, **kkwargs):
         """
         reload settings from some predefined configuration
@@ -125,6 +168,7 @@ class SlurmSettingsWindow(qt.QMainWindow):
                         "job_name": settingsClass.PROJECT_NAME,
                         "walltime": settingsClass.DEFAULT_WALLTIME,
                         "python_venv": settingsClass.PYTHON_VENV,
+                        "modules": settingsClass.MODULES_TO_LOAD,
                     }
                 )
 
@@ -179,13 +223,17 @@ class SlurmSettingsWidget(qt.QWidget):
         self._queue = qt.QComboBox(self)
         self._queue.setEditable(True)
         for partition in get_partitions():
+            if partition in ("nice*",):
+                # filter some node that we cannot access in fact
+                continue
             self._queue.addItem(partition)
         self.layout().addRow("queue / partition", self._queue)
 
         # n workers
         self._nWorkers = qt.QSpinBox(self)
         self._nWorkers.setRange(1, 100)
-        self.layout().addRow("number of task", self._nWorkers)
+        self._nWorkersLabel = qt.QLabel("number of task", self)
+        self.layout().addRow(self._nWorkersLabel, self._nWorkers)
 
         # ncores active
         self._nCores = qt.QSpinBox(self)
@@ -218,17 +266,34 @@ class SlurmSettingsWidget(qt.QWidget):
         self._wallTimeLabel = qt.QLabel("wall time", self)
         self.layout().addRow(self._wallTimeLabel, self._wallTimeQLE)
 
-        # python exe
-        self._pythonVenv = qt.QLineEdit("", self)
-        self.layout().addRow(
-            "source script before processing (python venv)", self._pythonVenv
-        )
+        # python exe / modules
+        self._preProcessingGroup = qt.QGroupBox("pre-processing", self)
+        self._preProcessingGroup.setLayout(qt.QFormLayout())
+        self._preProcessingButtonGroup = qt.QButtonGroup(self)
+        self._preProcessingButtonGroup.setExclusive(True)
+        self.layout().addRow(self._preProcessingGroup)
+
+        # python venv
+        self._pythonVenv = qt.QLineEdit("/scisoft/tomotools/activate stable", self)
+        self._sourceScriptCB = qt.QRadioButton("source script (python venv)", self)
+        self._preProcessingButtonGroup.addButton(self._sourceScriptCB)
+        self._preProcessingGroup.layout().addRow(self._sourceScriptCB, self._pythonVenv)
         self._pythonVenv.setToolTip(
             """
             Optional path to a bash script to source before executing the script.
             """
         )
 
+        self._modulesQLE = qt.QLineEdit(", ".join(SlurmSettings.MODULES_TO_LOAD), self)
+        self._modulesCB = qt.QRadioButton("module(s) to load", self)
+        self._preProcessingButtonGroup.addButton(self._modulesCB)
+        self._preProcessingGroup.layout().addRow(self._modulesCB, self._modulesQLE)
+        self._preProcessingGroup.setToolTip(
+            """
+            Optional list of modules to load before executing the script. each module must be separated by a coma
+            """
+        )
+
         # job name
         self._jobName = qt.QLineEdit("", self)
         self._jobName.setToolTip(
@@ -257,6 +322,39 @@ class SlurmSettingsWidget(qt.QWidget):
         self._dashboardPortLabel = qt.QLabel("dashboard port", self)
         self.layout().addRow(self._dashboardPortLabel, self._dashboardPort)
 
+        # sbatch advance parameters
+        self._sbatchAdvancedParameters = qt.QGroupBox("sbatch advanced settings", self)
+        self._sbatchAdvancedParameters.setLayout(qt.QFormLayout())
+        self.layout().addRow(self._sbatchAdvancedParameters)
+
+        ## export parameter
+        self._exportValueCM = qt.QComboBox(self)
+        self._exportValueCM.addItems(("NONE", "ALL"))
+        self._exportValueCM.setItemData(
+            self._exportValueCM.findText("NONE"),
+            """
+            Only SLURM_* variables from the user environment will be defined. User must use absolute path to the binary to be executed that will define the environment. User can not specify explicit environment variables with "NONE". However, Slurm will then implicitly attempt to load the user's environment on the node where the script is being executed, as if --get-user-env was specified. \nThis option is particularly important for jobs that are submitted on one cluster and execute on a different cluster (e.g. with different paths). To avoid steps inheriting environment export settings (e.g. "NONE") from sbatch command, the environment variable SLURM_EXPORT_ENV should be set to "ALL" in the job script.
+            """,
+        )
+        self._exportValueCM.setItemData(
+            self._exportValueCM.findText("ALL"),
+            """
+            All of the user's environment will be loaded (either from the caller's environment or from a clean environment if --get-user-env is specified). \nCan fail when submitting cross-platform jobs and user has some module loaded
+            """,
+        )
+        self._exportValueCM.setCurrentText("NONE")
+        self._sbatchAdvancedParameters.layout().addRow("--export", self._exportValueCM)
+
+        ## gpu card
+        self._gpuCardCB = qt.QComboBox(self)
+        self._gpuCardCB.setToolTip(
+            "Specify a GPU card to be used. Using the -C command from sbatch"
+        )
+        self._gpuCardCB.setEditable(
+            True
+        )  # let the user the ability to provide a GPU that is not found for now (expecting he knows what he is doing)
+        self._sbatchAdvancedParameters.layout().addRow("-C (gpu card)", self._gpuCardCB)
+
         # simplify gui
         self._wallTimeLabel.hide()
         self._wallTimeQLE.hide()
@@ -266,16 +364,23 @@ class SlurmSettingsWidget(qt.QWidget):
         self._job_nameQLabel.hide()
         self._portLabel.hide()  # for now we don't use the port. This can be done automatically
         self._port.hide()  # for now we don't use the port. This can be done automatically
+        # for now nworker == ntask is not used
+        self._nWorkers.setVisible(False)
+        self._nWorkersLabel.setVisible(False)
 
         # set up the gui
         self._nCores.setValue(SlurmSettings.N_CORES_PER_TASK)
         self._nWorkers.setValue(SlurmSettings.N_TASKS)
         self._memory.setValue(SlurmSettings.MEMORY_PER_WORKER)
-        self._queue.setCurrentText(SlurmSettings.PARTITION)
+        if self._queue.findText(SlurmSettings.PARTITION) >= 0:
+            self._queue.setCurrentText(SlurmSettings.PARTITION)
         self._nGpu.setValue(n_gpu)
         self._jobName.setText(SlurmSettings.PROJECT_NAME)
         self._wallTimeQLE.setText(SlurmSettings.DEFAULT_WALLTIME)
-        self._pythonVenv.setText(SlurmSettings.PYTHON_VENV)
+        self._modulesCB.setChecked(True)  # by default we go for modules
+        self._preProcessingModeChanged()
+        self._partitionChanged()
+        self._nGpuChanged()
 
         # connect signal / slot
         self._nCores.valueChanged.connect(self._configurationChanged)
@@ -286,8 +391,20 @@ class SlurmSettingsWidget(qt.QWidget):
         self._jobName.editingFinished.connect(self._configurationChanged)
         self._wallTimeQLE.editingFinished.connect(self._configurationChanged)
         self._pythonVenv.editingFinished.connect(self._configurationChanged)
+        self._modulesQLE.editingFinished.connect(self._configurationChanged)
+        self._preProcessingButtonGroup.buttonClicked.connect(self._configurationChanged)
         self._port.sigRangeChanged.connect(self._configurationChanged)
         self._dashboardPort.valueChanged.connect(self._configurationChanged)
+        self._preProcessingButtonGroup.buttonClicked.connect(
+            self._preProcessingModeChanged
+        )
+        self._queue.currentTextChanged.connect(self._partitionChanged)
+        self._nGpu.valueChanged.connect(self._nGpuChanged)
+        self._gpuCardCB.currentTextChanged.connect(self._configurationChanged)
+
+    def _nGpuChanged(self, *args, **kwargs):
+        nGpu = self.getNGPU()
+        self._gpuCardCB.setEnabled(nGpu > 0)
 
     def _configurationChanged(self, *args, **kwargs):
         self.sigConfigChanged.emit()
@@ -341,64 +458,122 @@ class SlurmSettingsWidget(qt.QWidget):
         self._wallTimeQLE.setText(walltime)
 
     def getPythonExe(self):
-        return self._pythonVenv.text()
+        if self._sourceScriptCB.isChecked():
+            return self._pythonVenv.text()
+        else:
+            return None
 
     def setPythonExe(self, python_venv):
         self._pythonVenv.setText(python_venv)
+        if python_venv != "":
+            self._sourceScriptCB.setChecked(True)
+
+    def getModulesToLoad(self) -> tuple:
+        if self._modulesCB.isChecked():
+            return convert_str_to_tuple(self._modulesQLE.text())
+        else:
+            return tuple()
+
+    def setModulesToLoad(self, modules: tuple):
+        if not isinstance(modules, (tuple, list)):
+            raise TypeError(
+                f"modules is expected to be a tuple or a list. Get {type(modules)} instead"
+            )
+        self._modulesQLE.setText(str(modules))
+        if len(modules) > 0:
+            self._modulesCB.setChecked(True)
+
+    def getGpuCard(self) -> Optional[str]:
+        card = self._gpuCardCB.currentText()
+        if card == "any" or self._nGpu == 0:
+            return None
+        else:
+            return card
+
+    def getSBatchExtraParams(self):
+        return {
+            "export": self._exportValueCM.currentText(),
+            "gpu_card": self.getGpuCard(),
+        }
+
+    def setSBatchExtraParams(self, params: dict):
+        export_ = params.get("export", None)
+        if export_ is not None:
+            index = self._exportValueCM.findText(export_)
+            if index >= 0:
+                self._exportValueCM.setCurrentIndex(index)
+        gpu_card = params.get("gpu_card", None)
+        if gpu_card is not None:
+            index = self._gpuCardCB.findText("gpu_card")
+            if index >= 0:
+                self._gpuCardCB.setCurrentIndex(index)
+            else:
+                # policy when setting the extra params: if doesn't exists / found then won't set it.
+                # because they can be part of .ows, this parameter is hidden by default.
+                # so safer to use 'any' in the case it is unknown (debatable).
+                _logger.warning(f"unable to find gpu {gpu_card}. Won't set it")
 
     def setConfiguration(self, config: dict) -> None:
-        old = self.blockSignals(True)
-        active_slurm = config.get("active_slurm", None)
-        if active_slurm is not None:
-            self._slurmCB.setChecked(active_slurm)
-
-        n_cores = config.get("cpu-per-task", None)
-        if n_cores is not None:
-            self.setNCores(n_cores)
-
-        n_workers = config.get("n_tasks", None)
-        if n_workers is not None:
-            self.setNWorkers(n_workers)
-
-        memory = config.get("memory", None)
-        if memory is not None:
-            if isinstance(memory, str):
-                memory = memory.replace(" ", "").lower().rstrip("gb")
-            self.setMemory(int(memory))
-
-        queue_ = config.get("partition", None)
-        if queue_ is not None:
-            queue_ = queue_.rstrip("'").rstrip('"')
-            queue_ = queue_.lstrip("'").lstrip('"')
-            self.setQueue(queue_)
-
-        n_gpu = config.get("n_gpus", None)
-        if n_gpu is not None:
-            self.setNGPU(int(n_gpu))
-
-        project_name = config.get("job_name", None)
-        if project_name is not None:
-            self.setProjectName(project_name)
-
-        wall_time = config.get("walltime", None)
-        if wall_time is not None:
-            self.setWallTime(wall_time)
-
-        python_venv = config.get("python_venv", None)
-        if python_venv is not None:
-            python_venv = python_venv.rstrip("'").rstrip('"')
-            python_venv = python_venv.lstrip("'").lstrip('"')
-            self.setPythonExe(python_venv)
-
-        n_jobs = config.get("n_jobs", None)
-        if n_jobs is not None:
-            self.setNJobs(n_jobs)
-
-        self.blockSignals(old)
+        with block_signals(self):
+            active_slurm = config.get("active_slurm", None)
+            if active_slurm is not None:
+                self._slurmCB.setChecked(active_slurm)
+
+            n_cores = config.get("cpu-per-task", None)
+            if n_cores is not None:
+                self.setNCores(n_cores)
+
+            n_workers = config.get("n_tasks", None)
+            if n_workers is not None:
+                self.setNWorkers(n_workers)
+
+            memory = config.get("memory", None)
+            if memory is not None:
+                if isinstance(memory, str):
+                    memory = memory.replace(" ", "").lower().rstrip("gb")
+                self.setMemory(int(memory))
+
+            queue_ = config.get("partition", None)
+            if queue_ is not None:
+                queue_ = queue_.rstrip("'").rstrip('"')
+                queue_ = queue_.lstrip("'").lstrip('"')
+                self.setQueue(queue_)
+
+            n_gpu = config.get("n_gpus", None)
+            if n_gpu is not None:
+                self.setNGPU(int(n_gpu))
+
+            project_name = config.get("job_name", None)
+            if project_name is not None:
+                self.setProjectName(project_name)
+
+            wall_time = config.get("walltime", None)
+            if wall_time is not None:
+                self.setWallTime(wall_time)
+
+            python_venv = config.get("python_venv", None)
+            if python_venv is not None:
+                python_venv = python_venv.rstrip("'").rstrip('"')
+                python_venv = python_venv.lstrip("'").lstrip('"')
+                self.setPythonExe(python_venv)
+
+            modules = config.get("modules", None)
+            if modules is not None:
+                modules = convert_str_to_tuple(modules)
+                self.setModulesToLoad(modules)
+
+            sbatch_extra_params = config.get("sbatch_extra_params", {})
+            self.setSBatchExtraParams(sbatch_extra_params)
+
+            n_jobs = config.get("n_jobs", None)
+            if n_jobs is not None:
+                self.setNJobs(n_jobs)
+            self._preProcessingModeChanged()  # make sure modules and python venv is enabled according to the activate mode
+
         self.sigConfigChanged.emit()
 
     def getConfiguration(self) -> dict:
-        return {
+        config = {
             "cpu-per-task": self.getNCores(),
             "n_tasks": self.getNWorkers(),
             "n_jobs": self.getNJobs(),
@@ -407,14 +582,48 @@ class SlurmSettingsWidget(qt.QWidget):
             "n_gpus": self.getNGPU(),
             "job_name": self.getProjectName(),
             "walltime": self.getWallTime(),
-            "python_venv": self.getPythonExe(),
+            "sbatch_extra_params": self.getSBatchExtraParams(),
         }
+        if self._modulesCB.isChecked():
+            config["modules"] = self.getModulesToLoad()
+        elif self._sourceScriptCB.isChecked():
+            config["python_venv"] = self.getPythonExe()
+        else:
+            raise ValueError("'modules' or python environement should be enable")
+        return config
 
     def getSlurmClusterConfiguration(self):
         from tomwer.core.cluster import SlurmClusterConfiguration
 
         return SlurmClusterConfiguration().from_dict(self.getConfiguration())
 
+    def _preProcessingModeChanged(self):
+        self._modulesQLE.setEnabled(self._modulesCB.isChecked())
+        self._pythonVenv.setEnabled(self._sourceScriptCB.isChecked())
+
+    def setConfigurationLevel(self, level: ConfigurationLevel):
+        self._sbatchAdvancedParameters.setVisible(level >= ConfigurationLevel.ADVANCED)
+
+    def _partitionChanged(self, *args, **kwargs):
+        partition = self.getQueue()
+        gpus = self._getGpus(partition=partition)
+        self._gpuCardCB.clear()
+        self._gpuCardCB.addItems(gpus)
+        self._gpuCardCB.setCurrentText("any")
+
+    @cache(maxsize=None)
+    def _getGpus(self, partition) -> tuple:
+        try:
+            gpus = get_partition_gpus(partition)
+        except Exception as e:
+            _logger.error(f"Failed to detect GPU on {partition}. Error is {e}")
+            gpus = ("any",)
+        else:
+            gpus = list(gpus) + [
+                "any",
+            ]
+            return gpus
+
 
 class _PortRangeSelection(qt.QWidget):
     sigRangeChanged = qt.Signal()

tomwer/gui/cluster/supervisor.py

@@ -102,6 +102,7 @@ class FutureTomwerScanObserverWidget(qt.QWidget):
             )
             if future_tomo_obj is not None:
                 self.sigConversionRequested.emit(future_tomo_obj)
+        self.observationTable.model().updateIndices()
         self.observationTable.model().layoutChanged.emit()
 
     def _cancelSelected(self, *args, **kwargs):
@@ -123,6 +124,7 @@ class FutureTomwerScanObserverWidget(qt.QWidget):
         self.observationTable.model().filtered_status = (
             self.filterWidget.getFilteredStatus()
         )
+        self.observationTable.model().endResetModel()
 
     def updateView(self):
         """
@@ -265,6 +267,16 @@ class _DatasetProcessModel(qt.QAbstractTableModel):
             del self._tomoObjStatus[future_tomo_obj]
         self.layoutChanged.emit()
 
+    def updateIndices(self):
+        """
+        Update tomo object indices when a tomo object has been removed (during a convertion for example)
+        """
+        tomo_objs = list(self.futureTomoObjs.values())
+        self.futureTomoObjs.clear()
+        for i_tomo_obj, tomo_obj in enumerate(tomo_objs):
+            self.futureTomoObjs[i_tomo_obj] = tomo_obj
+        self._computeUnfilteredFutureTomoObjs()
+
     def getUnfilteredFutureTomoObjs(self):
         return self._filteredFutureTomoObjs
 

tomwer/gui/cluster/test/test_cluster.py

@@ -58,12 +58,16 @@ class TestSlurmWidget(TestCaseQt):
             "cpu-per-task": SlurmSettings.N_CORES_PER_TASK,
             "n_tasks": SlurmSettings.N_TASKS,
             "memory": SlurmSettings.MEMORY_PER_WORKER,
-            "partition": SlurmSettings.PARTITION,
+            "partition": "",
             "n_gpus": SlurmSettings.N_GPUS_PER_WORKER,
             "job_name": "tomwer_{scan}_-_{process}_-_{info}",
             "n_jobs": 1,
-            "python_venv": "/scisoft/tomotools/activate stable",
+            "modules": ("tomotools/stable",),
             "walltime": "01:00:00",
+            "sbatch_extra_params": {
+                "export": "NONE",
+                "gpu_card": None,
+            },
         }
         assert dict_res == expected_dict, f"{dict_res} vs {expected_dict}"
 
@@ -75,6 +79,10 @@ class TestSlurmWidget(TestCaseQt):
                 "memory": 156,
                 "partition": "test-queue",
                 "n_gpus": 5,
+                "modules": "mymodule, mysecond/10.3",
+                "sbatch_extra_params": {
+                    "export": "ALL",
+                },
             }
         )
 
@@ -83,6 +91,10 @@ class TestSlurmWidget(TestCaseQt):
         assert self.slurmWidget.getMemory() == 156
         assert self.slurmWidget.getQueue() == "test-queue"
         assert self.slurmWidget.getNGPU() == 5
+        assert self.slurmWidget.getSBatchExtraParams() == {
+            "export": "ALL",
+            "gpu_card": None,
+        }
 
 
 def test_SlurmSettingsWindow(qtapp):  # noqa F811

tomwer/gui/cluster/test/test_supervisor.py

@@ -36,7 +36,7 @@ from silx.gui import qt
 from silx.gui.utils.testutils import TestCaseQt
 
 from tomwer.core.futureobject import FutureTomwerObject
-from tomwer.core.utils.scanutils import MockHDF5
+from tomwer.core.utils.scanutils import MockNXtomo
 from tomwer.gui.cluster.supervisor import FutureTomwerScanObserverWidget
 
 
@@ -52,12 +52,12 @@ class TestSupervisor(TestCaseQt):
         self._future_tomo_objs = []
         for i in range(5):
             # create scan
-            scan = MockHDF5(
+            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_ref=False,
+                create_ini_flat=False,
                 dim=10,
             ).scan
             self._scans.append(scan)

tomwer/gui/{reconstruction/nabu → configuration}/action.py

@@ -1,35 +1,4 @@
-# coding: utf-8
-# /*##########################################################################
-#
-# Copyright (c) 2016-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__ = "04/08/2020"
-
-
 from silx.gui import qt
-
 from tomwer.gui import icons as tomwer_icons
 
 
@@ -114,7 +83,7 @@ class FilterAction(qt.QAction):
         qt.QAction.__init__(self, icon, "filter configuration", parent)
         self.setToolTip(
             "If activated will only display the configuration"
-            "for the active nabu phase"
+            "for the active nabu step"
         )
         self.setCheckable(True)
         self.setShortcut(qt.QKeySequence(qt.Qt.Key_F))

tomwer/gui/configuration/level.py

@@ -0,0 +1,22 @@
+from silx.utils.enum import Enum as _Enum
+
+
+class ConfigurationLevel(_Enum):
+    REQUIRED = "required"
+    OPTIONAL = "optional"
+    ADVANCED = "advanced"
+
+    def _get_num_value(self) -> int:
+        if self is self.REQUIRED:
+            return 0
+        elif self is self.OPTIONAL:
+            return 1
+        elif self is self.ADVANCED:
+            return 2
+
+    def __le__(self, other):
+        if not isinstance(other, ConfigurationLevel):
+            raise TypeError(
+                f"other is expected to be an instance of ConfigurationLevel. {type(other)} provided"
+            )
+        return self._get_num_value() <= other._get_num_value()