nxtomomill 2.1.0.dev2__tar.gz → 2.1.0.dev4__tar.gz

{nxtomomill-2.1.0.dev2/nxtomomill.egg-info → nxtomomill-2.1.0.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nxtomomill
-Version: 2.1.0.dev2
+Version: 2.1.0.dev4
 Summary: applications and library to convert raw format to NXtomo format
 Author-email: Henri Payno <henri.payno@esrf.fr>, Pierre Paleo <pierre.paleo@esrf.fr>, Pierre-Olivier Autran <pierre-olivier.autran@esrf.fr>, Jérôme Lesaint <jerome.lesaint@esrf.fr>, Alessandro Mirone <mirone@esrf.fr>
 License: 
@@ -55,13 +55,14 @@ License-File: LICENSE
 Requires-Dist: numpy
 Requires-Dist: h5py>=3.0
 Requires-Dist: silx>=2.0
-Requires-Dist: nxtomo>=3.0.0dev0
+Requires-Dist: nxtomo>=3.1.0dev1
 Requires-Dist: pint
 Requires-Dist: packaging
 Requires-Dist: tomoscan[full]>=2.2.0a4
 Requires-Dist: tqdm
 Requires-Dist: pydantic
 Requires-Dist: eval_type_backport; python_version < "3.10"
+Requires-Dist: platformdirs
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: python-gitlab; extra == "test"

{nxtomomill-2.1.0.dev2 → nxtomomill-2.1.0.dev4}/nxtomomill/app/dxfile2nx.py

@@ -103,9 +103,16 @@ def main(argv):
         "--fov",
         "--field-of-view",
         default=None,
-        help="field of view. Can be Full or Half",
+        help="DEPRECATED: field of view as string. Use --half-acquisition instead.",
         dest="field_of_view",
     )
+    parser.add_argument(
+        "--half-acquisition",
+        help="Use half acquisition instead of full acquisition.",
+        action="store_true",
+        dest="half_acquisition",
+        default=None,
+    )
     # as distance is not stored in the dxfile and requested for paganin
     # we provide some default value
     parser.add_argument(
@@ -139,6 +146,12 @@ def main(argv):
     )
     options = parser.parse_args(argv[1:])
 
+    if options.field_of_view is not None and options.half_acquisition is not None:
+        raise ValueError(
+            "Cannot use --field-of-view and --half-acquisition together. "
+            "Please use --half-acquisition."
+        )
+
     distance = options.distance
     if distance is not None:
         distance = float(options.distance)
@@ -163,6 +176,7 @@ def main(argv):
         scan_range=convert_2elmts__tuple_to_float(options.scan_range),
         pixel_size=_get_pixel_size(options.pixel_size),
         field_of_view=options.field_of_view,
+        half_acquisition=options.half_acquisition,
         distance=distance,
         overwrite=options.overwrite,
         duplicate_data=options.duplicate_data,

{nxtomomill-2.1.0.dev2 → nxtomomill-2.1.0.dev4}/nxtomomill/app/h52nx.py

@@ -11,7 +11,6 @@ For a complete tutorial you can have a look at: :ref:`Tomoh52nx`
 
 import argparse
 import logging
-import os
 
 from tqdm import tqdm
 
@@ -126,6 +125,11 @@ def main(argv):
         "parse raw data to find this information.",
         default=None,
     )
+    parser.add_argument(
+        "--half-acquisition",
+        help="If the scan is an half-acquisition (CoR at the borders of projections).",
+        default=None,
+    )
     parser.add_argument(
         "--no-input",
         "--no-input-for-missing-information",
@@ -206,9 +210,10 @@ def main(argv):
         help="Y pixel size key to read",
     )
     parser.add_argument(
-        "--read-mode",
+        "--open_mode_for_reading",
+        "--open-mode-for-reading",
         default="robust",
-        help="Options when reading bliss file. Valid values are 'locking', 'swmr' and 'safe'. 'robust' is the default h5py read mode.",
+        help="Options when reading bliss file. Valid values are 'robust' or 'safe'. 'robust' is the default h5py read mode.",
     )
     # scan titles
     parser.add_argument(
@@ -301,21 +306,23 @@ def main(argv):
         help="file containing the full configuration to convert from h5 "
         "bliss to nexus",
     )
-
+    parser.add_argument(
+        "--use-abs-path-for-vds",
+        "--abs-path-for-vds",
+        "--use_abs_path_for_vds",
+        "--use-abs-path-for-vds",
+        default=False,
+        action="store_true",
+        help="Generated NXtomo file contains relative path by default. "
+        "Sometime relative link cannot be solved (GPFS vs NFS). "
+        "In this case you might be forced to use absolute path.",
+    )
     options = parser.parse_args(argv[1:])
     if options.request_input:
         callback_det_sel = _ask_for_selecting_detector
     else:
         callback_det_sel = None
 
-    # define reading mode
-    read_mode = os.getenv("NXTOMOMILL_HDF5_READ_MODE", "robust")
-    if options.read_mode not in ("robust", "safe", "swmr"):
-        raise ValueError(
-            f"Invalid read mode: {read_mode}. Valid values are 'robust', 'safe' and 'swmr'"
-        )
-    os.environ["NXTOMOMILL_HDF5_READ_MODE"] = options.read_mode
-
     try:
         configuration_handler = TomoHDF5ConfigHandler(options)
     except Exception:

{nxtomomill-2.1.0.dev2 → nxtomomill-2.1.0.dev4}/nxtomomill/app/patch_nx.py

@@ -253,7 +253,9 @@ def main(argv):
             "No url provided for dark or flats or frame type to "
             "modify. Nothing to be done."
         )
-    elif not utils.is_nx_tomo_entry(file_path=options.file_path, entry=options.entry):
+    elif not utils.is_nx_tomo_entry(
+        file_path=options.file_path, entry=options.entry, open_mode_for_reading="safe"
+    ):
         _logger.error(
             f"{options.entry}@{options.file_path} is not recognized as a valid NXTomo entry."
         )
@@ -292,4 +294,5 @@ def main(argv):
                 flats_end=flat_end_url,
                 embed_data=True,
                 logger=_logger,
+                open_mode_for_reading="robust",
             )

{nxtomomill-2.1.0.dev2 → nxtomomill-2.1.0.dev4}/nxtomomill/app/split_nxfile.py

@@ -47,7 +47,17 @@ def main(argv):
         help="Make all NXtomo free of any external link. As a result this will duplicate data",
         nargs="?",
     )
-
+    parser.add_argument(
+        "--use_abs_path_for_vds",
+        "--use-abs-path-for-vds",
+        "--abs-path-for-vds",
+        "--abs_path_for_vds",
+        default=False,
+        action="store_true",
+        help="Generated NXtomo file contains relative path by default. "
+        "Sometime relative link cannot be solved (GPFS vs NFS). "
+        "In this case you might be forced to use absolute path.",
+    )
     options = parser.parse_args(argv[1:])
     output_file_pattern = options.output_file_pattern
     if "{input_file_name}" in output_file_pattern:
@@ -61,6 +71,7 @@ def main(argv):
         input_file=options.input_file,
         output_file_pattern=output_file_pattern,
         overwrite=options.overwrite,
+        force_abs_path=options.use_abs_path_for_vds,
     )
 
 
@@ -69,11 +80,13 @@ def split(
     output_file_pattern: str,
     overwrite: bool = False,
     duplicate_data: bool = False,
+    force_abs_path: bool = False,
 ) -> tuple:
     """
     :param input_file: path to the file to be splitted
     :param output_file_pattern: pattern of the file to create. Must contain either `{entry_name}` or `{index}`
     :param overwrite: can we overwrite output file if alread exists
+    :param force_abs_path: should the generated NXtomo contains absolute path (True) or relative path (False, default)
 
     :return: tuple of identifier of all the NXtomo generated
     """
@@ -128,7 +141,10 @@ def split(
                 if dirname and not os.path.exists(dirname):
                     os.makedirs(dirname)
                 nx_tomo.save(
-                    file_path=output_file, data_path=entry, overwrite=overwrite
+                    file_path=output_file,
+                    data_path=entry,
+                    overwrite=overwrite,
+                    use_abs_path_for_vds=force_abs_path,
                 )
                 result.append(NXtomoScan(output_file, entry))
 

{nxtomomill-2.1.0.dev2 → nxtomomill-2.1.0.dev4}/nxtomomill/app/z_concatenate_scans.py

@@ -209,7 +209,9 @@ def main(argv):
         if dummy_frame is None:
             if len(nxt.instrument.detector.data) > 0:
                 # create empty frame to give it to the 'invalid_nxt' NXtomo later
-                with DatasetReader(nxt.instrument.detector.data[0]) as raw_data:
+                with DatasetReader(
+                    nxt.instrument.detector.data[0], open_mode_for_reading="safe"
+                ) as raw_data:
                     data_type = raw_data.dtype
                 # FIXME: avoid keeping some file open. not clear why this is needed
                 raw_data = None

{nxtomomill-2.1.0.dev2 → nxtomomill-2.1.0.dev4}/nxtomomill/converter/dxfile/dxfileconverter.py

@@ -49,6 +49,7 @@ def from_dx_to_nx(
     scan_range: tuple = (0.0, 180.0),
     pixel_size=(None, None),
     field_of_view: FieldOfView | str | None = None,
+    half_acquisition: bool | None = None,
     distance: float | None = None,
     overwrite: bool = True,
     energy: float | None = None,
@@ -84,6 +85,7 @@ def from_dx_to_nx(
     configuration.scan_range = scan_range
     configuration.pixel_size = pixel_size
     configuration.field_of_view = field_of_view
+    configuration.half_acquisition = half_acquisition
     configuration.sample_detector_distance = distance
     configuration.overwrite = overwrite
     configuration.energy = energy
@@ -143,7 +145,7 @@ class _DxFileToNxConverter(BaseConverter):
             output_file = os.path.join(
                 os.path.dirname(input_file),
                 os.path.basename(input_file_basename)
-                + self._configuration.file_extension,
+                + self._configuration.file_extension.value,
             )
         else:
             output_file = os.path.abspath(self.output_file)
@@ -200,6 +202,10 @@ class _DxFileToNxConverter(BaseConverter):
     def field_of_view(self) -> FieldOfView | None:
         return self._configuration.field_of_view
 
+    @property
+    def half_acquisition(self) -> bool | None:
+        return self._configuration.half_acquisition
+
     @property
     def energy(self) -> float | None:
         return self._configuration.energy
@@ -281,12 +287,15 @@ class _DxFileToNxConverter(BaseConverter):
             detector_grp["y_pixel_size"] = y_pixel_size
             detector_grp["y_pixel_size"].attrs["units"] = "m"
         #  field of view
-        if self.field_of_view is not None:
+        if self.field_of_view is not None or self.half_acquisition is not None:
             with HDF5File(self.output_file, mode="a") as h5f:
                 root_grp = h5f.require_group(self.output_entry)
                 instrument_grp = root_grp.require_group("instrument")
                 detector_grp = instrument_grp.require_group("detector")
-                detector_grp["field_of_view"] = self.field_of_view.value
+                if self.field_of_view is not None:
+                    detector_grp["field_of_view"] = self.field_of_view.value
+                if self.half_acquisition is not None:
+                    detector_grp["half_acquisition"] = self.half_acquisition
         #  distance
         if self._configuration.sample_detector_distance is None:
             # if value not set by the user let read it
@@ -329,7 +338,9 @@ class _DxFileToNxConverter(BaseConverter):
         self._copy_count_time()
 
         # start time
-        with EntryReader(self.input_root_url) as input_entry:
+        with EntryReader(
+            self.input_root_url, open_mode_for_reading="safe"
+        ) as input_entry:
             if "file_creation_datetime" in input_entry:
                 with HDF5File(self.output_file, mode="a") as h5f:
                     root_grp = h5f.require_group(self.output_entry)
@@ -365,7 +376,9 @@ class _DxFileToNxConverter(BaseConverter):
                         f"Failed to get 'count_time' / 'exposure_period'. reason is {e}"
                     )
 
-        with EntryReader(self.input_root_url) as input_entry:
+        with EntryReader(
+            self.input_root_url, open_mode_for_reading="safe"
+        ) as input_entry:
             if "measurement" in input_entry:
                 measurement_grp = input_entry["measurement"]
                 if "detector" in measurement_grp:
@@ -469,7 +482,9 @@ class _DxFileToNxConverter(BaseConverter):
         n_proj = 0
         # handle darks
         try:
-            with DatasetReader(self._data_darks_url) as dark_dataset:
+            with DatasetReader(
+                self._data_darks_url, open_mode_for_reading="safe"
+            ) as dark_dataset:
                 n_dark = dark_dataset.shape[0]
             # FIXME: avoid keeping some file open. not clear why this is needed
             dark_dataset = None
@@ -491,7 +506,9 @@ class _DxFileToNxConverter(BaseConverter):
 
         # handle flats
         try:
-            with DatasetReader(self._data_flats_url) as flat_dataset:
+            with DatasetReader(
+                self._data_flats_url, open_mode_for_reading="safe"
+            ) as flat_dataset:
                 n_flat = flat_dataset.shape[0]
             # FIXME: avoid keeping some file open. not clear why this is needed
             flat_dataset = None
@@ -513,7 +530,9 @@ class _DxFileToNxConverter(BaseConverter):
 
         # handle projections
         try:
-            with DatasetReader(self._data_proj_url) as proj_dataset:
+            with DatasetReader(
+                self._data_proj_url, open_mode_for_reading="safe"
+            ) as proj_dataset:
                 n_proj = proj_dataset.shape[0]
             # FIXME: avoid keeping some file open. not clear why this is needed
             proj_dataset = None
@@ -554,7 +573,9 @@ class _DxFileToNxConverter(BaseConverter):
             self._path_nxtomo_attrs(root_grp)
 
     def _read_sample_detector_distance(self):
-        with EntryReader(self.input_root_url) as input_entry:
+        with EntryReader(
+            self.input_root_url, open_mode_for_reading="safe"
+        ) as input_entry:
             path = "/".join(
                 ("measurement", "instrument", "sample", "setup", "detector_distance")
             )
@@ -568,7 +589,9 @@ class _DxFileToNxConverter(BaseConverter):
             return distance * unit
 
     def _read_energy(self):
-        with EntryReader(self.input_root_url) as input_entry:
+        with EntryReader(
+            self.input_root_url, open_mode_for_reading="safe"
+        ) as input_entry:
             path = "/".join(("measurement", "instrument", "source", "energy"))
             dataset = input_entry[path]
             energy = float(h5py_read_dataset(dataset))
@@ -580,7 +603,9 @@ class _DxFileToNxConverter(BaseConverter):
             return energy * unit
 
     def _read_x_pixel_size(self):
-        with EntryReader(self.input_root_url) as input_entry:
+        with EntryReader(
+            self.input_root_url, open_mode_for_reading="safe"
+        ) as input_entry:
             path = "/".join(
                 ("measurement", "instrument", "detector", "actual_pixel_size_x")
             )
@@ -594,7 +619,9 @@ class _DxFileToNxConverter(BaseConverter):
             return pixel_size * unit
 
     def _read_y_pixel_size(self):
-        with EntryReader(self.input_root_url) as input_entry:
+        with EntryReader(
+            self.input_root_url, open_mode_for_reading="safe"
+        ) as input_entry:
             path = "/".join(
                 ("measurement", "instrument", "detector", "actual_pixel_size_y")
             )

{nxtomomill-2.1.0.dev2 → nxtomomill-2.1.0.dev4}/nxtomomill/converter/dxfile/tests/test_dxfile.py

@@ -1,16 +1,18 @@
 # coding: utf-8
 
 import os
+import h5py
 import pytest
 import numpy
 
-from nxtomomill import converter
+from nxtomomill.converter.dxfile.dxfileconverter import from_dx_config_to_nx
+from nxtomomill.models.dx2nx import DX2nxModel
 from nxtomomill.tests.utils.dxfile import MockDxFile
 
 from tomoscan.esrf.scan.nxtomoscan import NXtomoScan
 from tomoscan.validator import is_valid_for_reconstruction
 
-from silx.io.utils import get_data
+from silx.io.utils import get_data, h5py_read_dataset
 
 
 @pytest.mark.parametrize("duplicate_data", (True, False))
@@ -32,11 +34,13 @@ def test_dx_file_conversion(tmp_path, duplicate_data):
 
     output_file = os.path.join(folder, "dxfile.nx")
 
-    results = converter.from_dx_to_nx(
+    config = DX2nxModel(
         input_file=dxfile_path,
         output_file=output_file,
         duplicate_data=duplicate_data,
     )
+
+    results = from_dx_config_to_nx(config)
     assert len(results) == 1
     assert os.path.exists(output_file)
     _, entry = results[0]
@@ -62,17 +66,58 @@ def test_dx_file_conversion(tmp_path, duplicate_data):
 
     # if overwrite not requested should fail on reprocessing
     with pytest.raises(OSError):
-        converter.from_dx_to_nx(
+        from_dx_config_to_nx(
+            DX2nxModel(
+                input_file=dxfile_path,
+                output_file=output_file,
+                duplicate_data=duplicate_data,
+                overwrite=False,
+            )
+        )
+
+    # if overwrite requested should succeed
+    from_dx_config_to_nx(
+        DX2nxModel(
             input_file=dxfile_path,
             output_file=output_file,
             duplicate_data=duplicate_data,
-            overwrite=False,
+            overwrite=True,
         )
+    )
 
-    # if overwrite requested should succeed
-    converter.from_dx_to_nx(
-        input_file=dxfile_path,
-        output_file=output_file,
-        overwrite=True,
-        duplicate_data=duplicate_data,
+
+def test_dx_file_conversion_half_acquisition(tmp_path):
+    folder = tmp_path / "test_dx_file_conversion_half_acquisition"
+    folder.mkdir()
+    dxfile_path = os.path.join(folder, "dxfile.h5")
+
+    n_projections = 10
+    n_darks = 1
+    n_flats = 1
+    MockDxFile(
+        file_path=dxfile_path,
+        n_projection=n_projections,
+        n_darks=n_darks,
+        n_flats=n_flats,
     )
+
+    output_file = os.path.join(folder, "dxfile_half.nx")
+
+    results = from_dx_config_to_nx(
+        DX2nxModel(
+            input_file=dxfile_path,
+            output_file=output_file,
+            half_acquisition=True,
+        )
+    )
+    assert len(results) == 1
+    assert os.path.exists(output_file)
+
+    with h5py.File(output_file, "r") as h5f:
+        assert h5py_read_dataset(
+            h5f["entry0000/instrument/detector/half_acquisition"]
+        ) is numpy.bool(True)
+        assert (
+            h5py_read_dataset(h5f["entry0000/instrument/detector/field_of_view"])
+            == "Half"
+        )

{nxtomomill-2.1.0.dev2 → nxtomomill-2.1.0.dev4}/nxtomomill/converter/edf/edfconverter.py

@@ -1000,16 +1000,24 @@ def __process(
         output_grp["/entry/instrument"].attrs["NX_class"] = "NXinstrument"
         output_grp["/entry/instrument/detector"].attrs["NX_class"] = "NXdetector"
         output_grp["/entry/instrument/detector/data"].attrs["interpretation"] = "image"
-        if configuration.field_of_view is not None:
+        if configuration.half_acquisition is not None:
+            half_acquisition = configuration.half_acquisition
+            field_of_view = "Half" if half_acquisition else "Full"
+        elif configuration.field_of_view is not None:
             field_of_view = configuration.field_of_view
+            half_acquisition = field_of_view is FieldOfView.HALF
         elif abs(scan.scan_range) == 180:
             field_of_view = "Full"
+            half_acquisition = False
         elif abs(scan.scan_range) == 360:
             field_of_view = "Half"
+            half_acquisition = True
 
         if field_of_view is not None:
             field_of_view = FieldOfView(field_of_view)
             output_grp["/entry/instrument/detector/field_of_view"] = field_of_view.value
+        if half_acquisition is not None:
+            output_grp["/entry/instrument/detector/half_acquisition"] = half_acquisition
 
         output_grp["/entry/sample"].attrs["NX_class"] = "NXsample"
         output_grp["/entry/definition"] = "NXtomo"

{nxtomomill-2.1.0.dev2 → nxtomomill-2.1.0.dev4}/nxtomomill/converter/fscan/fscanconverter.py

@@ -125,9 +125,7 @@ def from_fscan_to_nx(
             )
         my_nxtomo.sample.rotation_angle = np.concatenate(rotation_angles) * _ureg.degree
 
-    my_nxtomo.instrument.detector.field_of_view = (
-        "Half" if (halftomo and do_360) else "Full"
-    )
+    my_nxtomo.instrument.detector.half_acquisition = halftomo and do_360
     my_nxtomo.instrument.detector.x_pixel_size = (
         my_nxtomo.instrument.detector.y_pixel_size
     ) = (6.5 * 1e-6)

nxtomomill-2.1.0.dev4/nxtomomill/converter/hdf5/acquisition/_bliss_activeconfig.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+import h5py
+from silx.io.utils import h5py_read_dataset
+
+__all__ = [
+    "BlissActiveConfig",
+]
+
+
+class BlissActiveConfig:
+    """
+    hold the bliss active config. Can retrieve the 'tomo_detector' that contains information about the optic
+    """
+
+    def __init__(self) -> None:
+        self._tomo_detector: None | tuple[str, ...] = None
+
+    @property
+    def tomo_detector(self) -> tuple[str, ...] | None:
+        return self._tomo_detector
+
+    @staticmethod
+    def from_hdf5_group(group: h5py.Group):
+        """
+        Create an instance of 'BlissActiveConfig' from a group (containing the bliss active configuration).
+        """
+        if not isinstance(group, h5py.Group):
+            raise TypeError
+
+        bliss_config = BlissActiveConfig()
+        if "tomo_detector" in group:
+            bliss_config._tomo_detector = h5py_read_dataset(group["tomo_detector"])
+        return bliss_config

{nxtomomill-2.1.0.dev2 → nxtomomill-2.1.0.dev4}/nxtomomill/converter/hdf5/acquisition/baseacquisition.py

@@ -64,12 +64,15 @@ class BaseAcquisition:
     )
 
     _INSTRUMENT_NAME_PATH = (
+        "instrument/name",
         "technique/saving/beamline",
         "instrument/title",
     )
 
     _FOV_PATH = "technique/scan/field_of_view"
 
+    _HALF_ACQUISITION = "technique/scan/half_acquisition"
+
     _NB_LOOP_PATH = ("technique/scan/nb_loop", "technique/proj/nb_loop")
 
     _NB_TOMO_PATH = ("technique/scan/nb_tomo", "technique/proj/nb_tomo")
@@ -98,14 +101,10 @@ class BaseAcquisition:
 
     _SOURCE_NAME = ("instrument/machine/name",)
 
-    _BEAMLINE_NAME = (
-        "instrument/name",
-        "instrument/title",
-    )
-
     _SOURCE_TYPE = ("instrument/machine/type",)
 
     _FRAME_FLIP_PATHS = (
+        "instrument/{active_config_tomo_detector}/data_axes",  # note: data_axes are stored in the optic and not in the camera name.
         "technique/detector/{detector_name}/flipping",
         "technique/detector/flipping",
     )
@@ -203,7 +202,7 @@ class BaseAcquisition:
             if self.configuration.single_file or not divide_sub_files:
                 en_output_file = self.configuration.output_file
             else:
-                ext = file_extension_ or self.configuration.file_extension
+                ext = file_extension_ or self.configuration.file_extension.value
                 file_name = (
                     os.path.splitext(output_file_basename)[0]
                     + "_"
@@ -284,7 +283,10 @@ class BaseAcquisition:
                         and self._copy_frames[url.path()]
                     ):
                         new_url = embed_url(url, output_file=output_file)
-                        n_vs, _, _ = from_data_url_to_virtual_source(new_url)
+                        n_vs, _, _ = from_data_url_to_virtual_source(
+                            new_url,
+                            open_mode_for_reading=self.configuration.open_mode_for_reading,
+                        )
                         new_vs.append(n_vs)
                     else:
                         new_vs.append(vs)
@@ -294,7 +296,11 @@ class BaseAcquisition:
             if input_file_path is not None:
                 nx_tomo.bliss_original_files = (abspath(input_file_path),)
             # save data
-            nx_tomo.save(file_path=output_file, data_path=data_path)
+            nx_tomo.save(
+                file_path=output_file,
+                data_path=data_path,
+                use_abs_path_for_vds=self.configuration.use_abs_path_for_vds,
+            )
             # check rotation angle
             if nx_tomo.sample.rotation_angle is not None:
                 unique_angles = numpy.unique(
@@ -331,7 +337,10 @@ class BaseAcquisition:
         raise NotImplementedError("Base class")
 
     def read_entry(self):
-        return EntryReader(self._root_url)
+        return EntryReader(
+            self._root_url,
+            open_mode_for_reading=self.configuration.open_mode_for_reading,
+        )
 
     def is_different_sequence(self, entry):
         """
@@ -346,7 +355,9 @@ class BaseAcquisition:
             return False
 
         def read_sample_node(url: DataUrl) -> str | None:
-            with EntryReader(url=url) as entry:
+            with EntryReader(
+                url=url, open_mode_for_reading=self.configuration.open_mode_for_reading
+            ) as entry:
                 sample_node = self._get_sample_node(entry)
                 if sample_node is None:
                     return None
@@ -536,7 +547,10 @@ class BaseAcquisition:
             _logger.warning("no root url. Unable to read rotation motor")
             return None
         else:
-            with EntryReader(self._root_url) as entry:
+            with EntryReader(
+                self._root_url,
+                open_mode_for_reading=self.configuration.open_mode_for_reading,
+            ) as entry:
                 for motor_path in self._TECHNIQUE_MOTOR_PATHS:
                     if motor_path in entry:
                         try:
@@ -809,7 +823,10 @@ class BaseAcquisition:
             _logger.warning("no root url. Unable to read detector roi")
             return None
         else:
-            with EntryReader(self._root_url) as entry:
+            with EntryReader(
+                self._root_url,
+                open_mode_for_reading=self.configuration.open_mode_for_reading,
+            ) as entry:
                 for roi_path in self._DETECTOR_ROI:
                     if roi_path in entry:
                         try: