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

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

@@ -37,7 +37,7 @@ import typing
 from ewokscore.task import Task as EwoksTask
 from nxtomomill import converter as nxtomomill_converter
 from silx.io.utils import h5py_read_dataset
-from tomoscan.io import HDF5File
+from silx.io.utils import open as open_hdf5
 
 import tomwer.version
 from tomwer.core import settings
@@ -229,7 +229,7 @@ class DataListener(BaseProcessInfo):
         """Return the list of scans dir for this bliss_file / entry"""
 
         def get_scan_indexes():
-            with HDF5File(bliss_file, "r", swmr=DataListener.SWMR_MODE) as h5f:
+            with open_hdf5(bliss_file) as h5f:
                 entry_node = h5f[entry]
                 if _SCAN_NUMBER_PATH in entry_node:
                     return h5py_read_dataset(entry_node[_SCAN_NUMBER_PATH])
@@ -254,7 +254,7 @@ class DataListener(BaseProcessInfo):
         """Return the proposal file of the experimentation if registred by the
         data listener"""
         if entry is None:
-            with HDF5File(process_file, "r", swmr=DataListener.SWMR_MODE) as h5f:
+            with open_hdf5(process_file) as h5f:
                 entries = BaseProcessInfo._get_process_nodes(
                     root_node=h5f, process=DataListener
                 )
@@ -269,7 +269,7 @@ class DataListener(BaseProcessInfo):
                     entry = list(entries.keys())[0]
                     _logger.info("take %s as default entry" % entry)
 
-        with HDF5File(process_file, "r", swmr=DataListener.SWMR_MODE) as h5f:
+        with open_hdf5(process_file) as h5f:
             dl_nodes = BaseProcessInfo._get_process_nodes(
                 root_node=h5f[entry], process=DataListener
             )
@@ -311,7 +311,7 @@ class DataListener(BaseProcessInfo):
         """Return the proposal file of the experimentation if registred by the
         data listener"""
         if entry is None:
-            with HDF5File(process_file, "r", swmr=DataListener.SWMR_MODE) as h5f:
+            with open_hdf5(process_file) as h5f:
                 entries = BaseProcessInfo._get_process_nodes(
                     root_node=h5f, process=DataListener
                 )
@@ -326,7 +326,7 @@ class DataListener(BaseProcessInfo):
                     entry = list(entries.keys())[0]
                     _logger.info("take %s as default entry" % entry)
 
-        with HDF5File(process_file, "r", swmr=DataListener.SWMR_MODE) as h5f:
+        with open_hdf5(process_file) as h5f:
             dl_nodes = BaseProcessInfo._get_process_nodes(
                 root_node=h5f[entry], process=DataListener
             )
@@ -360,7 +360,7 @@ class DataListener(BaseProcessInfo):
         """Return the proposal file of the experimentation if registred by the
         data listener"""
         if entry is None:
-            with HDF5File(process_file, "r", swmr=DataListener.SWMR_MODE) as h5f:
+            with open_hdf5(process_file) as h5f:
                 entries = BaseProcessInfo._get_process_nodes(
                     root_node=h5f, process=DataListener
                 )
@@ -375,7 +375,7 @@ class DataListener(BaseProcessInfo):
                     entry = list(entries.keys())[0]
                     _logger.info("take %s as default entry" % entry)
 
-        with HDF5File(process_file, "r", swmr=DataListener.SWMR_MODE) as h5f:
+        with open_hdf5(process_file) as h5f:
             dl_nodes = BaseProcessInfo._get_process_nodes(
                 root_node=h5f[entry], process=DataListener
             )
@@ -410,7 +410,7 @@ class DataListener(BaseProcessInfo):
         specific sequence data
         """
         if entry is None:
-            with HDF5File(process_file, "r", swmr=DataListener.SWMR_MODE) as h5f:
+            with open_hdf5(process_file) as h5f:
                 entries = BaseProcessInfo._get_process_nodes(
                     root_node=h5f, process=DataListener
                 )
@@ -425,7 +425,7 @@ class DataListener(BaseProcessInfo):
                     entry = list(entries.keys())[0]
                     _logger.info("take %s as default entry" % entry)
 
-        with HDF5File(process_file, "r", swmr=DataListener.SWMR_MODE) as h5f:
+        with open_hdf5(process_file) as h5f:
             dl_nodes = BaseProcessInfo._get_process_nodes(
                 root_node=h5f[entry], process=DataListener
             )
@@ -503,7 +503,7 @@ class DataListener(BaseProcessInfo):
         # write
         def sequence_is_finished():
             try:
-                with HDF5File(bliss_file, "r", swmr=DataListener.SWMR_MODE) as h5f:
+                with open_hdf5(bliss_file) as h5f:
                     end_scan_path = "/".join((entry, "end_time"))
                     return end_scan_path in h5f
             except Exception:

tomwer/core/process/control/datawatcher/edfdwprocess.py

@@ -50,15 +50,6 @@ except ImportError:
     has_rsync = True
 
 
-def get_info_val(lines, key):
-    r = range(len(lines))
-    key = key + "="
-    for i in r:
-        if key in lines[i]:
-            val = float(lines[i].split("=")[1])
-    return val
-
-
 class _DataWatcherEDFProcess(_DataWatcherProcess):
     """
     Base class for edf acquisition observation

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

@@ -76,7 +76,7 @@ else:
     has_composite_cor_finder = True
 from silx.io.url import DataUrl
 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__)
 if not has_composite_cor_finder:
@@ -1164,7 +1164,7 @@ class AxisTask(
         :return:
         """
         if entry is None:
-            with HDF5File(process_file, "r", swmr=get_swmr_mode()) as h5f:
+            with open_hdf5(process_file) as h5f:
                 entries = AxisTask._get_process_nodes(root_node=h5f, process=AxisTask)
                 if len(entries) == 0:
                     _logger.info("unable to find a Axis process in %s" % process_file)
@@ -1175,7 +1175,7 @@ class AxisTask(
                     entry = list(entries.keys())[0]
                     _logger.info("take %s as default entry" % entry)
 
-        with HDF5File(process_file, "r", swmr=get_swmr_mode()) as h5f:
+        with open_hdf5(process_file) as h5f:
             axis_nodes = AxisTask._get_process_nodes(
                 root_node=h5f[entry], process=AxisTask
             )

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

@@ -39,6 +39,7 @@ 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,
@@ -297,7 +298,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 +310,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

@@ -171,6 +171,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(
@@ -461,6 +463,10 @@ 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
         )
 
     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/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:

tomwer/gui/control/reducedarkflatselector.py

@@ -8,11 +8,11 @@ from silx.gui import qt
 from silx.gui.plot import Plot2D
 from silx.io.dictdump import h5todict
 from silx.io.url import DataUrl
+from silx.io.utils import open as open_hdf5
 from silx.gui.dialog.DataFileDialog import DataFileDialog
 
 from tomoscan.esrf.scan.utils import cwd_context
 from tomoscan.framereducer.target import REDUCER_TARGET
-from tomoscan.io import HDF5File, get_swmr_mode
 
 from tomwer.io.utils import get_default_directory
 
@@ -249,7 +249,7 @@ class ReduceDarkFlatSelectorTableWidget(qt.QWidget):
         if not os.path.exists(file_path):
             _logger.error(f"file doesn't exists ({file_path})")
 
-        with HDF5File(file_path, mode="r", swmr=get_swmr_mode()) as h5f:
+        with open_hdf5(file_path) as h5f:
             entries = tuple(h5f.keys())
 
         res = []