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

tomwer/gui/cluster/slurm.py

@@ -1,47 +1,22 @@
-# 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__ = "11/10/2021"
-
+from __future__ import annotations
 
+import os
+import re
 import logging
-from typing import Optional
 from functools import lru_cache as cache
 
 from silx.gui import qt
-from sluurp.utils import get_partitions, get_partition_gpus
+from sluurp.utils import get_partitions, get_partition_gpus, get_partition_walltime
 
 from tomwer.core.settings import SlurmSettings, SlurmSettingsMode
+from tomwer.gui import icons
 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__)
@@ -89,7 +64,7 @@ class SlurmSettingsWindow(qt.QMainWindow):
     sigConfigChanged = qt.Signal()
     """Signal emit when the SlurmSetting changed"""
 
-    def __init__(self, parent: Optional[qt.QWidget] = None) -> None:
+    def __init__(self, parent: qt.QWidget | None = None) -> None:
         super().__init__(parent)
 
         # define toolbar
@@ -166,6 +141,7 @@ class SlurmSettingsWindow(qt.QMainWindow):
                         "partition": settingsClass.PARTITION,
                         "n_gpus": settingsClass.N_GPUS_PER_WORKER,
                         "job_name": settingsClass.PROJECT_NAME,
+                        "walltime": settingsClass.DEFAULT_WALLTIME,
                         "python_venv": settingsClass.PYTHON_VENV,
                         "modules": settingsClass.MODULES_TO_LOAD,
                     }
@@ -204,122 +180,175 @@ class SlurmSettingsWidget(qt.QWidget):
     sigConfigChanged = qt.Signal()
     """Signal emit when the SlurmSetting changed"""
 
+    WALL_TIME_INVALID_COLOR = qt.QColor("#FF0000")
+
     def __init__(
         self,
         parent=None,
         n_gpu=SlurmSettings.N_GPUS_PER_WORKER,
-        jobLimitation: Optional[int] = 1,
+        jobLimitation: int | None = 1,
     ) -> None:
         """
-        :param int n_gpu: if provided will set the value to the number of gpu requested
+        :param n_gpu: if provided will set the value to the number of gpu requested
                           (default is one as most of the job are nabu reconstruction)
-        :param Optional[int] jobLimitation: if set then will hide the option to define the number of job
+        :param jobLimitation: if set then will hide the option to define the number of job
         """
         super().__init__(parent=parent)
-        self.setLayout(qt.QFormLayout())
+        self.setLayout(qt.QGridLayout())
+        """Action to display warning in case of possible 'wrong' setting"""
+        # define some optional warning
+        warning_icon = icons.getQIcon("warning")
+        self._warning_opd_p9 = qt.QLabel("")
+        self._warning_opd_p9.setPixmap(warning_icon.pixmap(20, state=qt.QIcon.On))
+        self._warning_opd_p9.setToolTip(
+            f"'{get_login()}' account cannot submit job on p9 architecture"
+        )
+        self._warning_opd_export_opts = qt.QLabel("")
+        self._warning_opd_export_opts.setPixmap(
+            warning_icon.pixmap(20, state=qt.QIcon.On)
+        )
+        self._warning_opd_export_opts.setToolTip(
+            f"'{get_login()}' account needs to export job with ALL option (advanced settings)"
+        )
 
         # queues
-        self._queue = qt.QComboBox(self)
-        self._queue.setEditable(True)
+        self._queueLabel = qt.QLabel("queue / partition")
+        self.layout().addWidget(self._queueLabel, 0, 0, 1, 1)
+        self._queueCB = qt.QComboBox(self)
+        self._queueCB.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)
+            self._queueCB.addItem(partition)
+        self.layout().addWidget(self._queueCB, 0, 1, 1, 1)
+        self.layout().addWidget(self._warning_opd_p9, 0, 2, 1, 1)
 
         # n workers
-        self._nWorkers = qt.QSpinBox(self)
-        self._nWorkers.setRange(1, 100)
         self._nWorkersLabel = qt.QLabel("number of task", self)
-        self.layout().addRow(self._nWorkersLabel, self._nWorkers)
+        self.layout().addWidget(self._nWorkersLabel, 1, 0, 1, 1)
+        self._nWorkersSP = qt.QSpinBox(self)
+        self._nWorkersSP.setRange(1, 100)
+        self.layout().addWidget(self._nWorkersSP, 1, 1, 1, 1)
 
         # ncores active
-        self._nCores = qt.QSpinBox(self)
-        self._nCores.setRange(1, 500)
-        self.layout().addRow("number of cores per task", self._nCores)
+        self._nCoresLabel = qt.QLabel("number of cores per task")
+        self.layout().addWidget(self._nCoresLabel, 2, 0, 1, 1)
+        self._nCoresSB = qt.QSpinBox(self)
+        self._nCoresSB.setRange(1, 500)
+        self.layout().addWidget(self._nCoresSB, 2, 1, 1, 1)
 
         # memory
-        self._memory = qt.QSpinBox(self)
-        self._memory.setRange(1, 10000)
-        self._memory.setSuffix("GB")
-        self.layout().addRow("memory per task", self._memory)
+        self._memoryLabel = qt.QLabel("memory per task")
+        self.layout().addWidget(self._memoryLabel, 3, 0, 1, 1)
+        self._memorySB = qt.QSpinBox(self)
+        self._memorySB.setRange(1, 10000)
+        self._memorySB.setSuffix("GB")
+        self.layout().addWidget(self._memorySB, 3, 1, 1, 1)
 
         # gpu
-        self._nGpu = qt.QSpinBox(self)
-        self._nGpu.setRange(0, 12)
-        self.layout().addRow("number of GPUs per task", self._nGpu)
+        self._nGpuLabel = qt.QLabel("number of GPUs per task")
+        self.layout().addWidget(self._nGpuLabel, 4, 0, 1, 1)
+        self._nGpuSB = qt.QSpinBox(self)
+        self._nGpuSB.setRange(0, 12)
+        self.layout().addWidget(self._nGpuSB, 4, 1, 1, 1)
 
         # n jobs
+        self._nJobsLabel = qt.QLabel("number of job", self)
+        self.layout().addWidget(self._nJobsLabel, 5, 0, 1, 1)
+
         self._nJobs = qt.QSpinBox(self)
         self._nJobs.setRange(1, 100000)
         self._nJobs.setValue(1)
-        self._nJobsLabel = qt.QLabel("number of job", self)
-        self.layout().addRow(self._nJobsLabel, self._nJobs)
         self._nJobs.setToolTip("Define on how many part the job should be split in")
         self._nJobsLabel.setVisible(jobLimitation is None)
         self._nJobs.setVisible(jobLimitation is None)
+        self.layout().addWidget(self._nJobs, 5, 1, 1, 1)
+
+        # wall time
+        self._wallTimeLabel = qt.QLabel("wall time", self)
+        self.layout().addWidget(self._wallTimeLabel, 6, 0, 1, 1)
+        self._wallTimeQLE = qt.QLineEdit("", self)
+        self.__reWallTime = qt.QRegularExpression(
+            r"[0-9]?[0-9]:[0-9]?[0-9]:[0-9]?[0-9]"
+        )
+        self._wallTimeQLE.setPlaceholderText("HH:MM:SS")
+        self._wallTimeValidator = qt.QRegularExpressionValidator(
+            self.__reWallTime, self
+        )
+        self._wallTimeQLE.setValidator(self._wallTimeValidator)
+        self.layout().addWidget(self._wallTimeQLE, 6, 1, 1, 1)
+        self.__defaultWallTimeBackgroundColor = self.palette().color(
+            self._wallTimeQLE.backgroundRole()
+        )
+        self._warningWallTime = qt.QLabel("")
+        self._warningWallTime.setPixmap(warning_icon.pixmap(20, state=qt.QIcon.On))
+        self.layout().addWidget(self._warningWallTime, 6, 2, 1, 1)
 
         # 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)
+        self.layout().addWidget(self._preProcessingGroup, 10, 0, 1, 2)
 
         # python venv
-        self._pythonVenv = qt.QLineEdit("/scisoft/tomotools/activate stable", self)
         self._sourceScriptCB = qt.QRadioButton("source script (python venv)", self)
+        self._pythonVenv = qt.QLineEdit("/scisoft/tomotools/activate stable", 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._preProcessingGroup.layout().addRow(self._sourceScriptCB, self._pythonVenv)
+        # module
         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
             """
         )
+        self._preProcessingGroup.layout().addRow(self._modulesCB, self._modulesQLE)
 
         # job name
+        self._job_nameQLabel = qt.QLabel("job name", self)
+        self.layout().addWidget(self._job_nameQLabel, 13, 0, 1, 1)
+
         self._jobName = qt.QLineEdit("", self)
         self._jobName.setToolTip(
             """Job name. Can contains several keyword that will be formatted:
             - scan: will be replaced by the scan name
             - process: will be replaced by the process name (nabu slices, nabu volume...)
             - info: some extra information that can be provided by the process to `specify` the processing
-            note: those key word have to be surronding by surrounded `{` and `}` in order to be formatted.
+            note: those key word have to be surrounding by surrounded `{` and `}` in order to be formatted.
             """
         )
-        self._job_nameQLabel = qt.QLabel("job name", self)
-        self.layout().addRow(self._job_nameQLabel, self._jobName)
+        self.layout().addWidget(self._jobName, 13, 1, 1, 1)
 
         # port
         # fixme: replace by a dedicated widget / validator for TCP adress
+        self._portLabel = qt.QLabel("port", self)
+        self.layout().addWidget(self._portLabel, 14, 0, 1, 1)
         self._port = _PortRangeSelection(self)
         self._port.setRange(0, 99999)
         self._port.setToolTip("TCP Port for the dask-distributed scheduler")
-        self._portLabel = qt.QLabel("port", self)
-        self.layout().addRow(self._portLabel, self._port)
+        self.layout().addWidget(self._port, 14, 1, 1, 1)
 
         # dashboard port
         self._dashboardPort = qt.QSpinBox(self)
+        self.layout().addWidget(self._dashboardPort, 15, 0, 1, 1)
         self._dashboardPort.setRange(0, 99999)
         self._dashboardPort.setToolTip("TCP Port for the dashboard")
         self._dashboardPortLabel = qt.QLabel("dashboard port", self)
-        self.layout().addRow(self._dashboardPortLabel, self._dashboardPort)
+        self.layout().addWidget(self._dashboardPort, 15, 1, 1, 1)
 
         # sbatch advance parameters
         self._sbatchAdvancedParameters = qt.QGroupBox("sbatch advanced settings", self)
         self._sbatchAdvancedParameters.setLayout(qt.QFormLayout())
-        self.layout().addRow(self._sbatchAdvancedParameters)
+        self.layout().addWidget(self._sbatchAdvancedParameters, 16, 0, 1, 2)
 
         ## export parameter
         self._exportValueCM = qt.QComboBox(self)
@@ -338,6 +367,7 @@ class SlurmSettingsWidget(qt.QWidget):
         )
         self._exportValueCM.setCurrentText("NONE")
         self._sbatchAdvancedParameters.layout().addRow("--export", self._exportValueCM)
+        self.layout().addWidget(self._warning_opd_export_opts, 16, 2, 1, 1)
 
         ## gpu card
         self._gpuCardCB = qt.QComboBox(self)
@@ -357,29 +387,39 @@ class SlurmSettingsWidget(qt.QWidget):
         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._nWorkersSP.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)
-        if self._queue.findText(SlurmSettings.PARTITION) >= 0:
-            self._queue.setCurrentText(SlurmSettings.PARTITION)
-        self._nGpu.setValue(n_gpu)
+        self._nCoresSB.setValue(SlurmSettings.N_CORES_PER_TASK)
+        self._nWorkersSP.setValue(SlurmSettings.N_TASKS)
+        self._memorySB.setValue(SlurmSettings.MEMORY_PER_WORKER)
+        if self._queueCB.findText(SlurmSettings.PARTITION) >= 0:
+            self._queueCB.setCurrentText(SlurmSettings.PARTITION)
+        self._nGpuSB.setValue(n_gpu)
         self._jobName.setText(SlurmSettings.PROJECT_NAME)
+        self._wallTimeQLE.setText(SlurmSettings.DEFAULT_WALLTIME)
         self._modulesCB.setChecked(True)  # by default we go for modules
+        self._warning_opd_p9.setVisible(False)
+        self._warning_opd_export_opts.setVisible(False)
+        self._warningWallTime.setVisible(False)
         self._preProcessingModeChanged()
         self._partitionChanged()
+        self._sbatchAdvancedSettingsChanged()
         self._nGpuChanged()
 
         # connect signal / slot
-        self._nCores.valueChanged.connect(self._configurationChanged)
-        self._nWorkers.valueChanged.connect(self._configurationChanged)
-        self._memory.valueChanged.connect(self._configurationChanged)
-        self._queue.currentTextChanged.connect(self._configurationChanged)
-        self._nGpu.valueChanged.connect(self._configurationChanged)
+        self._nCoresSB.valueChanged.connect(self._configurationChanged)
+        self._nWorkersSP.valueChanged.connect(self._configurationChanged)
+        self._memorySB.valueChanged.connect(self._configurationChanged)
+        self._queueCB.currentTextChanged.connect(self._configurationChanged)
+        self._queueCB.currentTextChanged.connect(self._updateWallTimeWarnings)
+        self._queueCB.currentTextChanged.connect(self._updateWallTimeTooltip)
+        self._nGpuSB.valueChanged.connect(self._configurationChanged)
         self._jobName.editingFinished.connect(self._configurationChanged)
+        self._wallTimeQLE.editingFinished.connect(self._configurationChanged)
+        self._wallTimeQLE.editingFinished.connect(self._updateWallTimeWarnings)
+        self._wallTimeQLE.editingFinished.connect(self._updateWallTimeTooltip)
         self._pythonVenv.editingFinished.connect(self._configurationChanged)
         self._modulesQLE.editingFinished.connect(self._configurationChanged)
         self._preProcessingButtonGroup.buttonClicked.connect(self._configurationChanged)
@@ -388,10 +428,44 @@ class SlurmSettingsWidget(qt.QWidget):
         self._preProcessingButtonGroup.buttonClicked.connect(
             self._preProcessingModeChanged
         )
-        self._queue.currentTextChanged.connect(self._partitionChanged)
-        self._nGpu.valueChanged.connect(self._nGpuChanged)
+        self._queueCB.currentTextChanged.connect(self._partitionChanged)
+        self._nGpuSB.valueChanged.connect(self._nGpuChanged)
         self._gpuCardCB.currentTextChanged.connect(self._configurationChanged)
         self._exportValueCM.currentIndexChanged.connect(self._configurationChanged)
+        self._exportValueCM.currentIndexChanged.connect(
+            self._sbatchAdvancedSettingsChanged
+        )
+
+    def _updateWallTimeWarnings(self):
+        time_limit, _ = self._getPartitionWallTime(partition=self.getQueue())
+        palette = self._wallTimeQLE.palette()
+        wall_time_limit_exceed = time_limit is not None and _WallTime(
+            self.getWallTime()
+        ) > _WallTime(time_limit)
+        if wall_time_limit_exceed:
+            palette.setColor(self.backgroundRole(), self.WALL_TIME_INVALID_COLOR)
+        else:
+            palette.setColor(
+                self.backgroundRole(), self.__defaultWallTimeBackgroundColor
+            )
+        self._warningWallTime.setVisible(wall_time_limit_exceed)
+        self._wallTimeQLE.setPalette(palette)
+
+    def _updateWallTimeTooltip(self):
+        partition = self.getQueue()
+        time_limit, default_wall_time = self._getPartitionWallTime(partition=partition)
+        if time_limit is not None and default_wall_time is not None:
+            tooltip = "\n".join(
+                (
+                    f"for partition {partition}:",
+                    f"time limit: {time_limit}",
+                    f"default limit: {default_wall_time}",
+                )
+            )
+        else:
+            tooltip = f"no wall time found for {partition}"
+        self._wallTimeQLE.setToolTip(tooltip)
+        self._warningWallTime.setToolTip(tooltip)
 
     def _nGpuChanged(self, *args, **kwargs):
         nGpu = self.getNGPU()
@@ -401,34 +475,34 @@ class SlurmSettingsWidget(qt.QWidget):
         self.sigConfigChanged.emit()
 
     def getNCores(self) -> int:
-        return self._nCores.value()
+        return self._nCoresSB.value()
 
     def setNCores(self, n: int) -> None:
-        self._nCores.setValue(int(n))
+        self._nCoresSB.setValue(int(n))
 
     def getNWorkers(self) -> int:
-        return self._nWorkers.value()
+        return self._nWorkersSP.value()
 
     def setNWorkers(self, n) -> None:
-        self._nWorkers.setValue(int(n))
+        self._nWorkersSP.setValue(int(n))
 
     def getMemory(self) -> int:
-        return self._memory.value()
+        return self._memorySB.value()
 
     def setMemory(self, memory: int) -> None:
-        self._memory.setValue(int(memory))
+        self._memorySB.setValue(int(memory))
 
     def getQueue(self) -> str:
-        return self._queue.currentText()
+        return self._queueCB.currentText()
 
     def setQueue(self, text: str) -> None:
-        self._queue.setCurrentText(text)
+        self._queueCB.setCurrentText(text)
 
     def getNGPU(self) -> int:
-        return self._nGpu.value()
+        return self._nGpuSB.value()
 
     def setNGPU(self, n: int) -> None:
-        self._nGpu.setValue(int(n))
+        self._nGpuSB.setValue(int(n))
 
     def getNJobs(self) -> int:
         return self._nJobs.value()
@@ -442,6 +516,31 @@ class SlurmSettingsWidget(qt.QWidget):
     def setProjectName(self, name):
         self._jobName.setText(name)
 
+    def getWallTime(self):
+        parts = self._wallTimeQLE.text().split(":")
+        hours = parts[0]
+        if len(parts) > 1:
+            minutes = parts[1]
+        else:
+            minutes = ""
+        if len(parts) > 2:
+            seconds = parts[2]
+        else:
+            seconds = ""
+
+        return ":".join(
+            [
+                hours.zfill(2),
+                minutes.zfill(2),
+                seconds.zfill(2),
+            ]
+        )
+
+    def setWallTime(self, walltime):
+        self._wallTimeQLE.setText(walltime)
+        self._updateWallTimeWarnings()
+        self._updateWallTimeTooltip()
+
     def getPythonExe(self):
         if self._sourceScriptCB.isChecked():
             return self._pythonVenv.text()
@@ -468,9 +567,9 @@ class SlurmSettingsWidget(qt.QWidget):
         if len(modules) > 0:
             self._modulesCB.setChecked(True)
 
-    def getGpuCard(self) -> Optional[str]:
+    def getGpuCard(self) -> str | None:
         card = self._gpuCardCB.currentText()
-        if card == "any" or self._nGpu == 0:
+        if card == "any" or self._nGpuSB == 0:
             return None
         else:
             return card
@@ -532,6 +631,10 @@ class SlurmSettingsWidget(qt.QWidget):
             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('"')
@@ -562,6 +665,7 @@ class SlurmSettingsWidget(qt.QWidget):
             "partition": self.getQueue(),
             "n_gpus": self.getNGPU(),
             "job_name": self.getProjectName(),
+            "walltime": self.getWallTime(),
             "sbatch_extra_params": self.getSBatchExtraParams(),
         }
         if self._modulesCB.isChecked():
@@ -569,7 +673,7 @@ class SlurmSettingsWidget(qt.QWidget):
         elif self._sourceScriptCB.isChecked():
             config["python_venv"] = self.getPythonExe()
         else:
-            raise ValueError("'modules' or python environement should be enable")
+            raise ValueError("'modules' or python environment should be enable")
         return config
 
     def getSlurmClusterConfiguration(self):
@@ -583,14 +687,29 @@ class SlurmSettingsWidget(qt.QWidget):
 
     def setConfigurationLevel(self, level: ConfigurationLevel):
         self._sbatchAdvancedParameters.setVisible(level >= ConfigurationLevel.ADVANCED)
+        self._wallTimeLabel.setVisible(level >= ConfigurationLevel.ADVANCED)
+        self._wallTimeQLE.setVisible(level >= ConfigurationLevel.ADVANCED)
 
     def _partitionChanged(self, *args, **kwargs):
         partition = self.getQueue()
+        # op(erator) accounts (from icc computers) cannot export to p9. they don't have home directories
+        self._warning_opd_p9.setVisible(
+            current_login_is_op_account() and partition.lower().startswith("p9")
+        )
         gpus = self._getGpus(partition=partition)
         self._gpuCardCB.clear()
         self._gpuCardCB.addItems(gpus)
         self._gpuCardCB.setCurrentText("any")
 
+    def _sbatchAdvancedSettingsChanged(self, *args, **kwargs):
+        # op(erator) accounts (from icc computers) must export ALL environment variable. Else job fails
+        # warning: we want to display the warning no matter if we are in 'advance options' or not.
+        # this way the user always see the warning when necessary
+        self._warning_opd_export_opts.setVisible(
+            current_login_is_op_account()
+            and self._exportValueCM.currentText() == "NONE"
+        )
+
     @cache(maxsize=None)
     def _getGpus(self, partition) -> tuple:
         try:
@@ -604,6 +723,15 @@ class SlurmSettingsWidget(qt.QWidget):
             ]
             return gpus
 
+    @cache(maxsize=None)
+    def _getPartitionWallTime(self, partition: str) -> tuple[str | None, str | None]:
+        try:
+            times = get_partition_walltime(partition=partition)
+        except Exception:
+            return None, None
+        else:
+            return times["time"], times["default_time"]
+
 
 class _PortRangeSelection(qt.QWidget):
     sigRangeChanged = qt.Signal()
@@ -647,8 +775,82 @@ class _PortRangeSelection(qt.QWidget):
             self._stepQSpinBox.value(),
         )
 
-    def setRange(self, min_: int, max_: int, step: Optional[int] = None) -> None:
+    def setRange(self, min_: int, max_: int, step: int | None = None) -> None:
         self._fromQSpinBox.setValue(min(min_, max_))
         self._toQSpinBox.setValue(max(min_, max_))
         if step is not None:
             self._stepQSpinBox.setValue(step)
+
+
+def get_login() -> str | None:
+    try:
+        return os.getlogin()
+    except OSError:
+        """In CI computer this raises the following error
+        OSError: [Errno 6] No such device or address
+        """
+        return None
+
+
+def current_login_is_op_account() -> bool:
+    """
+    return True if the current login is a op[i]dXX login.
+    """
+    return is_op_account(get_login())
+
+
+def is_op_account(user: str | None) -> bool:
+    """
+    Determines if a given username follows the 'op' account format,
+    specifically 'opdXX' or 'opidXX', where 'XX' are numeric digits.
+
+    Args:
+        user (Optional[str]): The username to check.
+
+    Returns:
+        bool: True if the username matches the pattern, False otherwise.
+    """
+
+    if user is None:
+        return False
+
+    op_account_pattern = r"^opi?d\d{2}$"
+    return bool(re.match(op_account_pattern, user))
+
+
+class _WallTime:
+    """Util class to compare two walltime provided as D-HH:MM:SS or as HH:MM:SS"""
+
+    def __init__(self, walltime: str):
+        parts = walltime.split("-")
+        if len(parts) > 1:
+            assert len(parts) == 2, f"unexpected walltime format ({walltime})"
+            days = int(parts[0])
+        else:
+            days = 0
+
+        def minutes_to_seconds(value):
+            return value * 60
+
+        def hours_to_seconds(value):
+            return minutes_to_seconds(value * 60)
+
+        def days_to_seconds(value):
+            return hours_to_seconds(value * 24)
+
+        hours, minutes, seconds = map(int, parts[-1].split(":"))
+        self.value = (
+            seconds
+            + minutes_to_seconds(minutes)
+            + hours_to_seconds(hours)
+            + days_to_seconds(days)
+        )
+
+    def __lt__(self, other):
+        return self.value < other.value
+
+    def __gt__(self, other):
+        return self.value > other.value
+
+    def __eq__(self, other):
+        return self.value == other.value

tomwer/gui/cluster/supervisor.py

@@ -1,31 +1,5 @@
 # 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__ = "14/10/2021"
+from __future__ import annotations
 
 
 import functools