nxtomomill 2.2.0.dev0__py3-none-any.whl → 2.2.0.dev2__py3-none-any.whl

nxtomomill/__main__.py

@@ -84,7 +84,7 @@ class Launcher(_Launcher):
                 replacement=deprecation_info.replacement,
                 since_version=deprecation_info.since,
             )
-        super().execute(argv=argv)
+        return super().execute(argv=argv)
 
     def print_help(self):
         """Print the help to stdout."""

nxtomomill/app/h52nx.py

@@ -10,12 +10,14 @@ For a complete tutorial you can have a look at: :ref:`Tomoh52nx`
 """
 
 import argparse
+import cProfile
 import logging
+import os
 
 from tqdm import tqdm
 
 from nxtomomill import utils
-from nxtomomill.converter import from_h5_to_nx
+from nxtomomill.converter.hdf5.hdf5converter import _H5ToNxConverter
 from nxtomomill.io.config.confighandler import (
     SETTABLE_PARAMETERS_UNITS,
     TomoHDF5ConfigHandler,
@@ -317,12 +319,49 @@ def main(argv):
         "Sometime relative link cannot be solved (GPFS vs NFS). "
         "In this case you might be forced to use absolute path.",
     )
+    parser.add_argument(
+        "--no-resolve-vds",
+        "--no-resolve-vds-links",
+        "--no_resolve_vds",
+        dest="resolve_vds",
+        action="store_false",
+        default=None,
+        help="Do not resolve external links and virtual datasets (VDS) down to "
+        "their final source when building the output NXtomo. Can speed up the "
+        "conversion for datasets with many nested links, at the cost of the "
+        "output file containing VDS pointing to other VDS instead of direct "
+        "links to the raw data. Defaults to the 'NXTOMOMILL_RESOLVE_VDS' "
+        "environment variable if set, else resolving is enabled.",
+    )
+    parser.add_argument(
+        "--profiling",
+        "--profile",
+        help="Profile the conversion with 'cProfile' and dump the statistics "
+        "to a file (see '--profiling-output-file').",
+        action="store_true",
+        default=False,
+    )
+    parser.add_argument(
+        "--profiling-output-file",
+        "--profiling_output_file",
+        default="profiling.out",
+        help="Output file to dump the 'cProfile' statistics to when "
+        "'--profiling' is provided. If this file already exists the "
+        "conversion won't be launched (default: 'profiling.out').",
+    )
     options = parser.parse_args(argv[1:])
     if options.request_input:
         callback_det_sel = _ask_for_selecting_detector
     else:
         callback_det_sel = None
 
+    if options.profiling and os.path.exists(options.profiling_output_file):
+        _logger.error(
+            f"Profiling output file already exists: '{options.profiling_output_file}'. "
+            "Remove it or provide another one with '--profiling-output-file'."
+        )
+        return 1
+
     try:
         configuration_handler = TomoHDF5ConfigHandler(options)
     except Exception:
@@ -335,9 +374,21 @@ def main(argv):
             configuration_handler.configuration.log_level
         )
         with tqdm(desc="h52nx", delay=1, bar_format="{l_bar}{bar}") as progress:
-            from_h5_to_nx(
+            converter = _H5ToNxConverter(
                 configuration=configuration_handler.configuration,
                 progress=progress,
                 input_callback=None,
                 detector_sel_callback=callback_det_sel,
             )
+            if options.profiling:
+                profiler = cProfile.Profile()
+                profiler.enable()
+                try:
+                    converter.convert()
+                finally:
+                    profiler.disable()
+                    profiler.dump_stats(options.profiling_output_file)
+            else:
+                converter.convert()
+            if converter.has_failed_acquisitions:
+                return 1

nxtomomill/converter/hdf5/acquisition/baseacquisition.py

@@ -12,7 +12,9 @@ import copy
 
 import h5py
 
+import nxtomomill
 from nxtomo.application.nxtomo import NXtomo
+from nxtomo.io import HDF5File
 from nxtomomill.utils.h5pyutils import from_data_url_to_virtual_source
 from nxtomomill.utils.hdf5 import EntryReader
 from nxtomomill.utils.utils import embed_url  # noqa F401
@@ -30,8 +32,9 @@ from silx.io.url import DataUrl
 from silx.io.utils import h5py_read_dataset
 
 from nxtomomill.models.h52nx.h52nx import H52nxModel
-from .utils._keys import keys_to_str_tuple
-from .utils._context import read_key, MissingValue
+from nxtomomill.models.h52nx._context import _Key
+from .utils._keys import keys_to_str_tuple, split_keys_by_priority
+from .utils._context import read_key, MissingValue, InvalidValue
 
 _ureg = pint.get_application_registry()
 _logger = logging.getLogger(__name__)
@@ -300,7 +303,14 @@ class BaseAcquisition:
                 file_path=output_file,
                 data_path=data_path,
                 use_abs_path_for_vds=self.configuration.use_abs_path_for_vds,
+                overwrite=self.configuration.overwrite,
             )
+            # record the nxtomomill version used to create this NXtomo as attributes
+            # on the NXtomo entry group itself
+            with HDF5File(output_file, mode="a") as h5f:
+                entry_grp = h5f[data_path]
+                entry_grp.attrs["creator"] = "nxtomomill"
+                entry_grp.attrs["creator_version"] = nxtomomill.__version__
             # check rotation angle
             if nx_tomo.sample.rotation_angle is not None:
                 unique_angles = numpy.unique(
@@ -408,6 +418,12 @@ class BaseAcquisition:
                     except MissingValue:
                         # skip values containing '*DIS*'
                         continue
+                    except InvalidValue:
+                        # dataset reports an 'ERR' value: skip it and try the next key
+                        _logger.warning(
+                            f"{info_retrieve} reports an 'ERR' value for {node.name} - {key}. This key will be skipped."
+                        )
+                        continue
                     except KeyError as e:
                         _logger.info(
                             f"Cannot solve key {key}. Most likely one dataset is not there. Error is {e}"
@@ -613,6 +629,55 @@ class BaseAcquisition:
 
             return None
 
+    @staticmethod
+    def _get_values_from_nodes(
+        nodes: tuple[h5py.Group | None, ...],
+        n_frame: int | None,
+        keys: tuple[_Key, ...],
+        info_retrieve: str,
+        expected_unit: pint.Unit,
+    ) -> pint.Quantity | None:
+        """
+        Look for the values of 'keys' in 'nodes'.
+
+        Keys resolved from the bliss-tomo 'tomoconfig' are looked at first (on all nodes, arrays
+        first then scalars). The other keys (default keys) are only used as a fallback if none of
+        the 'tomoconfig' keys could be found.
+
+        :return: values as a pint.Quantity or None if no key could be found.
+        """
+        tomo_config_keys, fallback_keys = split_keys_by_priority(keys)
+
+        def look_for_keys(keys_to_check: tuple[str, ...]) -> pint.Quantity | None:
+            for node in nodes:
+                if node is None:
+                    continue
+                try:
+                    values, unit = BaseAcquisition._get_node_values_for_frame_array(
+                        node=node,
+                        n_frame=n_frame,
+                        keys=keys_to_check,
+                        info_retrieve=info_retrieve,
+                        expected_unit=expected_unit,
+                    )
+                except (ValueError, KeyError):
+                    pass
+                else:
+                    return values * unit
+            return None
+
+        if len(tomo_config_keys) > 0:
+            result = look_for_keys(tomo_config_keys)
+            if result is not None:
+                return result
+            _logger.warning(
+                f"Unable to find {info_retrieve} from the bliss-tomo 'tomoconfig' datasets {tomo_config_keys}. "
+                f"Will look at the fallback datasets {fallback_keys}."
+            )
+        if len(fallback_keys) > 0:
+            return look_for_keys(fallback_keys)
+        return None
+
     def _get_rotation_angle(self, root_node: h5py.Group, n_frame: int) -> pint.Quantity:
         """
         return the list of rotation angle for each frame.
@@ -623,23 +688,19 @@ class BaseAcquisition:
         if not isinstance(root_node, h5py.Group):
             raise TypeError("root_node is expected to be a h5py.Group")
 
-        for grp in (
-            self._get_positioners_node(root_node),
-            root_node,
-            self._get_measurement_node(root_node),
-        ):
-            try:
-                angles, unit = self._get_node_values_for_frame_array(
-                    node=grp,
-                    n_frame=n_frame,
-                    keys=keys_to_str_tuple(self.configuration.rotation_angle_keys),
-                    info_retrieve="rotation angle",
-                    expected_unit=_ureg.degree,
-                )
-            except (ValueError, KeyError):
-                pass
-            else:
-                return angles * unit
+        angles = self._get_values_from_nodes(
+            nodes=(
+                self._get_positioners_node(root_node),
+                root_node,
+                self._get_measurement_node(root_node),
+            ),
+            n_frame=n_frame,
+            keys=self.configuration.rotation_angle_keys,
+            info_retrieve="rotation angle",
+            expected_unit=_ureg.degree,
+        )
+        if angles is not None:
+            return angles
 
         mess = f"Unable to find rotation angle for {root_node.name}"
         if self.raise_error_if_issue:
@@ -651,19 +712,15 @@ class BaseAcquisition:
 
     def _get_sample_x(self, root_node, n_frame) -> pint.Quantity:
         """return the list of translation for each frame"""
-        for grp in self._get_positioners_node(root_node), root_node:
-            try:
-                x_tr, unit = self._get_node_values_for_frame_array(
-                    node=grp,
-                    n_frame=n_frame,
-                    keys=keys_to_str_tuple(self.configuration.sample_x_keys),
-                    info_retrieve="sample x translation",
-                    expected_unit=_ureg.mm,
-                )
-            except (ValueError, KeyError):
-                pass
-            else:
-                return x_tr * unit
+        translation = self._get_values_from_nodes(
+            nodes=(self._get_positioners_node(root_node), root_node),
+            n_frame=n_frame,
+            keys=self.configuration.sample_x_keys,
+            info_retrieve="sample x translation",
+            expected_unit=_ureg.mm,
+        )
+        if translation is not None:
+            return translation
 
         mess = f"Unable to find sample x for {root_node.name}"
         if self.raise_error_if_issue:
@@ -675,19 +732,15 @@ class BaseAcquisition:
 
     def _get_sample_y(self, root_node, n_frame) -> pint.Quantity:
         """return the list of translation for each frame"""
-        for grp in self._get_positioners_node(root_node), root_node:
-            try:
-                y_tr, unit = self._get_node_values_for_frame_array(
-                    node=grp,
-                    n_frame=n_frame,
-                    keys=keys_to_str_tuple(self.configuration.sample_y_keys),
-                    info_retrieve="sample y translation",
-                    expected_unit=_ureg.mm,
-                )
-            except (ValueError, KeyError):
-                pass
-            else:
-                return y_tr * unit
+        translation = self._get_values_from_nodes(
+            nodes=(self._get_positioners_node(root_node), root_node),
+            n_frame=n_frame,
+            keys=self.configuration.sample_y_keys,
+            info_retrieve="sample y translation",
+            expected_unit=_ureg.mm,
+        )
+        if translation is not None:
+            return translation
 
         mess = f"Unable to find sample y for {root_node.name}"
         if self.raise_error_if_issue:
@@ -697,21 +750,17 @@ class BaseAcquisition:
             _logger.warning(mess)
             return ([0] * n_frame) * _ureg.meter
 
-    def _get_translation_x(self, root_node, n_frame) -> pint.quantity:
+    def _get_translation_x(self, root_node, n_frame) -> pint.Quantity | None:
         """return the list of translation for each frame"""
-        for grp in self._get_positioners_node(root_node), root_node:
-            try:
-                x_tr, unit = self._get_node_values_for_frame_array(
-                    node=grp,
-                    n_frame=n_frame,
-                    keys=keys_to_str_tuple(self.configuration.translation_x_keys),
-                    info_retrieve="x base translation",
-                    expected_unit=_ureg.mm,
-                )
-            except (ValueError, KeyError):
-                pass
-            else:
-                return x_tr * unit
+        translation = self._get_values_from_nodes(
+            nodes=(self._get_positioners_node(root_node), root_node),
+            n_frame=n_frame,
+            keys=self.configuration.translation_x_keys,
+            info_retrieve="x base translation",
+            expected_unit=_ureg.mm,
+        )
+        if translation is not None:
+            return translation
 
         mess = f"Unable to find translation x for {root_node.name}"
         if self.raise_error_if_issue:
@@ -721,21 +770,17 @@ class BaseAcquisition:
             _logger.warning(mess)
             return ([0] * n_frame) * _ureg.meter
 
-    def _get_translation_y(self, root_node, n_frame) -> pint.quantity:
+    def _get_translation_y(self, root_node, n_frame) -> pint.Quantity | None:
         """return the list of translation for each frame"""
-        for grp in self._get_positioners_node(root_node), root_node:
-            try:
-                y_tr, unit = self._get_node_values_for_frame_array(
-                    node=grp,
-                    n_frame=n_frame,
-                    keys=keys_to_str_tuple(self.configuration.translation_y_keys),
-                    info_retrieve="y base translation",
-                    expected_unit=_ureg.mm,
-                )
-            except (ValueError, KeyError):
-                pass
-            else:
-                return y_tr * unit
+        translation = self._get_values_from_nodes(
+            nodes=(self._get_positioners_node(root_node), root_node),
+            n_frame=n_frame,
+            keys=self.configuration.translation_y_keys,
+            info_retrieve="y base translation",
+            expected_unit=_ureg.mm,
+        )
+        if translation is not None:
+            return translation
 
         mess = f"Unable to find translation y for {root_node.name}"
         if self.raise_error_if_issue:
@@ -748,20 +793,16 @@ class BaseAcquisition:
     @staticmethod
     def get_translation_z_frm(
         root_node, n_frame: int, configuration: H52nxModel
-    ) -> pint.Quantity:
-        for grp in BaseAcquisition._get_positioners_node(root_node), root_node:
-            try:
-                z_tr, unit = BaseAcquisition._get_node_values_for_frame_array(
-                    node=grp,
-                    n_frame=n_frame,
-                    keys=keys_to_str_tuple(configuration.translation_z_keys),
-                    info_retrieve="z translation",
-                    expected_unit=_ureg.mm,
-                )
-            except (ValueError, KeyError):
-                pass
-            else:
-                return z_tr * unit
+    ) -> pint.Quantity | None:
+        translation = BaseAcquisition._get_values_from_nodes(
+            nodes=(BaseAcquisition._get_positioners_node(root_node), root_node),
+            n_frame=n_frame,
+            keys=configuration.translation_z_keys,
+            info_retrieve="z translation",
+            expected_unit=_ureg.mm,
+        )
+        if translation is not None:
+            return translation
 
         mess = f"Unable to find translation z on node {root_node.name}"
         if configuration.raises_error:
@@ -771,7 +812,7 @@ class BaseAcquisition:
             _logger.warning(mess)
             return ([0] * n_frame) * _ureg.meter
 
-    def _get_translation_z(self, root_node, n_frame) -> pint.Quantity:
+    def _get_translation_z(self, root_node, n_frame) -> pint.Quantity | None:
         """return the list of translation z for each frame"""
         return self.get_translation_z_frm(
             root_node=root_node,
@@ -804,7 +845,7 @@ class BaseAcquisition:
         else:
             mess += "default value will be set. (0)"
             _logger.warning(mess)
-            return 0 * _ureg.second
+            return numpy.zeros(n_frame) * _ureg.second
 
     def get_axis_scale_types(self):
         """

nxtomomill/converter/hdf5/acquisition/standardacquisition.py

@@ -65,6 +65,10 @@ from .utils._keys import keys_to_str_tuple
 _ureg = pint.get_application_registry()
 _logger = logging.getLogger(__name__)
 
+_MAX_VDS_SOURCES_TO_RESOLVE = 100
+"""If a camera dataset virtual source relies on that many (or more) distinct files, skip
+resolving external links / virtual dataset sources for it."""
+
 
 __all__ = ["StandardAcquisition"]
 
@@ -346,20 +350,35 @@ class StandardAcquisition(BaseAcquisition):
         image_key_control = frame_type.to_image_key_control()
         self._image_key_control.extend([image_key_control.value] * n_frame)
 
-        try:
-            solved_camera_dataset_urls = resolve_link(
-                dataset_url=camera_dataset_url,
-                dataset=data_dataset,
-                dataset_link=data_dataset_link,
-                open_mode_for_reading=self.configuration.open_mode_for_reading,
-            )
-        except OSError as e:
-            # This can happen if one fine cannot be found. In test for example where we are only using the master file
-            # and low level bliss / tango .h5 files are not existing
+        n_vds_files = (
+            len({vs_info.file_name for vs_info in data_dataset.virtual_sources()})
+            if data_dataset.is_virtual
+            else 0
+        )
+        if n_vds_files >= _MAX_VDS_SOURCES_TO_RESOLVE:
             _logger.warning(
-                "Fail to solve camera dataset links and VDS. Error is %s", e
+                f"{camera_dataset_url.path()} relies on {n_vds_files} files "
+                f"(>= {_MAX_VDS_SOURCES_TO_RESOLVE}). Skip external link / VDS "
+                "resolution to avoid opening too many files."
             )
             solved_camera_dataset_urls = (camera_dataset_url,)
+        elif self.configuration.resolve_vds:
+            try:
+                solved_camera_dataset_urls = resolve_link(
+                    dataset_url=camera_dataset_url,
+                    dataset=data_dataset,
+                    dataset_link=data_dataset_link,
+                    open_mode_for_reading=self.configuration.open_mode_for_reading,
+                )
+            except OSError as e:
+                # This can happen if one fine cannot be found. In test for example where we are only using the master file
+                # and low level bliss / tango .h5 files are not existing
+                _logger.warning(
+                    "Fail to solve camera dataset links and VDS. Error is %s", e
+                )
+                solved_camera_dataset_urls = (camera_dataset_url,)
+        else:
+            solved_camera_dataset_urls = (camera_dataset_url,)
 
         n_total_frame_solved = 0
         for solved_camera_dataset_url in solved_camera_dataset_urls:

nxtomomill/converter/hdf5/acquisition/tests/test_acquisition.py

@@ -3,6 +3,10 @@
 import os
 import tempfile
 
+import logging
+
+import h5py
+import numpy
 import pytest
 from silx.io.url import DataUrl
 
@@ -12,6 +16,7 @@ from nxtomomill.converter.hdf5.acquisition.baseacquisition import (
     get_dataset_name_from_motor,
 )
 from nxtomomill.io.config import TomoHDF5Config
+from nxtomomill.models.h52nx._context import _Key
 from nxtomomill.tests.datasets import GitlabDataset
 from nxtomomill import converter
 from nxtomo.application.nxtomo import NXtomo
@@ -52,6 +57,103 @@ def test_get_dataset_name_from_motor():
         get_dataset_name_from_motor(set_3, "rotation")
 
 
+@pytest.mark.parametrize("raises_error", (True, False))
+def test_translation_with_err_value(tmp_path, raises_error):
+    """
+    Test that translation datasets reporting an 'ERR' value are skipped:
+    the next valid key is used and, if none is valid, it behaves as if the
+    translation was not found (raises or default to 0).
+    """
+    file_path = os.path.join(tmp_path, "test.h5")
+    with HDF5File(file_path, mode="w") as h5f:
+        h5f["/entry/instrument/positioners/tx"] = "ERR"
+        h5f["/entry/instrument/positioners/ty"] = "ERR"
+        h5f["/entry/instrument/positioners/tz"] = "ERR"
+        h5f["/entry/instrument/positioners/sz"] = 2.0
+        h5f["/entry/instrument/positioners/sz"].attrs["units"] = "mm"
+
+    config = TomoHDF5Config()
+    config.raises_error = raises_error
+    config.translation_x_keys = ("tx",)
+    config.translation_y_keys = ("ty",)
+    config.translation_z_keys = ("tz", "sz")
+
+    url = DataUrl(file_path=file_path, data_path="/entry", scheme="silx")
+    std_acq = BaseAcquisition(
+        root_url=url,
+        configuration=config,
+        detector_sel_callback=None,
+        start_index=0,
+    )
+    with h5py.File(file_path, mode="r") as h5f:
+        root_node = h5f["/entry"]
+        # 'tz' reports 'ERR': fall back to 'sz'
+        z_tr = std_acq._get_translation_z(root_node=root_node, n_frame=1)
+        assert z_tr.to("mm").magnitude.tolist() == [2.0]
+
+        # no valid key: same behavior as a missing translation
+        if raises_error:
+            with pytest.raises(ValueError):
+                std_acq._get_translation_x(root_node=root_node, n_frame=1)
+            with pytest.raises(ValueError):
+                std_acq._get_translation_y(root_node=root_node, n_frame=1)
+        else:
+            x_tr = std_acq._get_translation_x(root_node=root_node, n_frame=1)
+            assert x_tr.magnitude.tolist() == [0]
+            y_tr = std_acq._get_translation_y(root_node=root_node, n_frame=1)
+            assert y_tr.magnitude.tolist() == [0]
+
+
+def test_tomo_config_keys_priority(tmp_path, caplog):
+    """
+    Test that keys resolved from the bliss-tomo 'tomoconfig' are looked at first (array then scalar)
+    and that the default keys are only used as fallback.
+    """
+    n_frame = 3
+    file_path = os.path.join(tmp_path, "test.h5")
+    with HDF5File(file_path, mode="w") as h5f:
+        # tomoconfig motor is static (scalar) while a default key records an array
+        h5f["/entry/instrument/positioners/real_sx"] = 1.0
+        h5f["/entry/instrument/positioners/samx"] = numpy.array([5.0, 6.0, 7.0])
+        # tomoconfig motor only exists in root_node while a default key exists in positioners
+        h5f["/entry/real_sy"] = numpy.array([1.0, 2.0, 3.0])
+        h5f["/entry/instrument/positioners/samy"] = numpy.array([5.0, 6.0, 7.0])
+        # tomoconfig motor doesn't exist: fallback on the default key
+        h5f["/entry/instrument/positioners/sz"] = numpy.array([5.0, 6.0, 7.0])
+
+    config = TomoHDF5Config()
+    config.sample_x_keys = (
+        _Key(dataset="real_sx", contexts=set(), resolved_from_tomo_config=True),
+        _Key(dataset="samx", contexts=set()),
+    )
+    config.sample_y_keys = (
+        _Key(dataset="real_sy", contexts=set(), resolved_from_tomo_config=True),
+        _Key(dataset="samy", contexts=set()),
+    )
+    config.translation_z_keys = (
+        _Key(dataset="real_tz", contexts=set(), resolved_from_tomo_config=True),
+        _Key(dataset="sz", contexts=set()),
+    )
+
+    url = DataUrl(file_path=file_path, data_path="/entry", scheme="silx")
+    std_acq = BaseAcquisition(
+        root_url=url,
+        configuration=config,
+        detector_sel_callback=None,
+        start_index=0,
+    )
+    with h5py.File(file_path, mode="r") as h5f:
+        root_node = h5f["/entry"]
+        sample_x = std_acq._get_sample_x(root_node=root_node, n_frame=n_frame)
+        assert sample_x.magnitude.tolist() == [1.0] * n_frame
+        sample_y = std_acq._get_sample_y(root_node=root_node, n_frame=n_frame)
+        assert sample_y.magnitude.tolist() == [1.0, 2.0, 3.0]
+        with caplog.at_level(logging.WARNING):
+            z_tr = std_acq._get_translation_z(root_node=root_node, n_frame=n_frame)
+        assert z_tr.magnitude.tolist() == [5.0, 6.0, 7.0]
+        assert "Will look at the fallback datasets" in caplog.text
+
+
 def test_frame_flips(tmp_path, monkeypatch):
     # make sure the result is obtained by using the "instrument/{active_config_tomo_detector}/data_axes" path.
     monkeypatch.setattr(

nxtomomill/converter/hdf5/acquisition/utils/_context.py

@@ -94,6 +94,7 @@ def update_config_keys_from_tomo_config_context(
                         _Key(
                             dataset=real_dataset_name,
                             contexts=key.contexts - {Proxy.TOMO_CONFIG},
+                            resolved_from_tomo_config=True,
                         )
                     )
             return tuple(candidates)
@@ -163,6 +164,10 @@ class MissingValue(ValueError):
     """Raised if a dataset contains 'DIS' - not saved"""
 
 
+class InvalidValue(ValueError):
+    """Raised if a dataset contains 'ERR' - value could not be read from the hardware"""
+
+
 def read_key(
     key: str,
     node: h5py.Group,
@@ -210,6 +215,9 @@ def read_key(
         # skip values containing '*DIS*'
         if isinstance(values, str) and values == "*DIS*":
             raise MissingValue(f"dataset {dataset_name} has not been recorded")
+        # dataset reports an 'ERR' value if the hardware failed to record it
+        if isinstance(values, str) and values == "ERR":
+            raise InvalidValue(f"dataset {dataset_name} reports an 'ERR' value")
 
     first_dataset = dataset_names[0]
     result_unit = dataset_units[first_dataset] or expected_unit

nxtomomill/converter/hdf5/acquisition/utils/_keys.py

@@ -8,3 +8,22 @@ def keys_to_str_tuple(keys: tuple[_Key]) -> tuple[str]:
         if not isinstance(key, _Key):
             raise TypeError(f"key should be an instance of {_Key}. Got {type(key)}")
     return tuple([key.dataset for key in keys])
+
+
+def split_keys_by_priority(
+    keys: tuple[_Key, ...],
+) -> tuple[tuple[str, ...], tuple[str, ...]]:
+    """
+    Split keys between the ones resolved from the bliss-tomo 'tomoconfig' (to be looked at first)
+    and the fallback ones (default keys).
+    """
+    for key in keys:
+        if not isinstance(key, _Key):
+            raise TypeError(f"key should be an instance of {_Key}. Got {type(key)}")
+    tomo_config_keys = tuple(
+        key.dataset for key in keys if key.resolved_from_tomo_config
+    )
+    fallback_keys = tuple(
+        key.dataset for key in keys if not key.resolved_from_tomo_config
+    )
+    return tomo_config_keys, fallback_keys

nxtomomill/converter/hdf5/hdf5converter.py

@@ -146,6 +146,7 @@ class _H5ToNxConverter(BaseConverter):
         self._detector_sel_callback = detector_sel_callback
         self._acquisitions = []
         self._entries_created = []
+        self._conversion_errors: list[tuple[str, Exception]] = []
         self._z_series_v2_v3: list[list[ZSeriesBaseAcquisition]] = []
         # bliss z-series for version 2 and 3. Can be used for post-processing
         self.preprocess()
@@ -176,6 +177,11 @@ class _H5ToNxConverter(BaseConverter):
     def acquisitions(self):
         return self._acquisitions
 
+    @property
+    def has_failed_acquisitions(self) -> bool:
+        """True if at least one acquisition failed to be converted (and the error was not raised, see 'raises_error')"""
+        return len(self._conversion_errors) > 0
+
     def preprocess(self):
         self._preprocess_urls()
         self._check_conversion_is_possible()
@@ -311,6 +317,7 @@ class _H5ToNxConverter(BaseConverter):
                         exc_info=e,
                     )
                     acquisition_to_nxtomo[acquisition] = None
+                    self._conversion_errors.append((root_location, e))
             else:
                 res.extend(new_entries)
                 acquisition_to_nxtomo[acquisition] = new_entries