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

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/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/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/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/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/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/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/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():

nxtomomill/converter/hdf5/tests/test_hdf5converter.py

@@ -27,6 +27,7 @@ from nxtomomill.converter.hdf5.utils import (
     get_default_output_file,
 )
 from nxtomomill.models.h52nx import H52nxModel
+import nxtomomill.converter.hdf5.acquisition.standardacquisition as standardacquisition_module
 
 from tomoscan.scans.nxtomoscan import NXtomoScan
 
@@ -1415,6 +1416,49 @@ def test_id16a_use_case(tmp_path):
         transformation.transformation_values.magnitude == numpy.array([0.0])
 
 
+def test_creator_and_creator_version_are_saved(tmp_path):
+    """
+    Test that each NXtomo entry created by h52nx records the nxtomomill
+    version used to create it, as 'creator' / 'creator_version' attributes
+    on the NXtomo entry group itself.
+    """
+    import nxtomomill
+
+    folder = tmp_path / "output_test_creator_and_creator_version_are_saved"
+    folder.mkdir()
+    bliss_mock = MockBlissAcquisition(
+        n_sample=1,
+        n_sequence=1,
+        n_scan_per_sequence=2,
+        n_darks=1,
+        n_flats=1,
+        with_nx_detector_attr=True,
+        output_dir=folder,
+        detector_name="pcolinux",
+        create_tomo_config=False,
+    )
+    sample = bliss_mock.samples[0]
+
+    config = TomoHDF5Config()
+    config.input_file = sample.sample_file
+    config.output_file = str(tmp_path / "output.nx")
+    config.single_file = True
+    config.sample_x_keys = ("sx",)
+    config.sample_y_keys = ("sy",)
+    config.translation_x_keys = ("tx",)
+
+    converter.from_h5_to_nx(configuration=config)
+    assert os.path.exists(config.output_file)
+
+    with HDF5File(config.output_file, mode="r") as h5f:
+        entries = [name for name in h5f.keys() if "creator" in h5f[name].attrs]
+        assert len(entries) > 0
+        for entry in entries:
+            entry_grp = h5f[entry]
+            assert entry_grp.attrs["creator"] == "nxtomomill"
+            assert entry_grp.attrs["creator_version"] == nxtomomill.__version__
+
+
 def test_resolve_vds_option(tmp_path, monkeypatch):
     """
     Test that the 'resolve_vds' configuration option correctly enables /
@@ -1472,6 +1516,94 @@ def test_resolve_vds_option(tmp_path, monkeypatch):
     assert os.path.exists(config.output_file)
 
 
+def test_skip_vds_resolution_when_too_many_files(tmp_path, monkeypatch):
+    """
+    Test that VDS / external link resolution is skipped entirely - even with
+    'resolve_vds' enabled - when the camera dataset virtual source spans at
+    least '_MAX_VDS_SOURCES_TO_RESOLVE' distinct files.
+    """
+
+    n_chunks = 3
+    monkeypatch.setattr(
+        standardacquisition_module, "_MAX_VDS_SOURCES_TO_RESOLVE", n_chunks
+    )
+
+    folder = tmp_path / "output_test_skip_vds_resolution_when_too_many_files"
+    folder.mkdir()
+    bliss_mock = MockBlissAcquisition(
+        n_sample=1,
+        n_sequence=1,
+        n_scan_per_sequence=2,
+        n_darks=1,
+        n_flats=1,
+        with_nx_detector_attr=True,
+        output_dir=folder,
+        detector_name="pcolinux",
+        create_tomo_config=False,
+    )
+    sample = bliss_mock.samples[0]
+    sample_dir = os.path.dirname(sample.sample_file)
+
+    # turn every (plain) detector dataset into a virtual dataset spanning
+    # 'n_chunks' distinct files, like a real bliss acquisition chunked
+    # across many small files.
+    with h5py.File(sample.sample_file, "a") as h5f:
+        target_entries = [
+            entry_name
+            for entry_name, entry_grp in h5f.items()
+            if (det_grp := entry_grp.get("instrument/pcolinux")) is not None
+            and "data" in det_grp
+            and det_grp["data"].shape[0] >= n_chunks
+        ]
+        assert len(target_entries) > 0, "no suitable entry found"
+
+        for entry_name in target_entries:
+            det_grp = h5f[entry_name]["instrument/pcolinux"]
+            original_data = det_grp["data"][()]
+            del det_grp["data"]
+            n_frames = original_data.shape[0]
+            boundaries = numpy.linspace(0, n_frames, n_chunks + 1, dtype=int)
+            layout = h5py.VirtualLayout(
+                shape=original_data.shape, dtype=original_data.dtype
+            )
+            for i in range(n_chunks):
+                start, stop = boundaries[i], boundaries[i + 1]
+                chunk_file = os.path.join(sample_dir, f"{entry_name}_det_chunk_{i}.h5")
+                with h5py.File(chunk_file, "w") as chunk_h5:
+                    chunk_h5.create_dataset("data", data=original_data[start:stop])
+                with h5py.File(chunk_file, "r") as chunk_h5:
+                    layout[start:stop] = h5py.VirtualSource(
+                        path_or_dataset=chunk_h5["data"]
+                    )
+            det_grp.create_virtual_dataset("data", layout)
+
+    call_counter = {"n": 0}
+    original_resolve_link = standardacquisition_module.resolve_link
+
+    def _counting_resolve_link(*args, **kwargs):
+        call_counter["n"] += 1
+        return original_resolve_link(*args, **kwargs)
+
+    monkeypatch.setattr(
+        standardacquisition_module, "resolve_link", _counting_resolve_link
+    )
+
+    config = TomoHDF5Config()
+    config.input_file = sample.sample_file
+    config.output_file = str(tmp_path / "output.nx")
+    config.single_file = True
+    # explicitly enabled: the file-count threshold must override it
+    config.resolve_vds = True
+    config.sample_x_keys = ("sx",)
+    config.sample_y_keys = ("sy",)
+    config.translation_x_keys = ("tx",)
+
+    converter.from_h5_to_nx(configuration=config)
+
+    assert call_counter["n"] == 0
+    assert os.path.exists(config.output_file)
+
+
 def test_single_file_and_overwrite_from_cli(tmp_path):
     """
     Test that the `--single-file` and `--overwrite` options provided from

nxtomomill/io/config/confighandler.py

@@ -8,11 +8,11 @@ from __future__ import annotations
 
 import logging
 import os
-from nxtomomill.utils._os import abspath
 
 from nxtomomill.converter.hdf5.utils import get_default_output_file
 
 from nxtomomill.models.h52nx.h52nx import H52nxModel
+from nxtomomill.utils._os import abspath
 
 _logger = logging.getLogger(__name__)
 

nxtomomill/models/dx2nx.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 from nxtomo.nxobject.nxdetector import FieldOfView
+from nxtomomill.utils._os import abspath
 from .base.general_section import GeneralSection
 from pydantic import (
     Field,
@@ -57,6 +58,14 @@ class DX2nxModel(GeneralSection):
     )
     energy: float | None = Field(default=None, description="Energy in keV")
 
+    @field_validator(
+        "input_file",
+        mode="before",
+    )
+    @classmethod
+    def cast_input_file_to_abspath(cls, value: str) -> str:
+        return abspath(value)
+
     @field_validator(
         "field_of_view",
     )

nxtomomill/models/edf2nx/general_section.py

@@ -83,9 +83,12 @@ class GeneralSection(_GeneralSectionBase):
         mode="plain",
     )
     @classmethod
-    def cast_to_tuple(cls, value: tuple[str, ...] | str | None) -> tuple[str]:
-        if isinstance(value, tuple):
-            return value
+    def cast_to_tuple(
+        cls, value: tuple[str, ...] | list[str] | str | None
+    ) -> tuple[str]:
+        if isinstance(value, (tuple, list)):
+            # a list is obtained if the configuration went through a json serialization for example
+            return tuple(value)
         value = filter_str_def(value)
         return convert_str_to_tuple(value) or ()
 

nxtomomill/models/edf2nx/unit_section.py

@@ -63,6 +63,9 @@ class UnitSection(BaseModel):
     )
     @classmethod
     def cast_to_pint_unit(cls, value: str | FieldOfView) -> pint.Unit | None:
+        if value is None:
+            # pint >= 0.26.2 casts None to 'dimensionless'
+            raise TypeError("unit cannot be None")
         if value in ("kiloelectron_volt", "kev"):
             return _ureg.keV
         if value == "milliampere":

nxtomomill/models/h52nx/_context.py

@@ -53,6 +53,8 @@ _CONTEXT_CLASSES = {Proxy, Beamline}
 class _Key(BaseModel):
     dataset: str
     contexts: set[_CONTEXT]
+    resolved_from_tomo_config: bool = False
+    """True if the dataset name has been resolved from the bliss-tomo 'tomoconfig'. Those keys have priority over the other (fallback) keys."""
 
     @field_validator(
         "dataset",

nxtomomill/models/h52nx/general_section.py

@@ -12,6 +12,7 @@ from nxtomomill.models.utils import (
     convert_str_to_bool,
     convert_str_to_tuple,
 )
+from nxtomomill.utils._os import abspath
 from ..base.general_section import GeneralSection as _GeneralSectionBase
 
 
@@ -159,7 +160,10 @@ class GeneralSection(_GeneralSectionBase):
     )
     @classmethod
     def cast_general_section_to_str(cls, value: str | None) -> str | None:
-        return filter_str_def(value)
+        value = filter_str_def(value)
+        if not value:
+            return value
+        return abspath(value)
 
     @field_validator(
         "no_input",

nxtomomill/models/h52nx/keys_section.py

@@ -17,6 +17,9 @@ def _cast_keys_section_to_tuple(value):
     if isinstance(value, str):
         # convert "sa, id16a:sx" to ("sa", "id16a:sx")
         value: tuple = convert_str_to_tuple(value)
+    elif isinstance(value, list):
+        # a list is obtained if the configuration went through a json serialization for example
+        value = tuple(value)
 
     def invalid_type():
         raise TypeError(

nxtomomill/models/tests/test_edf2nx_model.py

@@ -289,3 +289,15 @@ def test_TomoEDFConfig_setters():
 
     detector_section_dict = config_dict["DETECTOR_SECTION"]
     assert detector_section_dict["field_of_view"] == FieldOfView.HALF.value
+
+
+def test_edf2nx_model_json_round_trip():
+    """
+    Make sure the configuration can be loaded back once dumped to json (tuples are converted to lists).
+    """
+    import json
+
+    config = EDF2nxModel()
+    as_json = json.loads(json.dumps(config.to_nested_model().model_dump(), default=str))
+    assert isinstance(as_json["general_section"]["patterns_to_ignores"], list)
+    assert EDF2nxModel.from_dict(as_json) == config

nxtomomill/models/tests/test_h52nx_model.py

@@ -26,6 +26,7 @@ from nxtomomill.models.h52nx.extra_params_section import (
     ExtraParamsSection,
 )
 from nxtomomill.converter.hdf5.acquisition.utils._keys import _Key
+from nxtomomill.utils._os import abspath
 
 from nxtomomill.tests.resources import h52nx_config_files as _h52nx_config_files
 from configparser import ConfigParser
@@ -67,7 +68,7 @@ def test_moving_to_pydantic_modified_config_file():
 
     config = H52nxModel.from_cfg_file(ref_file)
     # general section
-    assert config.input_file == "input_file.h5"
+    assert config.input_file == abspath("input_file.h5")
     assert config.output_file == "output_file.nx"
     assert config.overwrite is True
     assert config.file_extension is FileExtension.H5
@@ -226,7 +227,7 @@ def test_generate_default_hdf5_config():
 
     # check input and output file
     general_information = output["GENERAL_SECTION"]
-    assert general_information["input_file"] == "toto.h5"
+    assert general_information["input_file"] == abspath("toto.h5")
     assert general_information["output_file"] == "toto.nx"
 
 
@@ -333,3 +334,15 @@ def test_hdf5config_to_and_from_cfg_file(tmp_path):
     assert os.path.exists(file_path)
     loaded_config = H52nxModel.from_cfg_file(file_path=file_path)
     assert isinstance(loaded_config, H52nxModel)
+
+
+def test_h52nx_model_json_round_trip():
+    """
+    Make sure the configuration can be loaded back once dumped to json (tuples are converted to lists).
+    """
+    import json
+
+    config = H52nxModel()
+    as_json = json.loads(json.dumps(config.to_nested_model().model_dump(), default=str))
+    assert isinstance(as_json["keys_section"]["valid_camera_names"], list)
+    assert H52nxModel.from_dict(as_json) == config

nxtomomill/utils/flat_reducer.py

@@ -135,9 +135,9 @@ class __RefsDarks:
     ):
         self.dict_or_file_name = dict_or_file_name
         self.entry_name = entry_name
+        self._open_mode_for_reading = open_mode_for_reading
         self.flat_image, self.flat_current = self._take_image_and_meta("flat")
         self.dark_image, self.dark_current = self._take_image_and_meta("dark")
-        self._open_mode_for_reading = open_mode_for_reading
 
     def _take_image_and_meta(self, what) -> tuple:
         """

{nxtomomill-2.2.0.dev1.dist-info → nxtomomill-2.2.0.dev2.dist-info}/METADATA

@@ -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.dist-info → nxtomomill-2.2.0.dev2.dist-info}/RECORD

@@ -13,7 +13,7 @@ nxtomomill/app/edfconfig.py,sha256=TJDQfkeIBX1Rk13HBl1otdKB8uJwqAyKuFvhmtti3Kg,1
 nxtomomill/app/fluo2nx.py,sha256=mI8m18rQ9qOuY6CPIKoWJRaIuu4jgI2Z65Fi1P03FeI,4524
 nxtomomill/app/fluoconfig.py,sha256=M2b6pd8HmtcLx2wC0NcQbjXB2l550JuQap16JWhVQss,948
 nxtomomill/app/fscan2nx.py,sha256=uejEHirz6TDAvh-blkrORsMlx8ZW1MRGoxj8dtLwhlw,2363
-nxtomomill/app/h52nx.py,sha256=3Kv8W_dtC9-Ns5vTWok7Pd563BOhirCsfZn1KGAzdDI,11938
+nxtomomill/app/h52nx.py,sha256=qHLrT9SgkBtYtRogUdKWw8mvdpy1aI24bA9ZBujyWNM,13193
 nxtomomill/app/h5config.py,sha256=OpRLjwGlDbnHmh8W_fCU-JXAjts2GOcrfHu5I4oLCMk,1527
 nxtomomill/app/nxcopy.py,sha256=KknTJ0r61erBzQ83i7OJkFgTT1bH8FHo0llfbj0TzPk,2477
 nxtomomill/app/patch_nx.py,sha256=oXMevqyYe1ZS3ylYz6w8jYfu8_YfdNJLkeAMv7OaT9E,9839
@@ -58,14 +58,14 @@ nxtomomill/converter/hdf5/utils.py,sha256=uS8HymNSwMEWYvhD1yUxkco7xi41LAeG1pNXFs
 nxtomomill/converter/hdf5/acquisition/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nxtomomill/converter/hdf5/acquisition/_bliss_activeconfig.py,sha256=mgC-apxxu6PuVmLnve3W619LMkKnu9weWPTVbgvQrRQ,943
 nxtomomill/converter/hdf5/acquisition/backandforth.py,sha256=PbhoELpvfHRYvl25GFnhyGjf6L42UV8uxYcrXHZ4Wxk,677
-nxtomomill/converter/hdf5/acquisition/baseacquisition.py,sha256=en_kOFU7Oa6aJxr71Jce7y9gnNzz4tRqFfs9nZAsvGM,34330
+nxtomomill/converter/hdf5/acquisition/baseacquisition.py,sha256=mclCgRPxUbi5bme3SdDu8bnlNcI05ZKSZRBYLqvF3H0,35041
 nxtomomill/converter/hdf5/acquisition/blisstomoconfig.py,sha256=9-LxXeyNPDUPLybwJ48o7XHx8ggqvy-K-FnhJ0qie-c,6953
 nxtomomill/converter/hdf5/acquisition/multitomo.py,sha256=N5fHVwKSqqHPDEycRhJ0mtXLijvxCHwY_IiDtQ5SFq4,19280
 nxtomomill/converter/hdf5/acquisition/pcotomoacquisition.py,sha256=1CgX1rFzekIckUlT8u2eb-xw5wCIF3TOoesmIg1y1oc,619
-nxtomomill/converter/hdf5/acquisition/standardacquisition.py,sha256=EklnKyvKn_WjDn9WulQ4kM8EDpiDDxwvdAbXwBfHzTM,62515
+nxtomomill/converter/hdf5/acquisition/standardacquisition.py,sha256=pcDoq8HlC-HGwUeRQC3cwJRO7FdQ9gIjnt6nNMaiLcs,63260
 nxtomomill/converter/hdf5/acquisition/zseriesacquisition.py,sha256=15VZvPMqp6pluGXo2rRh5IVfbAegGMy2ByHo5doCeDM,10634
 nxtomomill/converter/hdf5/acquisition/tests/bliss_tomo_datasets.py,sha256=pcusczTBMttXRJGeEag4Uel6y8riWd981g-OVxW2M_o,874
-nxtomomill/converter/hdf5/acquisition/tests/test_acquisition.py,sha256=dWdbwjvg60J4d-U6pq3_e_GV_dTEt-6hekeDe2r7O58,4357
+nxtomomill/converter/hdf5/acquisition/tests/test_acquisition.py,sha256=_g0PHHcReRT2gD3IrMoLhiBP8G25IZm3uvW6qkYpBZI,7480
 nxtomomill/converter/hdf5/acquisition/tests/test_acquisition_utils.py,sha256=UTAq1J_c_cYNtfZdhBTqwCzu4h1gIdGwDWlyJNXQg3M,9271
 nxtomomill/converter/hdf5/acquisition/tests/test_back_and_forth.py,sha256=l2NbPcM21kdN0gGEC5xUHVsYE_tsS5AeZfa0idV3x8w,4573
 nxtomomill/converter/hdf5/acquisition/tests/test_bliss_tomo_config.py,sha256=sukeUc6P2Plg30hUeq26v15WcXN4zv2KfIX5LTF7RVo,3256
@@ -74,8 +74,8 @@ nxtomomill/converter/hdf5/acquisition/tests/test_legacy.py,sha256=EVj1s8NBVXQoAg
 nxtomomill/converter/hdf5/acquisition/tests/test_multitomo_zseries.py,sha256=wPUhG3VihCND_Uoq-yHec4qwpNQyzyb3qvzHPOOhfzQ,3654
 nxtomomill/converter/hdf5/acquisition/tests/test_multitomoacquisition.py,sha256=PCfpLhXvm8x3WU1d_pc57Ny4QpavNEPGy47BYaQ3oXc,7651
 nxtomomill/converter/hdf5/acquisition/utils/__init__.py,sha256=tc3O9HTgBxoG2hr2qIy41d9ARQBN1rPMb8Zo44eamHs,443
-nxtomomill/converter/hdf5/acquisition/utils/_context.py,sha256=eWk6PGdKl6WAJtRRCVydXCy-6Rd9dqQuDWHEYMtiIE8,9241
-nxtomomill/converter/hdf5/acquisition/utils/_keys.py,sha256=jQIjrL_WD_0o8KzqKBrba5o4hiBGf8H8MyVckVlyWJY,343
+nxtomomill/converter/hdf5/acquisition/utils/_context.py,sha256=Wfd5nM1RKA-5kgYdW_mMO7f611PPQtHObgzmOnHpETc,9301
+nxtomomill/converter/hdf5/acquisition/utils/_keys.py,sha256=vGbVJcW4qPKsJOtc91AYvSFaRNJR3wwLMjLQcJuhSS8,1001
 nxtomomill/converter/hdf5/acquisition/utils/_scan_type_finder.py,sha256=n3Vf3aCMwi6bD7LJlyojqk2JZTYgxDgaP5x9AB0ijv8,3695
 nxtomomill/converter/hdf5/acquisition/utils/bliss_scan_type.py,sha256=s72IPhbpU-lv79VshxDPzJMjRyaTIQPUFYbDIzol0R0,1378
 nxtomomill/converter/hdf5/acquisition/utils/detector.py,sha256=WHaHw7_082NL8p0J5ReI1yJ5faGmh_7hpHqbrD9bCR0,1926
@@ -84,13 +84,14 @@ nxtomomill/converter/hdf5/acquisition/utils/series.py,sha256=nIUcBSEIIsGAEHK11-D
 nxtomomill/converter/hdf5/acquisition/utils/timestamps.py,sha256=cvTi4Ol5DwA1u6st3sY8DNxq95jnivMrFF2VGxf7agc,461
 nxtomomill/converter/hdf5/post_processing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nxtomomill/converter/hdf5/post_processing/dark_flat_copy.py,sha256=nBbXT9r0mxlGI1la3pqT-g7pmpmvMSVCj0uBoZMenb8,9751
+nxtomomill/converter/hdf5/tests/test_err_handling.py,sha256=rSVSp5lL581t9M5CSGgMNOUJHpNucTJ_SgKUttkSjXY,1558
 nxtomomill/converter/hdf5/tests/test_frame_flip.py,sha256=0S0FmMM9RVj1UQNwCsXQyI_bwQ8hx6ORdl4-EsWUjf8,2330
-nxtomomill/converter/hdf5/tests/test_h52nx_utils.py,sha256=iPC52Ly5I8yH7hV2d-z39VDfC-hoIDINtTQC1X2aRIo,11806
-nxtomomill/converter/hdf5/tests/test_hdf5converter.py,sha256=izTJWIpxSG-F6Eh7c5msmsSlZVTo34ggJh6_akyigmk,59154
+nxtomomill/converter/hdf5/tests/test_h52nx_utils.py,sha256=QGAmTeaf9feqJvlWPXBbw_wjOChX0hWr8Kl5I2OfyoU,12002
+nxtomomill/converter/hdf5/tests/test_hdf5converter.py,sha256=0iSp-pDRElp3168Jm27lNG5mMrZ8q0Y9jq0cIS85PMU,64022
 nxtomomill/io/__init__.py,sha256=gxUEBT0A0o8kJJ19N4pIIYVTA-7TuvuJq2BEepqbrNQ,91
 nxtomomill/io/config/__init__.py,sha256=q1RV3iBYSqpV-r8H794YBXl_1DiA0KNZVWEmWpF04x4,348
 nxtomomill/io/config/configbase.py,sha256=pLPGV91Vwxuqidh7UnkWscXauPzsrNbAI9T7DJQHMEo,554
-nxtomomill/io/config/confighandler.py,sha256=6kSG01z0lqPJVGrUSHJj2MsBFe2N9X7UqRN_p871ufU,6475
+nxtomomill/io/config/confighandler.py,sha256=55bvQJNtlM1DIeDpfCjMrrofNxDP-h5zqQf0f0RC5V8,6475
 nxtomomill/io/config/dxconfig.py,sha256=33gYIWsr0R7qL8uY7IDoE6kUNuWHtWp3_tfaY6TSGJk,590
 nxtomomill/io/config/edfconfig.py,sha256=J04CZoDYkV3XZ-ZowNdyx5Lf8W1-QbAXKPnSPksqSLA,911
 nxtomomill/io/config/fluoconfig.py,sha256=R-Cy1pYROzqS9CDj3T9kO7m17oCgyazIPz2d8-BRZwY,933
@@ -100,7 +101,7 @@ nxtomomill/io/config/tests/test_confighandler.py,sha256=-O7tbbKI3n7lSbXfDxa-mwt1
 nxtomomill/io/tests/test_frame_group.py,sha256=P0weUFFwlNLhIDk4gpJsCrFSZ_mzF54SNNqjMVr_lhw,5719
 nxtomomill/io/tests/utils.py,sha256=z_-AVtX26c6gsmpDgol1RqXmbdzdaj2jMXY3wfx2UyI,1950
 nxtomomill/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nxtomomill/models/dx2nx.py,sha256=XoQ48YuSmVfuYeH8b0lgcV-rie4p-RCQO53juEXE5Pk,3136
+nxtomomill/models/dx2nx.py,sha256=QAP32N2BsAqDLHgmhRDgeoL_OP3Oi5t2HT26zVUHpck,3358
 nxtomomill/models/utils.py,sha256=VB34e3AXfcFka7OL-eeP6byKBiSP_b4dNiqBuclpgyU,3096
 nxtomomill/models/base/ConfigBase.py,sha256=6QZBVAdKIoarm0oMvmYFLL5AmldA-F76QP1p-Pp64j4,971
 nxtomomill/models/base/FrmFlatToNestedBase.py,sha256=HvvMSmZrCfH4HqTCJgr4Bv3_K8IQSRRoriT6tdHIWFk,1053
@@ -116,28 +117,28 @@ nxtomomill/models/edf2nx/__init__.py,sha256=btz-4hb-LOIodmLSSihq1FhbF0W7vGTcwt6j
 nxtomomill/models/edf2nx/dark_and_flat_section.py,sha256=AvgAxdMQ_EWlnR7h5nUeEYr1LyI7KjE0YaZsUf3YOL8,1711
 nxtomomill/models/edf2nx/detector_section.py,sha256=54K2Ezb1ktjs46kkfktcfRP9ptJaN1_VRyBMCWyD7bk,1372
 nxtomomill/models/edf2nx/edf2nx.py,sha256=RCTgD4Y_zbmiAjED8I1PqXymcYwZbd7EP416RNRMo7w,6696
-nxtomomill/models/edf2nx/general_section.py,sha256=wY2UIt9iswsFgNFTQHRDTvUkZ2cdH0779-eB1QaqWxM,5073
+nxtomomill/models/edf2nx/general_section.py,sha256=wCPxjCxeuy517QL2600BLqRm95sfW0swlKYrRDCFA0Y,5214
 nxtomomill/models/edf2nx/keys_section.py,sha256=H04pODXv0Wtun3Qbd3JFB7xXq58PIL_5wtUVPVkc4XY,2056
 nxtomomill/models/edf2nx/sample_section.py,sha256=wEPBuKIDwXTn84-oFahUOKZ-Em3Kpb6wmZJl7VaPNlk,1640
-nxtomomill/models/edf2nx/unit_section.py,sha256=nvxmHpDq0ClRmlRUQyfvy6PTwOlmCnpzrfR55q4CGPM,3903
+nxtomomill/models/edf2nx/unit_section.py,sha256=220wL2YT6XSw5M9kmp7IIMkU93_CawdxoA4gkSm03Gs,4039
 nxtomomill/models/fluo2nx/__init__.py,sha256=E0KmuFqL10lxFF2K7IBnsv8VpQYmNh-FQFESwNcN_4o,120
 nxtomomill/models/fluo2nx/fluo2nx.py,sha256=gWVNsytqyd6hIj6TffBRTObdj2Elvqf4ECVFhsHjr2o,3613
 nxtomomill/models/fluo2nx/general_section.py,sha256=JmfAmnWZJWsCbzR-cNOLi1gIUrKTb_hqWNDjnQdVcAk,2621
 nxtomomill/models/h52nx/FrameGroup.py,sha256=mjw-pQfNm_WVR10JkktVfK0-NK05Hf3cct3mKtCCyOI,9363
 nxtomomill/models/h52nx/__init__.py,sha256=F2B5npgvXjYWw3npIJsA_Jt0IyTeM8rsl_HBQYu8zJI,112
 nxtomomill/models/h52nx/_acquisitionstep.py,sha256=YFA0kmcKUUKv6Qi3GMdm26RlT00BJ_afBy-v97VAnOU,2206
-nxtomomill/models/h52nx/_context.py,sha256=Z_ofzqAFMyrjVQOXTnQw9PrzrU8iLNaV4OfSAG9YZKU,3549
+nxtomomill/models/h52nx/_context.py,sha256=OVVugpf1eRAt5hJDic2hWTDyeOTHr_iqJaCR46ITF08,3737
 nxtomomill/models/h52nx/entries_and_title_section.py,sha256=qEs2VGRf6Nciq3FupJUZCKpNA2ZGBeK694O_kDOWo1Y,4703
 nxtomomill/models/h52nx/extra_params_section.py,sha256=ZnxzwJVOjUqOd6ngmmrIb2xZVABfomBvKSELiT00Nmc,1547
 nxtomomill/models/h52nx/frame_type_section.py,sha256=U-akT0f8lOvzjOQ6ZuUSwy3-pYAYkiVXeY7bBtZ0o44,3716
-nxtomomill/models/h52nx/general_section.py,sha256=d9EujPhiMzSGIplo41XQthV7gzmk5iX57cXrn02x4JU,6891
+nxtomomill/models/h52nx/general_section.py,sha256=z69qLCEIFKa7xFdt1zcVmed_jZSRqLFzB7-T6CpCnPc,7010
 nxtomomill/models/h52nx/h52nx.py,sha256=4EwwMBQZBPQQ-um6rCgk5uhv-S01zjDzDVo1us2WT88,8603
-nxtomomill/models/h52nx/keys_section.py,sha256=Hpu0pUrUyI3fuwZ1y5j-qdxpzDNQXQZCwdcWG6nNtL4,5923
+nxtomomill/models/h52nx/keys_section.py,sha256=FFGb39DWlLaN-XOcAEOOgIBc64RdETjugtH8X68ACcs,6082
 nxtomomill/models/h52nx/multitomo_section.py,sha256=aOM3oxopLjlBFzs0UXInxbkZ_NOw0QXS0BGI_2uhzLk,1819
 nxtomomill/models/tests/test_context.py,sha256=w0A02DXL5hEhw-imMleSeue7ejqotuu_qr0aUJrEhxg,1711
-nxtomomill/models/tests/test_edf2nx_model.py,sha256=SdYov4dX8fN4D8DfFN8EQjuU3MQjEyKMl6Udve5lg3g,11385
+nxtomomill/models/tests/test_edf2nx_model.py,sha256=Tf8GaRkvVettIY_FO_br8KJ30LvTBWTkxV-6vfaQw_c,11812
 nxtomomill/models/tests/test_fluo2nx_model.py,sha256=v-_B0-2ZIt4wapKWjtTjNUEDBCbU2x-WtVDQGvvYms0,5247
-nxtomomill/models/tests/test_h52nx_model.py,sha256=5XgaM9HbWORPu0mpf9WRtEqdZTYinrfujdEVN8GwJn8,12736
+nxtomomill/models/tests/test_h52nx_model.py,sha256=K1o0q5QQpCbNwxTmi5G988nXnB9gY502SZS5MRYOugY,13215
 nxtomomill/models/tests/test_io_utils.py,sha256=ZvHx5XpVAx3C-3phFWwy0RFamtf98idt-bWTcpLljkU,1576
 nxtomomill/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nxtomomill/tests/datasets.py,sha256=hjEAtM2F6GNIJoE8VaX5cnAikWM5Wt12J-nRyTi14kY,344
@@ -151,7 +152,7 @@ nxtomomill/tests/utils/bliss.py,sha256=fslMDgGqssY_3KjlmkpaVhfqMpjqukI0QdOrH3-bE
 nxtomomill/tests/utils/dxfile.py,sha256=LSoBQtBBs8dOFvoJw0t0QpWsWVF_FrPeAKTTfAPyD6k,1892
 nxtomomill/utils/__init__.py,sha256=HiwjKOWdwZ9wV0F16HQcE1qUWCuk_rL_N2bsSIBZVwo,568
 nxtomomill/utils/_os.py,sha256=Mzz2_d4Inz7fmxZWl0wI03GQUb0oVo1soiX52Dkq49Y,368
-nxtomomill/utils/flat_reducer.py,sha256=J05n7rVzuwm3gybaaROF4HI0-EDaBREXM2_Wu6Jud68,12416
+nxtomomill/utils/flat_reducer.py,sha256=Ul-Gi3CYR0JU6tbWaFaZntJ7T-oRtjzYusQbwg0Zrps,12416
 nxtomomill/utils/h5pyutils.py,sha256=tLSnUfFp-A3RaL3YXu4b_deiToQKFi8xn45Cp0r_1Dw,8400
 nxtomomill/utils/hdf5.py,sha256=KuJdr3LnvA8eX17ECdwlPgVARZAf_8Z5xIJZx3Otplw,4983
 nxtomomill/utils/io.py,sha256=f3pdEqH2Fca5vl7xPry1cPp5yP4Tnas8DGbfPqz-94Q,3158
@@ -162,9 +163,9 @@ nxtomomill/utils/tests/test_flat_reducer.py,sha256=kMatWooQ5vRcsf03rkMDEEdgkmjv9
 nxtomomill/utils/tests/test_h5pyutils.py,sha256=L9h0-m68rvLCWIFzK71K3Hg_9YH-_PynEsPghSkz5qY,8890
 nxtomomill/utils/tests/test_nexus_utils.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nxtomomill/utils/tests/test_utils.py,sha256=D4I_r2Xux4pAc8E4lhi4BHA0-0kyiOqlU9JNnJGS3Es,53064
-nxtomomill-2.2.0.dev1.dist-info/licenses/LICENSE,sha256=3-51vily0513UmUtHb-gWYFOhge5Ldp8HTjIOPtIdBo,1257
-nxtomomill-2.2.0.dev1.dist-info/METADATA,sha256=XBd-CMot2l3Ou-AMxd-wJ4_hSghDRU3BdSppMXSZUxM,5318
-nxtomomill-2.2.0.dev1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-nxtomomill-2.2.0.dev1.dist-info/entry_points.txt,sha256=kZUAunNCjlk8gda1r07SPNRO9TR5rP0wVPa8-jVx5ts,56
-nxtomomill-2.2.0.dev1.dist-info/top_level.txt,sha256=FxntqOpZgeTW3KHuyJ7gjFwOcTSdNNIGex2gPf07-Vg,15
-nxtomomill-2.2.0.dev1.dist-info/RECORD,,
+nxtomomill-2.2.0.dev2.dist-info/licenses/LICENSE,sha256=3-51vily0513UmUtHb-gWYFOhge5Ldp8HTjIOPtIdBo,1257
+nxtomomill-2.2.0.dev2.dist-info/METADATA,sha256=1J8Des6wS0p8z_lMZB2-UXA9RBsW1C6S2LISFKo1IVY,5318
+nxtomomill-2.2.0.dev2.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+nxtomomill-2.2.0.dev2.dist-info/entry_points.txt,sha256=kZUAunNCjlk8gda1r07SPNRO9TR5rP0wVPa8-jVx5ts,56
+nxtomomill-2.2.0.dev2.dist-info/top_level.txt,sha256=FxntqOpZgeTW3KHuyJ7gjFwOcTSdNNIGex2gPf07-Vg,15
+nxtomomill-2.2.0.dev2.dist-info/RECORD,,

{nxtomomill-2.2.0.dev1.dist-info → nxtomomill-2.2.0.dev2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (84.0.0)
+Generator: setuptools (84.2.1)
 Root-Is-Purelib: true
 Tag: py3-none-any