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

orangecontrib/tomwer/widgets/reconstruction/DarkRefAndCopyOW.py

@@ -152,6 +152,7 @@ class DarkRefAndCopyOW(SuperviseOW, WidgetLongProcessing):
         self.widget.recons_params.sigChanged.connect(self._updateSettingsVals)
         self.widget.sigModeAutoChanged.connect(self._updateSettingsVals)
         self.widget.sigCopyActivationChanged.connect(self._updateSettingsVals)
+        self.widget.sigClearCache.connect(self._processing_stack.clear_cache)
         self._processing_stack.sigComputationStarted.connect(self._startProcessing)
         self._processing_stack.sigComputationEnded.connect(self._endProcessing)
         self._processing_stack.sigRefSetted.connect(self.widget.setRefSetBy)

orangecontrib/tomwer/widgets/reconstruction/NabuHelicalPrepareWeightsDoubleOW.py

@@ -1,184 +1,184 @@
-import logging
-
-from orangewidget import gui
-from orangewidget.settings import Setting
-from orangewidget.widget import Input, Output
-from orangecontrib.tomwer.orange.managedprocess import TomwerWithStackStack
-from silx.gui import qt
-from typing import Optional
-
-from tomwer.core.futureobject import FutureTomwerObject
-from tomwer.core.scan.scanbase import TomwerScanBase
-from tomwer.gui.reconstruction.nabu.helical import HelicalPrepareWeightsDouble
-from tomwer.core.process.reconstruction.nabu.helical import (
-    NabuHelicalPrepareWeightsDouble,
-)
-from tomwer.core.scan.nxtomoscan import NXtomoScan
-
-_logger = logging.getLogger(__name__)
-
-
-class NabuHelicalPrepareWeightsDoubleOW(
-    TomwerWithStackStack,
-    ewokstaskclass=NabuHelicalPrepareWeightsDouble,
-):
-    """
-    widget used to call the `nabu-helical-prepare-weights-double` application on a dedicated thread. It define weights map and double flat field.
-
-    :param parent: the parent widget
-    """
-
-    # note of this widget should be the one registered on the documentation
-    name = "helical prerate weights double"
-    id = "orangecontrib.tomwer.widgets.reconstruction.NabuHelicalPrepareWeightsDoubleOW.NabuHelicalPrepareWeightsDoubleOW"
-    description = "compute map of weights requested for nabu helical reconstruction"
-    icon = "icons/nabu_prepare_weights_double.svg"
-    priority = 199
-    keywords = [
-        "tomography",
-        "nabu",
-        "reconstruction",
-        "nabu-helical",
-        "helical",
-        "weights",
-        "prepare",
-    ]
-
-    want_main_area = True
-    want_control_area = False
-    resizing_enabled = True
-
-    _ewoks_default_inputs = Setting(
-        {
-            "data": None,
-            "transition_width_vertical": 50,
-            "transition_width_horizontal": 50,
-            "processes_file": "",
-            "rotation_axis_position": 0,
-        }
-    )
-
-    _ewoks_inputs_to_hide_from_orange = (
-        "progress",
-        "processes_file",
-        "transition_width_vertical",
-        "transition_width_horizontal",
-        "rotation_axis_position",
-    )
-
-    sigScanReady = qt.Signal(TomwerScanBase)
-    "Signal emitted when a scan is ended"
-
-    TIMEOUT = 30
-
-    class Inputs:
-        data = Input(
-            name="data",
-            type=TomwerScanBase,
-            doc="one scan to be process",
-            default=True,
-            multiple=False,
-        )
-
-    class Outputs:
-        data = Output(name="data", type=TomwerScanBase, doc="one scan to be process")
-        future_tomo_obj = Output(
-            name="future_tomo_obj",
-            type=FutureTomwerObject,
-            doc="future object (process remotely)",
-        )
-
-    LOGGER = _logger
-
-    def __init__(self, parent=None):
-        super().__init__(parent)
-        self.__scan = None
-
-        # gui definition
-        _layout = gui.vBox(self.mainArea, self.name).layout()
-        self.widget = HelicalPrepareWeightsDouble(parent=self)
-        _layout.addWidget(self.widget)
-
-        ## connect signal / slot
-        self.widget.sigConfigChanged.connect(self._updateSettings)
-
-        if isinstance(self.task_output_changed_callbacks, set):
-            self.task_output_changed_callbacks.add(self._notify_state)
-        elif isinstance(self.task_output_changed_callbacks, list):
-            self.task_output_changed_callbacks.append(self._notify_state)
-        else:
-            raise NotImplementedError
-
-        ## handle settings
-        self._loadSettings()
-        self.task_executor_queue.sigComputationStarted.connect(self._newTaskStarted)
-
-    def _updateSettings(self):
-        config = self.widget.getConfiguration()
-        for key in ("transition_width", "processes_file"):
-            self._ewoks_default_inputs[key] = config[key]  # pylint: disable=E1137
-
-    @property
-    def request_input(self):
-        return self.__request_input
-
-    @request_input.setter
-    def request_input(self, request):
-        self.__request_input = request
-
-    def get_task_inputs(self):
-        assert self.__scan is not None
-        return {
-            "data": self.__scan,
-            "transition_width": self.widget.getConfiguration()["transition_width"],
-            "processes_file": self.widget.getConfiguration()["processes_file"],
-        }
-
-    def handleNewSignals(self) -> None:
-        """Invoked by the workflow signal propagation manager after all
-        signals handlers have been called.
-        """
-        # for now we want to avoid propagation any processing.
-        # task will be executed only when the user validates the dialog
-        data = super().get_task_inputs().get("data", None)
-        if data is not None:
-            if not isinstance(data, NXtomoScan):
-                raise TypeError(
-                    f"data is expected to be an instance of NXtomoScan. {type(data)} are not handled"
-                )
-            self.add(data.path)
-
-    def _loadSettings(self):
-        self.widget.setConfiguration(self._ewoks_default_inputs)
-
-    def _newTaskStarted(self):
-        try:
-            task_executor = self.sender()
-            scan = task_executor.current_task.inputs.data
-            self.notify_on_going(scan)
-        except Exception:
-            pass
-
-    def _notify_state(self):
-        try:
-            task_executor = self.sender()
-            task_suceeded = task_executor.succeeded
-            scan = task_executor.current_task.outputs.data
-            if task_suceeded:
-                self.notify_succeed(scan=scan)
-            else:
-                self.notify_failed(scan=scan)
-        except Exception as e:
-            _logger.error(f"failed to handle task finished callback. Raiseon is {e}")
-
-    @Inputs.data
-    def process_data(self, scan: Optional[TomwerScanBase]):
-        if scan is None:
-            return
-        else:
-            self.__scan = scan
-            self.notify_pending(scan=scan)
-            self.execute_ewoks_task()
-
-    def sizeHint(self) -> qt.QSize:
-        return qt.QSize(650, 60)
+# import logging
+
+# from orangewidget import gui
+# from orangewidget.settings import Setting
+# from orangewidget.widget import Input, Output
+# from orangecontrib.tomwer.orange.managedprocess import TomwerWithStackStack
+# from silx.gui import qt
+# from typing import Optional
+
+# from tomwer.core.futureobject import FutureTomwerObject
+# from tomwer.core.scan.scanbase import TomwerScanBase
+# from tomwer.gui.reconstruction.nabu.helical import HelicalPrepareWeightsDouble
+# from tomwer.core.process.reconstruction.nabu.helical import (
+#     NabuHelicalPrepareWeightsDouble,
+# )
+# from tomwer.core.scan.nxtomoscan import NXtomoScan
+
+# _logger = logging.getLogger(__name__)
+
+
+# class NabuHelicalPrepareWeightsDoubleOW(
+#     TomwerWithStackStack,
+#     ewokstaskclass=NabuHelicalPrepareWeightsDouble,
+# ):
+#     """
+#     widget used to call the `nabu-helical-prepare-weights-double` application on a dedicated thread. It define weights map and double flat field.
+
+#     :param parent: the parent widget
+#     """
+
+#     # note of this widget should be the one registered on the documentation
+#     name = "helical prerate weights double"
+#     id = "orangecontrib.tomwer.widgets.reconstruction.NabuHelicalPrepareWeightsDoubleOW.NabuHelicalPrepareWeightsDoubleOW"
+#     description = "compute map of weights requested for nabu helical reconstruction"
+#     icon = "icons/nabu_prepare_weights_double.svg"
+#     priority = 199
+#     keywords = [
+#         "tomography",
+#         "nabu",
+#         "reconstruction",
+#         "nabu-helical",
+#         "helical",
+#         "weights",
+#         "prepare",
+#     ]
+
+#     want_main_area = True
+#     want_control_area = False
+#     resizing_enabled = True
+
+#     _ewoks_default_inputs = Setting(
+#         {
+#             "data": None,
+#             "transition_width_vertical": 50,
+#             "transition_width_horizontal": 50,
+#             "processes_file": "",
+#             "rotation_axis_position": 0,
+#         }
+#     )
+
+#     _ewoks_inputs_to_hide_from_orange = (
+#         "progress",
+#         "processes_file",
+#         "transition_width_vertical",
+#         "transition_width_horizontal",
+#         "rotation_axis_position",
+#     )
+
+#     sigScanReady = qt.Signal(TomwerScanBase)
+#     "Signal emitted when a scan is ended"
+
+#     TIMEOUT = 30
+
+#     class Inputs:
+#         data = Input(
+#             name="data",
+#             type=TomwerScanBase,
+#             doc="one scan to be process",
+#             default=True,
+#             multiple=False,
+#         )
+
+#     class Outputs:
+#         data = Output(name="data", type=TomwerScanBase, doc="one scan to be process")
+#         future_tomo_obj = Output(
+#             name="future_tomo_obj",
+#             type=FutureTomwerObject,
+#             doc="future object (process remotely)",
+#         )
+
+#     LOGGER = _logger
+
+#     def __init__(self, parent=None):
+#         super().__init__(parent)
+#         self.__scan = None
+
+#         # gui definition
+#         _layout = gui.vBox(self.mainArea, self.name).layout()
+#         self.widget = HelicalPrepareWeightsDouble(parent=self)
+#         _layout.addWidget(self.widget)
+
+#         ## connect signal / slot
+#         self.widget.sigConfigChanged.connect(self._updateSettings)
+
+#         if isinstance(self.task_output_changed_callbacks, set):
+#             self.task_output_changed_callbacks.add(self._notify_state)
+#         elif isinstance(self.task_output_changed_callbacks, list):
+#             self.task_output_changed_callbacks.append(self._notify_state)
+#         else:
+#             raise NotImplementedError
+
+#         ## handle settings
+#         self._loadSettings()
+#         self.task_executor_queue.sigComputationStarted.connect(self._newTaskStarted)
+
+#     def _updateSettings(self):
+#         config = self.widget.getConfiguration()
+#         for key in ("transition_width", "processes_file"):
+#             self._ewoks_default_inputs[key] = config[key]  # pylint: disable=E1137
+
+#     @property
+#     def request_input(self):
+#         return self.__request_input
+
+#     @request_input.setter
+#     def request_input(self, request):
+#         self.__request_input = request
+
+#     def get_task_inputs(self):
+#         assert self.__scan is not None
+#         return {
+#             "data": self.__scan,
+#             "transition_width": self.widget.getConfiguration()["transition_width"],
+#             "processes_file": self.widget.getConfiguration()["processes_file"],
+#         }
+
+#     def handleNewSignals(self) -> None:
+#         """Invoked by the workflow signal propagation manager after all
+#         signals handlers have been called.
+#         """
+#         # for now we want to avoid propagation any processing.
+#         # task will be executed only when the user validates the dialog
+#         data = super().get_task_inputs().get("data", None)
+#         if data is not None:
+#             if not isinstance(data, NXtomoScan):
+#                 raise TypeError(
+#                     f"data is expected to be an instance of NXtomoScan. {type(data)} are not handled"
+#                 )
+#             self.add(data.path)
+
+#     def _loadSettings(self):
+#         self.widget.setConfiguration(self._ewoks_default_inputs)
+
+#     def _newTaskStarted(self):
+#         try:
+#             task_executor = self.sender()
+#             scan = task_executor.current_task.inputs.data
+#             self.notify_on_going(scan)
+#         except Exception:
+#             pass
+
+#     def _notify_state(self):
+#         try:
+#             task_executor = self.sender()
+#             task_suceeded = task_executor.succeeded
+#             scan = task_executor.current_task.outputs.data
+#             if task_suceeded:
+#                 self.notify_succeed(scan=scan)
+#             else:
+#                 self.notify_failed(scan=scan)
+#         except Exception as e:
+#             _logger.error(f"failed to handle task finished callback. Raiseon is {e}")
+
+#     @Inputs.data
+#     def process_data(self, scan: Optional[TomwerScanBase]):
+#         if scan is None:
+#             return
+#         else:
+#             self.__scan = scan
+#             self.notify_pending(scan=scan)
+#             self.execute_ewoks_task()
+
+#     def sizeHint(self) -> qt.QSize:
+#         return qt.QSize(650, 60)

tomwer/app/canvas_launcher/mainwindow.py

@@ -281,7 +281,6 @@ class _OMain(ocMain):
         signal.signal(signal.SIGINT, signal.SIG_DFL)
         # Disable pyqtgraph's atexit and QApplication.aboutToQuit cleanup handlers.
         pyqtgraph.setConfigOption("exitCleanup", False)
-        print("argv are", argv)
         super().run(argv)
 
     def argument_parser(self) -> argparse.ArgumentParser:

tomwer/app/zstitching.py

@@ -56,7 +56,6 @@ class MainWidget(qt.QTabWidget):
                 "partition": settingsClass.PARTITION,
                 "n_gpus": settingsClass.N_GPUS_PER_WORKER,
                 "job_name": settingsClass.PROJECT_NAME,
-                "walltime": settingsClass.DEFAULT_WALLTIME,
                 "python_venv": settingsClass.PYTHON_VENV,
             }
         )

tomwer/core/cluster/cluster.py

@@ -48,7 +48,6 @@ class SlurmClusterConfiguration:
         queue=_SlurmSettings.PARTITION,
         n_gpus=_SlurmSettings.N_GPUS_PER_WORKER,
         project_name=_SlurmSettings.PROJECT_NAME,
-        walltime=_SlurmSettings.DEFAULT_WALLTIME,
         python_venv=_SlurmSettings.PYTHON_VENV,
         n_jobs=_SlurmSettings.N_JOBS,
         modules_to_load: tuple = _SlurmSettings.MODULES_TO_LOAD,
@@ -60,7 +59,6 @@ class SlurmClusterConfiguration:
         self._queue = queue
         self._n_gpus = n_gpus
         self._project_name = project_name
-        self._walltime = walltime
         self._python_venv = python_venv
         self._modules_to_load = modules_to_load
         self._n_jobs = n_jobs
@@ -98,10 +96,6 @@ class SlurmClusterConfiguration:
     def project_name(self):
         return self._project_name
 
-    @property
-    def walltime(self):
-        return self._walltime
-
     @property
     def python_venv(self):
         return self._python_venv
@@ -132,7 +126,6 @@ class SlurmClusterConfiguration:
             "partition": self.queue,
             "n_gpus": self.n_gpus,
             "job_name": self.project_name,
-            "walltime": self.walltime,
             "python_venv": self.python_venv,
             "modules": self.modules_to_load,
             "sbatch_extra_params": self.sbatch_extra_params,
@@ -157,8 +150,6 @@ class SlurmClusterConfiguration:
             self._n_gpus = dict_["n_gpus"]
         if "job_name" in dict_:
             self._project_name = dict_["job_name"]
-        if "walltime" in dict_:
-            self._walltime = dict_["walltime"]
         if "python_venv" in dict_:
             self._python_venv = dict_["python_venv"]
         modules = dict_.get("modules", None)

tomwer/core/process/control/datalistener/datalistener.py

@@ -60,7 +60,10 @@ try:
 except ImportError:
     from nxtomomill.converter.hdf5.acquisition.baseacquisition import BaseAcquisition
 
-    _SCAN_NUMBER_PATH = BaseAcquisition._SCAN_NUMBER_PATH
+    try:
+        _SCAN_NUMBER_PATH = BaseAcquisition._SCAN_NUMBER_PATH
+    except ImportError:
+        _SCAN_NUMBER_PATH = None
 
 _logger = logging.getLogger(__name__)
 

tomwer/core/process/reconstruction/axis/params.py

@@ -62,10 +62,10 @@ _WITH_PAG = "withpag"
 _NO_PAG = "nopag"
 
 
-DEFAULT_CMP_THETA = 10
-DEFAULT_CMP_N_SUBSAMPLING_Y = 10
+DEFAULT_CMP_THETA = 5
+DEFAULT_CMP_N_SUBSAMPLING_Y = 40
 DEFAULT_CMP_NEAR_POS = 0
-DEFAULT_CMP_NEAR_WIDTH = 20
+DEFAULT_CMP_NEAR_WIDTH = 40
 DEFAULT_CMP_OVERSAMPLING = 4
 DEFAULT_CMP_TAKE_LOG = True
 

tomwer/core/process/reconstruction/darkref/darkrefscopy.py

@@ -34,6 +34,7 @@ __date__ = "17/08/2021"
 
 import logging
 import os
+import h5py
 import tempfile
 from typing import Union
 
@@ -198,10 +199,37 @@ class DarkRefsCopy(DarkRefsTask):
             update_mode="replace",
         )
 
+    def clear_cache(self):
+        """
+        remove the file used to cache the reduced darks / flats.
+        This can be used in the case it contain unrelevant data. Like frame with another shape...
+        """
+        cache_file = DarkRefsCopy.get_save_file(self._savedir)
+        if os.path.exists(cache_file):
+            os.remove(cache_file)
+
+    def _clear_cache_data_path(self, file_path: str, data_path: str):
+        if not os.path.exists(file_path):
+            return
+        with h5py.File(file_path, mode="a") as h5f:
+            if data_path in h5f:
+                del h5f[data_path]
+
     def set_darks_and_flats_from_scan(self, scan: TomwerScanBase) -> bool:
-        if scan.reduced_flats in (None, {}):
+        has_flats = scan.reduced_flats not in (None, {})
+        has_darks = scan.reduced_darks not in (None, {})
+        if has_flats and has_darks:
+            # if the scan has darks and flats remove directly the cache file
+            # else in append mode HDF5 is not removing the dataset and
+            # the cache size will continue to increase
+            self.clear_cache()
+        if not has_flats:
             logger.warning(f"No flat found for {scan}. Unable to copy them")
         else:
+            self._clear_cache_data_path(
+                file_path=self._flats_url.file_path(),
+                data_path=self._flats_url.data_path(),
+            )
             dicttoh5(
                 scan.reduced_flats,
                 h5file=self._flats_url.file_path(),
@@ -209,9 +237,13 @@ class DarkRefsCopy(DarkRefsTask):
                 mode="a",
                 update_mode="replace",
             )
-        if scan.reduced_darks in (None, {}):
+        if not has_darks:
             logger.warning(f"No dark found for {scan}. Unable to copy them")
         else:
+            self._clear_cache_data_path(
+                file_path=self._darks_url.file_path(),
+                data_path=self._darks_url.data_path(),
+            )
             dicttoh5(
                 scan.reduced_darks,
                 h5file=self._darks_url.file_path(),
@@ -247,10 +279,6 @@ class DarkRefsCopy(DarkRefsTask):
                 overwrite=True,
             )
 
-    def clean_save_files(self):
-        if os.path.exists(self._save_file):
-            os.remove(self._save_file)
-
     def run(self):
         """
         This is function triggered when a new scan / data is received.

tomwer/core/process/reconstruction/nabu/utils.py

@@ -128,7 +128,6 @@ def get_nabu_resources_desc(scan: TomwerScanBase, method, workers=1) -> dict:
         "partition": "gpu",
         "memory_per_node": "90%",
         "threads_per_node": "100%",
-        "walltime": "01:00:00",
     }
     return res
 
@@ -305,7 +304,7 @@ def get_multi_cor_recons_volume_identifiers(
 class _NabuMode(_Enum):
     FULL_FIELD = "standard acquisition"
     HALF_ACQ = "half acquisition"
-    HELICAL = "helical acquisition"
+    # HELICAL = "helical acquisition"
 
 
 class _NabuStages(_Enum):
@@ -467,6 +466,9 @@ def nabu_std_err_has_error(errs: typing.Optional[bytes]):
             in line  # debatable but very disturbing from the gui side... anyway EDF days are coming to an end
             or "PerformanceWarning" in line
             or "jitify._init_module()" in line
+            or " unable to import 'siphash24.siphash13" in line
+            or "_create_built_program_from_source_cached" in line
+            or "prg.build(options_bytes," in line
         )
 
     if errs is None:

tomwer/core/utils/scanutils.py

@@ -40,7 +40,11 @@ from silx.io.utils import h5py_read_dataset
 from tomoscan.esrf.scan.mock import MockEDF as _MockEDF
 from tomoscan.esrf.scan.mock import MockNXtomo as _MockNXtomo
 from tomoscan.io import HDF5File
-from tomoscan.test.utils import MockContext
+
+try:
+    from tomoscan.test.utils import MockContext
+except ImportError:
+    from tomoscan.tests.utils import MockContext
 
 from tomwer.core.scan.blissscan import BlissScan
 from tomwer.core.scan.nxtomoscan import NXtomoScan

tomwer/gui/cluster/slurm.py

@@ -166,7 +166,6 @@ 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,
                     }
@@ -261,11 +260,6 @@ class SlurmSettingsWidget(qt.QWidget):
         self._nJobsLabel.setVisible(jobLimitation is None)
         self._nJobs.setVisible(jobLimitation is None)
 
-        # wall time
-        self._wallTimeQLE = qt.QLineEdit("", self)
-        self._wallTimeLabel = qt.QLabel("wall time", self)
-        self.layout().addRow(self._wallTimeLabel, self._wallTimeQLE)
-
         # python exe / modules
         self._preProcessingGroup = qt.QGroupBox("pre-processing", self)
         self._preProcessingGroup.setLayout(qt.QFormLayout())
@@ -356,8 +350,6 @@ class SlurmSettingsWidget(qt.QWidget):
         self._sbatchAdvancedParameters.layout().addRow("-C (gpu card)", self._gpuCardCB)
 
         # simplify gui
-        self._wallTimeLabel.hide()
-        self._wallTimeQLE.hide()
         self._dashboardPort.hide()
         self._dashboardPortLabel.hide()
         self._jobName.hide()
@@ -376,7 +368,6 @@ class SlurmSettingsWidget(qt.QWidget):
             self._queue.setCurrentText(SlurmSettings.PARTITION)
         self._nGpu.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._preProcessingModeChanged()
         self._partitionChanged()
@@ -389,7 +380,6 @@ class SlurmSettingsWidget(qt.QWidget):
         self._queue.currentTextChanged.connect(self._configurationChanged)
         self._nGpu.valueChanged.connect(self._configurationChanged)
         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)
@@ -401,6 +391,7 @@ class SlurmSettingsWidget(qt.QWidget):
         self._queue.currentTextChanged.connect(self._partitionChanged)
         self._nGpu.valueChanged.connect(self._nGpuChanged)
         self._gpuCardCB.currentTextChanged.connect(self._configurationChanged)
+        self._exportValueCM.currentIndexChanged.connect(self._configurationChanged)
 
     def _nGpuChanged(self, *args, **kwargs):
         nGpu = self.getNGPU()
@@ -451,12 +442,6 @@ class SlurmSettingsWidget(qt.QWidget):
     def setProjectName(self, name):
         self._jobName.setText(name)
 
-    def getWallTime(self):
-        return self._wallTimeQLE.text()
-
-    def setWallTime(self, walltime):
-        self._wallTimeQLE.setText(walltime)
-
     def getPythonExe(self):
         if self._sourceScriptCB.isChecked():
             return self._pythonVenv.text()
@@ -547,10 +532,6 @@ 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('"')
@@ -581,7 +562,6 @@ 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():