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

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

@@ -34,11 +34,13 @@ __date__ = "17/08/2021"
 
 import logging
 import os
+import h5py
 import tempfile
 from typing import Union
 
 from silx.io.dictdump import dicttoh5, h5todict
 from silx.io.url import DataUrl
+from silx.io.utils import open as open_hdf5
 from tomoscan.esrf.scan.utils import (
     copy_h5_dict_darks_to,
     copy_h5_dict_flats_to,
@@ -197,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(),
@@ -208,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(),
@@ -246,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.
@@ -297,7 +326,7 @@ class DarkRefsCopy(DarkRefsTask):
         if not os.path.exists(self._save_file):
             return False
         else:
-            with HDF5File(self._save_file, mode="r") as h5f:
+            with open_hdf5(self._save_file) as h5f:
                 return self._flats_url.data_path() in h5f
 
     def has_dark_stored(self) -> bool:
@@ -309,7 +338,7 @@ class DarkRefsCopy(DarkRefsTask):
         if not os.path.exists(self._save_file):
             return False
         else:
-            with HDF5File(self._save_file, mode="r") as h5f:
+            with open_hdf5(self._save_file) as h5f:
                 return self._darks_url.data_path() in h5f
 
     def contains_dark(self, scan: TomwerScanBase) -> bool:

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

@@ -43,9 +43,10 @@ import sys
 
 import numpy
 from silx.io.url import DataUrl
+from silx.io.utils import open as open_hdf5
 from sluurp.executor import submit as submit_to_slurm_cluster
 from sluurp.job import SBatchScriptJob
-from tomoscan.io import HDF5File, get_swmr_mode
+from tomoscan.io import HDF5File
 from tomoscan.normalization import Method as INormMethod
 from tomoscan.identifier import VolumeIdentifier
 
@@ -581,9 +582,7 @@ class _NabuBaseReconstructor:
                     # if an url exists insure we can access it
                     dataset_url = DataUrl(path=dataset_url)
                     if os.path.exists(dataset_url.file_path()):
-                        with HDF5File(
-                            dataset_url.file_path(), mode="r", swmr=get_swmr_mode()
-                        ) as h5f:
+                        with open_hdf5(dataset_url.file_path()) as h5f:
                             if dataset_url.data_path() not in h5f:
                                 dataset_url = None
                     else:

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

@@ -211,6 +211,7 @@ def run_nabu_multicor(
         recons_urls = {}
         std_outs = []
         std_errs = []
+        future_tomo_obj = None
 
         success = result.success
         if isinstance(result, ResultsWithStd):

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

@@ -35,6 +35,7 @@ import os
 import gc
 from tomwer.io.utils import format_stderr_stdout
 from silx.utils.deprecation import deprecated, deprecated_warning
+from silx.io.utils import open as open_hdf5
 
 from processview.core.manager.manager import ProcessManager, DatasetState
 
@@ -84,7 +85,6 @@ from processview.core.superviseprocess import SuperviseProcess
 from silx.io.dictdump import h5todict
 from silx.io.utils import h5py_read_dataset
 from silx.utils.enum import Enum as _Enum
-from tomoscan.io import HDF5File, get_swmr_mode
 
 from tomwer.core.process.task import Task
 from tomwer.core.scan.edfscan import EDFTomoScan
@@ -173,14 +173,6 @@ def run_slices_reconstruction(
 
     # handle special cases like several db...
     nabu_configurations = interpret_tomwer_configuration(config, scan=scan)
-    if "phase" in config and "delta_beta" in config["phase"]:
-        db_list = utils.retrieve_lst_of_value_from_str(
-            config["phase"]["delta_beta"], type_=float
-        )
-    else:
-        db_list = ()
-    ask_sinogram_registration = len(db_list) > 0
-    ask_sinogram_load = False
     output_urls = []
     stderrs = []
     stdouts = []
@@ -199,8 +191,6 @@ def run_slices_reconstruction(
             scan=scan,
             slice_index=slice_index,
             dry_run=dry_run,
-            ask_sinogram_registration=ask_sinogram_registration,
-            ask_sinogram_load=ask_sinogram_load,
             instanciate_class_only=instanciate_classes_only,
             axis=config.get("reconstruction", {}).get("slice_plane", "XY"),
         )
@@ -238,9 +228,6 @@ def run_slices_reconstruction(
             final_configs.append(result.config)
             all_succeed = all_succeed and result.success
 
-        if ask_sinogram_registration:
-            ask_sinogram_load = True
-            ask_sinogram_registration = False
         if advancement is not None:
             advancement.increaseAdvancement(1)
 
@@ -494,7 +481,7 @@ class NabuSlicesTask(
         :rtype:dict
         """
         if entry is None:
-            with HDF5File(process_file, "r", swmr=get_swmr_mode()) as h5f:
+            with open_hdf5(process_file) as h5f:
                 entries = NabuSlicesTask._get_process_nodes(
                     root_node=h5f, process=NabuSlicesTask
                 )
@@ -510,7 +497,7 @@ class NabuSlicesTask(
         configuration_path = None
         res = {}
 
-        with HDF5File(process_file, "r", swmr=get_swmr_mode()) as h5f:
+        with open_hdf5(process_file) as h5f:
             nabu_nodes = NabuSlicesTask._get_process_nodes(
                 root_node=h5f[entry], process=NabuSlicesTask
             )
@@ -640,8 +627,6 @@ class SingleSliceRunner(_NabuBaseReconstructor):
         slice_index: Union[int, str, None],
         axis: NabuPlane,
         target: Target,
-        ask_sinogram_registration: bool,
-        ask_sinogram_load: bool,
         cluster_config: Optional[dict],
         process_name: str,
         add_to_latest_reconstructions: bool = True,
@@ -658,8 +643,6 @@ class SingleSliceRunner(_NabuBaseReconstructor):
         if not isinstance(config, dict):
             raise TypeError(f"config is expected to be a dictionary not {type(dict)}")
         self._config = config
-        self._ask_sinogram_registration = ask_sinogram_registration
-        self._ask_sinogram_load = ask_sinogram_load
         self._add_to_latest_reconstructions = add_to_latest_reconstructions
 
     @property
@@ -670,14 +653,6 @@ class SingleSliceRunner(_NabuBaseReconstructor):
     def config(self):
         return self._config
 
-    @property
-    def ask_sinogram_load(self):
-        return self._ask_sinogram_load
-
-    @property
-    def ask_sinogram_registration(self):
-        return self._ask_sinogram_registration
-
     @property
     def add_to_latest_reconstructions(self):
         return self._add_to_latest_reconstructions
@@ -721,25 +696,8 @@ class SingleSliceRunner(_NabuBaseReconstructor):
         # force overwrite results
         if "output" not in config:
             config["output"] = {}
-        # handle nabu sinogram step
-        if self.scan.process_file is not None:
-            steps_file_basename, _ = os.path.splitext(self.scan.process_file)
-            steps_file_basename = "_".join(
-                ("steps_file_basename", "nabu", "sinogram", "save", "step")
-            )
-            steps_file_basename = steps_file_basename + ".hdf5"
-            steps_file = os.path.join(
-                os.path.dirname(self.scan.process_file), steps_file_basename
-            )
-        else:
-            steps_file = ""
 
         config["output"].update({"overwrite_results": 1})
-        config["pipeline"] = {
-            "save_steps": "sinogram" if self.ask_sinogram_registration else "",
-            "resume_from_step": "sinogram" if self.ask_sinogram_load else "",
-            "steps_file": steps_file,
-        }
 
         config, cfg_folder = self._treateOutputSliceConfig(config)
         # the policy is to save nabu .cfg file at the same location as the
@@ -845,7 +803,7 @@ class SingleSliceRunner(_NabuBaseReconstructor):
             basename, _ = os.path.splitext(scan.master_file)
             basename = os.path.basename(basename)
             try:
-                with HDF5File(scan.master_file, mode="r", swmr=get_swmr_mode()) as h5f:
+                with open_hdf5(scan.master_file) as h5f:
                     if len(h5f.keys()) > 1:
                         # if there is more than one entry in the file append the entry name to the file basename
                         basename = "_".join((basename, scan.entry.lstrip("/")))
@@ -918,8 +876,6 @@ def run_single_slice_reconstruction(
     nabu_config,
     dry_run,
     slice_index: Union[int, str, None],
-    ask_sinogram_registration: bool,
-    ask_sinogram_load: bool,
     process_id: Optional[int] = None,
     cluster_config: Optional[dict] = None,
     add_to_latest_reconstructions=True,
@@ -938,8 +894,6 @@ def run_single_slice_reconstruction(
     :param local:
     :param stdout: file to redirect stdout
     :param stderr: file to redirect stderr
-    :param bool ask_sinogram_registration: should we ask nabu to register sinogram
-    :param bool ask_sinogram_load: should we ask nabu to load sinogram
     :param bool add_to_latest_reconstructions: if true add reconstructed slice to the latest reconstruction.
                                                We wan't to avoid this treatment for saaxis and sadeltebeta for example
     :param bool instanciate_class_only: if we don't want to run the SingleSliceRunner but only return them. Use case: we want to keep a hand on processing and it can be cancelled
@@ -970,8 +924,6 @@ def run_single_slice_reconstruction(
         slice_index=slice_index,
         axis=axis,
         target=target,
-        ask_sinogram_registration=ask_sinogram_registration,
-        ask_sinogram_load=ask_sinogram_load,
         cluster_config=cluster_config,
         add_to_latest_reconstructions=add_to_latest_reconstructions,
         process_name=process_name,
@@ -1010,6 +962,8 @@ class NabuSliceMode(_Enum):
                     n_slice = scan.dim_2 or 2048
                 elif axis in (NabuPlane.YZ, NabuPlane.XZ):
                     n_slice = scan.dim_1 or 2048
+                else:
+                    raise NotImplementedError(f"unknow axis {axis}")
                 res.append(n_slice // 2)
             else:
                 raise ValueError(

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

@@ -43,10 +43,9 @@ from processview.core.manager.manager import ProcessManager, DatasetState
 from processview.core.superviseprocess import SuperviseProcess
 
 from silx.io.utils import h5py_read_dataset
+from silx.io.utils import open as open_hdf5
 from tomwer.core.utils.deprecation import deprecated_warning
 
-from tomoscan.io import HDF5File, get_swmr_mode
-
 from tomwer.core.cluster.cluster import SlurmClusterConfiguration
 from tomwer.core.futureobject import FutureTomwerObject
 from tomwer.core.process.reconstruction.nabu.plane import NabuPlane
@@ -354,9 +353,7 @@ class VolumeRunner(_NabuBaseReconstructor):
             basename = os.path.basename(basename)
             try:
                 # if there is more than one entry in the file append the entry name to the file basename
-                with HDF5File(
-                    self.scan.master_file, mode="r", swmr=get_swmr_mode()
-                ) as h5f:
+                with open_hdf5(self.scan.master_file) as h5f:
                     if len(h5f.keys()) > 1:
                         basename = "_".join((basename, self.scan.entry.strip("/")))
             except Exception:

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
 
@@ -171,6 +170,8 @@ def get_recons_volume_identifier(
             entry = scan.entry
         elif isinstance(scan, EDFTomoScan):
             entry = "entry"
+        else:
+            raise NotImplementedError(f"unrecognized scan type ({type(scan)})")
 
         volumes = (
             HDF5Volume(
@@ -303,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):
@@ -461,6 +462,13 @@ def nabu_std_err_has_error(errs: typing.Optional[bytes]):
             in line
             or "return SourceModule(" in line
             or "CUBLAS" in line
+            or "Not supported for EDF"
+            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/process/reconstruction/saaxis/saaxis.py

@@ -536,6 +536,8 @@ class SAAxisTask(
                     mess = "sa-axis computation succeeded"
             else:
                 cors_res = {}
+                state = DatasetState.FAILED
+                mess = "couldn't find 'compute_scores'"
 
         if self._cancelled:
             state = DatasetState.CANCELLED

tomwer/core/process/reconstruction/sadeltabeta/sadeltabeta.py

@@ -341,6 +341,8 @@ class SADeltaBetaTask(
                     mess = "sa-delta-beta computation succeeded"
             else:
                 dbs_res = {}
+                state = DatasetState.FAILED
+                mess = "couldn't find 'compute_scores'"
 
         if self._cancelled:
             state = DatasetState.CANCELLED

tomwer/core/process/task.py

@@ -46,7 +46,8 @@ from ewokscore.task import Task as _EwoksTask
 from ewokscore.taskwithprogress import TaskWithProgress as _EwoksTaskWithProgress
 from silx.io.dictdump import dicttoh5, h5todict
 from silx.io.utils import h5py_read_dataset
-from tomoscan.io import HDF5File, get_swmr_mode
+from silx.io.utils import open as open_hdf5
+from tomoscan.io import HDF5File
 from tomwer.core.utils.locker import FileLockerManager
 
 
@@ -376,12 +377,13 @@ class BaseProcessInfo:
         :rtype: list
         """
         # retrieve process to load
-        with HDF5File(process_file, mode="r", swmr=get_swmr_mode()) as h5f:
+        with open_hdf5(process_file) as h5f:
             if entry is None:
                 if len(h5f.keys()) > 0:
                     root = h5f[list(h5f.keys())[0]]
                 else:
                     _logger.warning("no process find")
+                    return []
             else:
                 root = h5f[entry]
 

tomwer/core/process/test/test_data_transfer.py

@@ -42,7 +42,8 @@ from nxtomomill.converter import from_h5_to_nx
 from nxtomomill.io.config.hdf5config import TomoHDF5Config
 from nxtomo.nxobject.nxdetector import ImageKey
 
-from tomoscan.io import HDF5File, get_swmr_mode
+from silx.io.utils import open as open_hdf5
+from tomoscan.io import HDF5File
 from tomoscan.validator import is_valid_for_reconstruction
 
 from tomwer.core.process.control.datalistener import DataListener
@@ -335,9 +336,9 @@ class NXTomoDataTransferBase(unittest.TestCase):
         dst_scan = process.outputs.data
         assert dst_scan.master_file != self.nexus_file_path
         assert is_valid_for_reconstruction(dst_scan, check_values=True)
-        with HDF5File(src_scan.master_file, mode="r", swmr=get_swmr_mode()) as h5s_src:
+        with open_hdf5(src_scan.master_file) as h5s_src:
             src_dataset = h5s_src["entry0000/detector/data"][...]
-        with HDF5File(dst_scan.master_file, mode="r", swmr=get_swmr_mode()) as h5s_dst:
+        with open_hdf5(dst_scan.master_file) as h5s_dst:
             dst_dataset = h5s_dst["entry0000/detector/data"][...]
         assert numpy.array_equal(src_dataset, dst_dataset)
 

tomwer/core/scan/blissscan.py

@@ -54,7 +54,7 @@ import logging
 from typing import Optional
 
 from silx.io.utils import h5py_read_dataset
-from tomoscan.io import HDF5File, get_swmr_mode
+from silx.io.utils import open as open_hdf5
 
 _logger = logging.getLogger(__name__)
 
@@ -203,7 +203,7 @@ class BlissScan:
                     return True
             return False
 
-        with HDF5File(file_path, mode="r", swmr=get_swmr_mode()) as h5s:
+        with open_hdf5(file_path) as h5s:
             if not isinstance(h5s, h5py.Group) or not isinstance(
                 h5s[entry], h5py.Group
             ):
@@ -227,7 +227,7 @@ class BlissScan:
             return tuple()
         else:
             res = []
-            with HDF5File(file_path, mode="r", swmr=get_swmr_mode()) as h5s:
+            with open_hdf5(file_path) as h5s:
                 for entry in h5s:
                     if BlissScan.is_bliss_valid_entry(file_path=file_path, entry=entry):
                         res.append(entry)

tomwer/core/scan/nxtomoscan.py

@@ -40,12 +40,12 @@ from urllib.parse import urlparse
 
 import h5py
 from processview.core.dataset import DatasetIdentifier
+from silx.io.utils import open as open_hdf5
 from tomoscan.esrf.identifier.hdf5Identifier import (
     NXtomoScanIdentifier as _NXtomoScanIdentifier,
 )
 from tomoscan.esrf.identifier.url_utils import UrlSettings, split_path, split_query
 from tomoscan.esrf.scan.nxtomoscan import NXtomoScan as _tsNXtomoScan
-from tomoscan.io import HDF5File, get_swmr_mode
 from nxtomo.nxobject.nxdetector import ImageKey
 
 from tomwer.utils import docstring
@@ -424,7 +424,7 @@ class NXtomoScan(_tsNXtomoScan, TomwerScanBase):
             return tuple()
         else:
             res = []
-            with HDF5File(file_path, mode="r", swmr=get_swmr_mode()) as h5s:
+            with open_hdf5(file_path) as h5s:
                 for entry_name, node in h5s.items():
                     if isinstance(node, h5py.Group):
                         if NXtomoScan.entry_is_nx_tomo(node):

tomwer/core/scan/scanbase.py

@@ -40,8 +40,9 @@ import functools
 import numpy
 from silx.io.url import DataUrl
 from silx.utils.enum import Enum as _Enum
+from silx.io.utils import open as open_hdf5
+
 from tomoscan.identifier import VolumeIdentifier
-from tomoscan.io import HDF5File, get_swmr_mode
 from tomoscan.normalization import IntensityNormalization
 from tomoscan.volumebase import VolumeBase
 from tomoscan.identifier import BaseIdentifier
@@ -131,7 +132,7 @@ class TomwerScanBase(TomwerObject):
             and self.process_file is not None
             and os.path.exists(self.process_file)
         ):
-            with HDF5File(self.process_file, mode="r", swmr=get_swmr_mode()) as h5s:
+            with open_hdf5(self.process_file) as h5s:
                 self._process_index = len(h5s.items())
         else:
             self._process_index = 0
@@ -756,7 +757,7 @@ class TomwerScanBase(TomwerObject):
         from tomwer.core.process.task import Task
 
         if os.path.exists(self.process_file):
-            with HDF5File(self.process_file, mode="r", swmr=get_swmr_mode()) as h5s:
+            with open_hdf5(self.process_file) as h5s:
                 if not hasattr(self, "entry"):
                     entry = "entry"
                 else:
@@ -864,9 +865,7 @@ def _get_reconstructed_single_file_volume(
 
                 if check_url is True:
                     try:
-                        with HDF5File(
-                            os.path.abspath(file_), "r", swmr=get_swmr_mode()
-                        ) as h5f:
+                        with open_hdf5(os.path.abspath(file_)) as h5f:
                             if entry not in h5f:
                                 logger.info("{volume} does not exists")
                                 return 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():

tomwer/gui/cluster/test/test_cluster.py

@@ -63,7 +63,6 @@ class TestSlurmWidget(TestCaseQt):
             "job_name": "tomwer_{scan}_-_{process}_-_{info}",
             "n_jobs": 1,
             "modules": ("tomotools/stable",),
-            "walltime": "01:00:00",
             "sbatch_extra_params": {
                 "export": "NONE",
                 "gpu_card": None,

tomwer/gui/control/datawatcher/datawatcher.py

@@ -148,7 +148,6 @@ class DataWatcherWidget(_DataWatcher, qt.QMainWindow):
 
         # set initial path to observe
         self.setFolderObserved(self._getInitPath())
-        self._initStatusView()
 
         # hide all windows by default
         for widget in (
@@ -475,20 +474,10 @@ class DataWatcherWidget(_DataWatcher, qt.QMainWindow):
             self.observationThread.sigScanReady.disconnect(self._signalScanReady)
             self.obsThIsConnected = False
 
-    def _initStatusView(self):
-        """
-        The status view need a thread to update the animated icon when scanning
-        """
-        self.__threadAnimation = QWaiterThread(0.1)
-        self.__threadAnimation.finished.connect(self._updateAnimatedIcon)
-
     def _updateStatusView(self):
         """Update the processing state"""
         if self.currentStatus in self._animatedStates:
-            if not self.__threadAnimation.isRunning():
-                self.__threadAnimation.start()
-            elif self.__threadAnimation is not None:
-                self.__threadAnimation.wait(4000)
+            pass
         elif self.currentStatus == "acquisition ended":
             self._setStateIcon(silxicons.getQIcon("selected"))
         elif self.currentStatus == "failure":
@@ -506,18 +495,6 @@ class DataWatcherWidget(_DataWatcher, qt.QMainWindow):
         else:
             self._stateLabel.setPixmap(icon.pixmap(30, state=qt.QIcon.On))
 
-    def _updateAnimatedIcon(self):
-        """Simple function which manage the waiting icon"""
-        if self.currentStatus in self._animatedStates:
-            icon = self.animated_icon.currentIcon()
-            if icon is None:
-                icon = qt.QIcon()
-            self.animated_icon._updateState()
-            self._setStateIcon(icon)
-
-            # get ready for the next animation
-            self.__threadAnimation.start()
-
     def _signalScanReady(self, scan):
         if type(scan) is str:
             try: