nxtomomill 2.2.0.dev1__tar.gz → 2.2.0.dev2__tar.gz

{nxtomomill-2.2.0.dev1/nxtomomill.egg-info → nxtomomill-2.2.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nxtomomill
-Version: 2.2.0.dev1
+Version: 2.2.0.dev2
 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: 

{nxtomomill-2.2.0.dev1 → nxtomomill-2.2.0.dev2}/nxtomomill/app/h52nx.py

@@ -10,7 +10,9 @@ For a complete tutorial you can have a look at: :ref:`Tomoh52nx`
 """
 
 import argparse
+import cProfile
 import logging
+import os
 
 from tqdm import tqdm
 
@@ -331,12 +333,35 @@ def main(argv):
         "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:
@@ -355,6 +380,15 @@ def main(argv):
                 input_callback=None,
                 detector_sel_callback=callback_det_sel,
             )
-            converter.convert()
+            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-2.2.0.dev1 → nxtomomill-2.2.0.dev2}/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,7 +32,8 @@ 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 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()
@@ -302,6 +305,12 @@ class BaseAcquisition:
                 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(
@@ -410,10 +419,11 @@ class BaseAcquisition:
                         # skip values containing '*DIS*'
                         continue
                     except InvalidValue:
-                        # dataset reports an 'ERR' value: let it propagate, the
-                        # caller decides how to handle it (e.g. translations
-                        # fall back to None instead of trying other keys)
-                        raise
+                        # 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}"
@@ -619,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.
@@ -629,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:
@@ -657,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:
@@ -681,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:
@@ -705,24 +752,15 @@ class BaseAcquisition:
 
     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 InvalidValue:
-                _logger.error(
-                    f"translation x reports an 'ERR' value for {root_node.name}. Translation x will be set to None."
-                )
-                return None
-            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:
@@ -734,24 +772,15 @@ class BaseAcquisition:
 
     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 InvalidValue:
-                _logger.error(
-                    f"translation y reports an 'ERR' value for {root_node.name}. Translation y will be set to None."
-                )
-                return None
-            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:
@@ -765,24 +794,15 @@ class BaseAcquisition:
     def get_translation_z_frm(
         root_node, n_frame: int, configuration: H52nxModel
     ) -> pint.Quantity | None:
-        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 InvalidValue:
-                _logger.error(
-                    f"translation z reports an 'ERR' value for {root_node.name}. Translation z will be set to None."
-                )
-                return None
-            except (ValueError, KeyError):
-                pass
-            else:
-                return z_tr * unit
+        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:

{nxtomomill-2.2.0.dev1 → nxtomomill-2.2.0.dev2}/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,7 +350,19 @@ class StandardAcquisition(BaseAcquisition):
         image_key_control = frame_type.to_image_key_control()
         self._image_key_control.extend([image_key_control.value] * n_frame)
 
-        if self.configuration.resolve_vds:
+        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(
+                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,

{nxtomomill-2.2.0.dev1 → nxtomomill-2.2.0.dev2}/nxtomomill/converter/hdf5/acquisition/tests/test_acquisition.py

@@ -3,7 +3,10 @@
 import os
 import tempfile
 
+import logging
+
 import h5py
+import numpy
 import pytest
 from silx.io.url import DataUrl
 
@@ -13,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
@@ -56,20 +60,80 @@ def test_get_dataset_name_from_motor():
 @pytest.mark.parametrize("raises_error", (True, False))
 def test_translation_with_err_value(tmp_path, raises_error):
     """
-    Test that translation x, y and z are set to None (instead of failing)
-    when the corresponding dataset reports an 'ERR' value.
+    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",)
+    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(
@@ -80,9 +144,14 @@ def test_translation_with_err_value(tmp_path, raises_error):
     )
     with h5py.File(file_path, mode="r") as h5f:
         root_node = h5f["/entry"]
-        assert std_acq._get_translation_x(root_node=root_node, n_frame=1) is None
-        assert std_acq._get_translation_y(root_node=root_node, n_frame=1) is None
-        assert std_acq._get_translation_z(root_node=root_node, n_frame=1) is None
+        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):

{nxtomomill-2.2.0.dev1 → nxtomomill-2.2.0.dev2}/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)

nxtomomill-2.2.0.dev2/nxtomomill/converter/hdf5/acquisition/utils/_keys.py

@@ -0,0 +1,29 @@
+"""A set of utils related to keys management"""
+
+from .....models.h52nx._context import _Key
+
+
+def keys_to_str_tuple(keys: tuple[_Key]) -> tuple[str]:
+    for key in keys:
+        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-2.2.0.dev2/nxtomomill/converter/hdf5/tests/test_err_handling.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+import os
+
+import h5py
+import numpy
+import pytest
+
+from nxtomo import NXtomo
+from nxtomomill.models.h52nx import H52nxModel
+from nxtomomill.converter.hdf5.hdf5converter import from_h5_to_nx
+from nxtomomill.tests.datasets import GitlabDataset
+
+
+@pytest.fixture()
+def dataset_with_err():
+    dataset_path = (
+        "h5_datasets/handling_ERR/15.12um_A327_lung_overview__TA2_REF_B_000_0001.h5"
+    )
+    source_file = GitlabDataset.get_dataset(dataset_path)
+    if source_file is None:
+        raise FileNotFoundError(f"Unable to download {dataset_path}")
+    return source_file
+
+
+def test_err_translation_fallback(tmp_path, dataset_with_err):
+    """
+    Make sure that if a translation candidate reports an 'ERR' value
+    ('mrsz') the next valid candidate ('sz') is used.
+    """
+    with h5py.File(dataset_with_err, mode="r") as h5f:
+        assert h5f["4.1/instrument/positioners/mrsz"][()] == b"ERR"
+        expected_z = h5f["4.1/instrument/positioners/sz"][()]
+
+    output_file = os.path.join(tmp_path, "output.nx")
+    model = H52nxModel(
+        input_file=dataset_with_err,
+        output_file=output_file,
+        single_file=True,
+    )
+    from_h5_to_nx(configuration=model)
+    assert os.path.exists(output_file)
+
+    nxtomo = NXtomo().load(file_path=output_file, data_path="entry0000")
+    # ESRF z axis is stored as the NXtomo (McStas) y axis
+    y_translation = nxtomo.sample.y_translation
+    assert y_translation is not None
+    numpy.testing.assert_allclose(y_translation.to("mm").magnitude, expected_z)

{nxtomomill-2.2.0.dev1 → nxtomomill-2.2.0.dev2}/nxtomomill/converter/hdf5/tests/test_h52nx_utils.py

@@ -97,15 +97,19 @@ def test_update_config_keys_from_tomo_config_context():
     # the real (per-frame) motor name is tried first, the bliss alias (static / scalar value) is
     # kept as a fallback in case the real motor name doesn't exist in a given (sub-)scan.
     assert model.sample_x_keys == (
-        _Key(dataset="real_sx", contexts=set()),
-        _Key(dataset="alias_sx", contexts=set()),
+        _Key(dataset="real_sx", contexts=set(), resolved_from_tomo_config=True),
+        _Key(dataset="alias_sx", contexts=set(), resolved_from_tomo_config=True),
     )
     assert model.sample_y_keys == (
-        _Key(dataset="real_sy+real_ty", contexts=set()),
-        _Key(dataset="alias_sy+alias_ty", contexts=set()),
+        _Key(dataset="real_sy+real_ty", contexts=set(), resolved_from_tomo_config=True),
+        _Key(
+            dataset="alias_sy+alias_ty", contexts=set(), resolved_from_tomo_config=True
+        ),
     )
     # when tomo_config only registered a single name there is nothing to fall back to: no duplicate
-    assert model.valid_camera_names == (_Key(dataset="single_su", contexts=set()),)
+    assert model.valid_camera_names == (
+        _Key(dataset="single_su", contexts=set(), resolved_from_tomo_config=True),
+    )
 
 
 def test_update_config_keys_from_beamline_context():