nabu 2024.2.14__py3-none-any.whl → 2025.1.0__py3-none-any.whl

nabu/resources/utils.py

@@ -1,8 +1,9 @@
 from ast import literal_eval
 import numpy as np
+import pint
 from psutil import virtual_memory, cpu_count
-from pyunitsystem.metricsystem import MetricSystem
-from pyunitsystem.energysystem import EnergySI
+
+_ureg = pint.get_application_registry()
 
 
 def get_values_from_file(fname, n_values=None, shape=None, sep=None, any_size=False):
@@ -163,12 +164,17 @@ def get_quantities_and_units(string, sep=";"):
         value, unit = value_and_unit.split()
         val = float(value)
         # Convert to SI
-        try:
-            # handle metrics
-            conversion_factor = MetricSystem.from_str(unit).value
-        except ValueError:
-            # handle energies
-            conversion_factor = EnergySI.from_str(unit).value / EnergySI.KILOELECTRONVOLT.value
-
-        result[quantity_name] = val * conversion_factor
+        if unit.lower() == "kev":
+            current_unit = _ureg.keV
+        elif unit.lower() == "ev":
+            current_unit = _ureg.eV
+        else:
+            current_unit = _ureg(unit)
+        # handle energies (to move to keV)
+        if _ureg.keV.dimensionality == current_unit.dimensionality:
+            result[quantity_name] = (val * current_unit).to(_ureg.keV).magnitude
+        elif _ureg.meter.dimensionality == current_unit.dimensionality:
+            result[quantity_name] = (val * current_unit).to_base_units().magnitude
+        else:
+            raise ValueError(f"Cannot convert: {unit}")
     return result

nabu/stitching/alignment.py

@@ -1,13 +1,10 @@
+from enum import Enum
 import h5py
 import numpy
 from typing import Union
-from silx.utils.enum import Enum as _Enum
-from tomoscan.volumebase import VolumeBase
-from tomoscan.esrf.volume.hdf5volume import HDF5Volume
-from nabu.io.utils import DatasetReader
 
 
-class AlignmentAxis2(_Enum):
+class AlignmentAxis2(Enum):
     """Specific alignment named to help users orienting themself with specific name"""
 
     CENTER = "center"
@@ -15,7 +12,7 @@ class AlignmentAxis2(_Enum):
     RIGTH = "right"
 
 
-class AlignmentAxis1(_Enum):
+class AlignmentAxis1(Enum):
     """Specific alignment named to help users orienting themself with specific name"""
 
     FRONT = "front"
@@ -23,7 +20,7 @@ class AlignmentAxis1(_Enum):
     BACK = "back"
 
 
-class _Alignment(_Enum):
+class _Alignment(Enum):
     """Internal alignment to be used for 2D alignment"""
 
     LOWER_BOUNDARY = "lower boundary"
@@ -32,7 +29,7 @@ class _Alignment(_Enum):
 
     @classmethod
     def from_value(cls, value):
-        # cast the AlignmentAxis1 and AlignmentAxis2 values to fit the generic definition
+        # cast the AlignmentAxis1 and AlignmentAxis2 values to fit the generic definition.
         if value in ("front", "left", AlignmentAxis1.FRONT, AlignmentAxis2.LEFT):
             return _Alignment.LOWER_BOUNDARY
         elif value in ("back", "right", AlignmentAxis1.BACK, AlignmentAxis2.RIGTH):
@@ -40,7 +37,7 @@ class _Alignment(_Enum):
         elif value in (AlignmentAxis1.CENTER, AlignmentAxis2.CENTER):
             return _Alignment.CENTER
         else:
-            return super().from_value(value)
+            return super().__new__(cls, value)
 
 
 def align_frame(
@@ -106,7 +103,7 @@ def align_horizontally(data: numpy.ndarray, alignment: AlignmentAxis2, new_width
     :param HAlignment alignment: alignment strategy
     :param int new_width: output data width
     """
-    alignment = AlignmentAxis2.from_value(alignment).value
+    alignment = AlignmentAxis2(alignment).value
     return align_frame(
         data=data, alignment=alignment, new_aligned_axis_size=new_width, pad_mode=pad_mode, alignment_axis=1
     )
@@ -151,7 +148,7 @@ class PaddedRawData:
     @property
     def shape(self):
         if self._shape is None:
-            self._shape = tuple(
+            self._shape = tuple(  # noqa: C409
                 (
                     self._raw_data_shape[0],
                     numpy.sum(

nabu/stitching/config.py

@@ -1,8 +1,9 @@
+import pint
 from math import ceil
-from typing import Any, Iterable, Optional, Union, Sized
+from typing import Optional, Union
+from collections.abc import Iterable, Sized
 from dataclasses import dataclass
 import numpy
-from pyunitsystem.metricsystem import MetricSystem
 from nxtomo.paths import nxtomo
 from tomoscan.factory import Factory
 from tomoscan.identifier import VolumeIdentifier, ScanIdentifier
@@ -12,13 +13,14 @@ from ..pipeline.config_validators import (
     convert_to_bool,
 )
 from ..utils import concatenate_dict, convert_str_to_tuple
-from ..io.utils import get_output_volume
 from .overlap import OverlapStitchingStrategy
 from .utils.utils import ShiftAlgorithm
 from .definitions import StitchingType
 from .alignment import AlignmentAxis1, AlignmentAxis2
-from pyunitsystem.metricsystem import MetricSystem
 
+_ureg = pint.get_application_registry()
+
+# ruff: noqa: S105
 
 KEY_IMG_REG_METHOD = "img_reg_method"
 
@@ -128,6 +130,8 @@ SLURM_MODULES_TO_LOADS = "modules"
 
 SLURM_CLEAN_SCRIPTS = "clean_scripts"
 
+SLURM_JOB_NAME = "job_name"
+
 # normalization by sample
 
 NORMALIZATION_BY_SAMPLE_SECTION = "normalization_by_sample"
@@ -205,7 +209,7 @@ def _str_to_dict(my_str: Union[str, dict]):
 
 
 def _dict_to_str(ddict: dict):
-    return ";".join([f"{str(key)}={str(value)}" for key, value in ddict.items()])
+    return ";".join([f"{key!s}={value!s}" for key, value in ddict.items()])
 
 
 def str_to_shifts(my_str: Optional[str]) -> Union[str, tuple]:
@@ -218,7 +222,7 @@ def str_to_shifts(my_str: Optional[str]) -> Union[str, tuple]:
         if my_str == "":
             return None
         try:
-            shift = ShiftAlgorithm.from_value(my_str)
+            shift = ShiftAlgorithm(my_str)
         except ValueError:
             shifts_as_str = filter(None, my_str.replace(";", ",").split(","))
             return [float(shift) for shift in shifts_as_str]
@@ -235,8 +239,8 @@ def _valid_stitching_kernels_params(my_dict: Union[dict, str]):
         my_dict = _str_to_dict(my_str=my_dict)
 
     valid_keys = (KEY_THRESHOLD_FREQUENCY, KEY_SIDE)
-    for key in my_dict.keys():
-        if not key in valid_keys:
+    for key in my_dict:
+        if key not in valid_keys:
             raise KeyError(f"{key} is a unrecognized key")
     return my_dict
 
@@ -253,8 +257,8 @@ def _valid_shifts_params(my_dict: Union[dict, str]):
         KEY_LOW_PASS_FILTER,
         KEY_SIDE,
     )
-    for key in my_dict.keys():
-        if not key in valid_keys:
+    for key in my_dict:
+        if key not in valid_keys:
             raise KeyError(f"{key} is a unrecognized key")
     return my_dict
 
@@ -334,7 +338,7 @@ class NormalizationBySample:
 
     @method.setter
     def method(self, method: Union[Method, str]) -> None:
-        self._method = Method.from_value(method)
+        self._method = Method(method)
 
     @property
     def margin(self) -> int:
@@ -351,7 +355,7 @@ class NormalizationBySample:
 
     @side.setter
     def side(self, side: Union[SampleSide, str]):
-        self._side = SampleSide.from_value(side)
+        self._side = SampleSide(side)
 
     @property
     def width(self) -> int:
@@ -401,16 +405,16 @@ class NormalizationBySample:
             NORMALIZATION_BY_SAMPLE_WIDTH: self.width,
         }
 
-    def __eq__(self, __value: object) -> bool:
-        if not isinstance(__value, NormalizationBySample):
+    def __eq__(self, value: object, /) -> bool:
+        if not isinstance(value, NormalizationBySample):
             return False
         else:
-            return self.to_dict() == __value.to_dict()
+            return self.to_dict() == value.to_dict()
 
 
 @dataclass
 class SlurmConfig:
-    "configuration for slurm jobs"
+    """configuration for slurm jobs"""
 
     partition: str = ""  # note: must stay empty to make by default we don't use slurm (use by the  configuration file)
     mem: str = "128"
@@ -421,6 +425,7 @@ class SlurmConfig:
     clean_script: bool = ""
     n_tasks: int = 1
     n_cpu_per_task: int = 4
+    job_name: str = ""
 
     def __post_init__(self) -> None:
         # make sure either 'modules' or 'preprocessing_command' is provided
@@ -430,7 +435,7 @@ class SlurmConfig:
             )
 
     def to_dict(self) -> dict:
-        "dump configuration to dict"
+        """dump configuration to dict"""
         return {
             SLURM_PARTITION: self.partition if self.partition is not None else "",
             SLURM_MEM: self.mem,
@@ -441,6 +446,7 @@ class SlurmConfig:
             SLURM_CLEAN_SCRIPTS: self.clean_script,
             SLURM_NUMBER_OF_TASKS: self.n_tasks,
             SLURM_COR_PER_TASKS: self.n_cpu_per_task,
+            SLURM_JOB_NAME: self.job_name,
         }
 
     @staticmethod
@@ -457,18 +463,21 @@ class SlurmConfig:
             preprocessing_command=config.get(SLURM_PREPROCESSING_COMMAND, ""),
             modules_to_load=convert_str_to_tuple(config.get(SLURM_MODULES_TO_LOADS, "")),
             clean_script=convert_to_bool(config.get(SLURM_CLEAN_SCRIPTS, False))[0],
+            job_name=config.get(SLURM_JOB_NAME, ""),
         )
 
 
-def _cast_shift_to_str(shifts: Union[tuple, str, None]) -> str:
+def _cast_shift_to_str(shifts: Union[tuple, numpy.ndarray, str, None]) -> str:
     if shifts is None:
         return ""
     elif isinstance(shifts, ShiftAlgorithm):
         return shifts.value
     elif isinstance(shifts, str):
         return shifts
-    elif isinstance(shifts, (tuple, list)):
+    elif isinstance(shifts, (tuple, list, numpy.ndarray)):
         return ";".join([str(value) for value in shifts])
+    else:
+        raise TypeError(f"unexpected type: {type(shifts)}")
 
 
 @dataclass
@@ -541,12 +550,12 @@ class StitchingConfiguration:
             STITCHING_SECTION: {
                 STITCHING_TYPE_FIELD: {
                     "default": StitchingType.Z_PREPROC.value,
-                    "help": f"stitching to be applied. Must be in {StitchingType.values()}",
+                    "help": f"stitching to be applied. Must be in {[st.value for st in StitchingType]}",
                     "type": "required",
                 },
                 STITCHING_STRATEGY_FIELD: {
                     "default": "cosinus weights",
-                    "help": f"Policy to apply to compute the overlap area. Must be in {OverlapStitchingStrategy.values()}.",
+                    "help": f"Policy to apply to compute the overlap area. Must be in {[ov.value for ov in OverlapStitchingStrategy]}.",
                     "type": "required",
                 },
                 CROSS_CORRELATION_SLICE_FIELD: {
@@ -626,7 +635,7 @@ class StitchingConfiguration:
                 },
                 ALIGNMENT_AXIS_2_FIELD: {
                     "default": "center",
-                    "help": f"In case frame have different frame widths how to align them (so along volume axis 2). Valid keys are {AlignmentAxis2.values()}",
+                    "help": f"In case frame have different frame widths how to align them (so along volume axis 2). Valid keys are {[aa.value for aa in AlignmentAxis2]}",
                     "type": "advanced",
                 },
                 PAD_MODE_FIELD: {
@@ -748,7 +757,7 @@ class StitchingConfiguration:
                 AXIS_2_POS_PX: _cast_shift_to_str(self.axis_2_pos_px),
                 AXIS_2_POS_MM: _cast_shift_to_str(self.axis_2_pos_mm),
                 AXIS_2_PARAMS: _dict_to_str(self.axis_2_params or {}),
-                STITCHING_STRATEGY_FIELD: OverlapStitchingStrategy.from_value(self.stitching_strategy).value,
+                STITCHING_STRATEGY_FIELD: OverlapStitchingStrategy(self.stitching_strategy).value,
                 FLIP_UD: self.flip_ud,
                 FLIP_LR: self.flip_lr,
                 RESCALE_FRAMES: self.rescale_frames,
@@ -927,7 +936,7 @@ class PreProcessedSingleAxisStitchingConfiguration(SingleAxisStitchingConfigurat
         if self.pixel_size is None:
             pixel_size_mm = ""
         else:
-            pixel_size_mm = self.pixel_size * MetricSystem.MILLIMETER.value
+            pixel_size_mm = (self.pixel_size * _ureg.meter).to(_ureg.millimeter).magnitude
         return concatenate_dict(
             super().to_dict(),
             {
@@ -991,10 +1000,10 @@ class PreProcessedSingleAxisStitchingConfiguration(SingleAxisStitchingConfigurat
         if pixel_size == "":
             pixel_size = None
         else:
-            pixel_size = float(pixel_size) / MetricSystem.MM
+            pixel_size = (float(pixel_size) * _ureg.millimeter).to_base_units().magnitude
 
         return cls(
-            stitching_strategy=OverlapStitchingStrategy.from_value(
+            stitching_strategy=OverlapStitchingStrategy(
                 config[STITCHING_SECTION].get(
                     STITCHING_STRATEGY_FIELD,
                     OverlapStitchingStrategy.COSINUS_WEIGHTS,
@@ -1035,7 +1044,7 @@ class PreProcessedSingleAxisStitchingConfiguration(SingleAxisStitchingConfigurat
                     config[STITCHING_SECTION].get(STITCHING_KERNELS_EXTRA_PARAMS, {}),
                 )
             ),
-            alignment_axis_2=AlignmentAxis2.from_value(
+            alignment_axis_2=AlignmentAxis2(
                 config[STITCHING_SECTION].get(ALIGNMENT_AXIS_2_FIELD, AlignmentAxis2.CENTER)
             ),
             pad_mode=config[STITCHING_SECTION].get(PAD_MODE_FIELD, "constant"),
@@ -1156,11 +1165,11 @@ class PostProcessedSingleAxisStitchingConfiguration(SingleAxisStitchingConfigura
         if voxel_size == "":
             voxel_size = None
         else:
-            voxel_size = float(voxel_size) * MetricSystem.MM
+            voxel_size = (float(voxel_size) * _ureg.millimeter).to_base_units().magnitude
 
         # on the next section the one with a default value qre the optional one
         return cls(
-            stitching_strategy=OverlapStitchingStrategy.from_value(
+            stitching_strategy=OverlapStitchingStrategy(
                 config[STITCHING_SECTION].get(
                     STITCHING_STRATEGY_FIELD,
                     OverlapStitchingStrategy.COSINUS_WEIGHTS,
@@ -1191,10 +1200,10 @@ class PostProcessedSingleAxisStitchingConfiguration(SingleAxisStitchingConfigura
                     config[STITCHING_SECTION].get(STITCHING_KERNELS_EXTRA_PARAMS, {}),
                 )
             ),
-            alignment_axis_1=AlignmentAxis1.from_value(
+            alignment_axis_1=AlignmentAxis1(
                 config[STITCHING_SECTION].get(ALIGNMENT_AXIS_1_FIELD, AlignmentAxis1.CENTER)
             ),
-            alignment_axis_2=AlignmentAxis2.from_value(
+            alignment_axis_2=AlignmentAxis2(
                 config[STITCHING_SECTION].get(ALIGNMENT_AXIS_2_FIELD, AlignmentAxis2.CENTER)
             ),
             pad_mode=config[STITCHING_SECTION].get(PAD_MODE_FIELD, "constant"),
@@ -1208,7 +1217,7 @@ class PostProcessedSingleAxisStitchingConfiguration(SingleAxisStitchingConfigura
         if self.voxel_size is None:
             voxel_size_mm = ""
         else:
-            voxel_size_mm = numpy.array(self.voxel_size) / MetricSystem.MM
+            voxel_size_mm = numpy.array((self.voxel_size * _ureg.meter).to(_ureg.millimeter).magnitude)
 
         return concatenate_dict(
             super().to_dict(),
@@ -1243,7 +1252,7 @@ class PostProcessedSingleAxisStitchingConfiguration(SingleAxisStitchingConfigura
                 STITCHING_SECTION: {
                     ALIGNMENT_AXIS_1_FIELD: {
                         "default": "center",
-                        "help": f"alignment to apply over axis 1 if needed. Valid values are {AlignmentAxis1.values()}",
+                        "help": f"alignment to apply over axis 1 if needed. Valid values are {[aa for aa in AlignmentAxis1]}",
                         "type": "advanced",
                     }
                 },
@@ -1274,7 +1283,7 @@ def dict_to_config_obj(config: dict):
     if stitching_type is None:
         raise ValueError("Unable to find stitching type from config dict")
     else:
-        stitching_type = StitchingType.from_value(stitching_type)
+        stitching_type = StitchingType(stitching_type)
         if stitching_type is StitchingType.Z_POSTPROC:
             return PostProcessedZStitchingConfiguration.from_dict(config)
         elif stitching_type is StitchingType.Z_PREPROC:
@@ -1297,7 +1306,7 @@ def get_default_stitching_config(stitching_type: Optional[Union[StitchingType, s
     if stitching_type is None:
         return concatenate_dict(z_postproc_stitching_config, z_preproc_stitching_config)
 
-    stitching_type = StitchingType.from_value(stitching_type)
+    stitching_type = StitchingType(stitching_type)
     if stitching_type is StitchingType.Z_POSTPROC:
         return z_postproc_stitching_config
     elif stitching_type is StitchingType.Z_PREPROC:

nabu/stitching/definitions.py

@@ -1,7 +1,7 @@
-from silx.utils.enum import Enum as _Enum
+from enum import Enum
 
 
-class StitchingType(_Enum):
+class StitchingType(Enum):
     Y_PREPROC = "y-preproc"
     Z_PREPROC = "z-preproc"
     Z_POSTPROC = "z-postproc"

nabu/stitching/frame_composition.py

@@ -31,7 +31,7 @@ class FrameComposition:
             )
 
     def compose(self, output_frame: numpy.ndarray, input_frames: tuple):
-        if not output_frame.ndim in (2, 3):
+        if output_frame.ndim not in (2, 3):
             raise TypeError(
                 f"output_frame is expected to be 2D (gray scale) or 3D (RGB(A)) and not {output_frame.ndim}"
             )
@@ -74,9 +74,10 @@ class FrameComposition:
         local_start_indices.extend(
             [ceil(key_line[1] + kernel.overlap_size / 2) for (key_line, kernel) in zip(key_lines, overlap_kernels)]
         )
-        local_end_indices = list(
-            [ceil(key_line[0] - kernel.overlap_size / 2) for (key_line, kernel) in zip(key_lines, overlap_kernels)]
-        )
+        local_end_indices = [
+            ceil(key_line[0] - kernel.overlap_size / 2) for (key_line, kernel) in zip(key_lines, overlap_kernels)
+        ]
+
         local_end_indices.append(frames[-1].shape[stitching_axis])
 
         for (
@@ -155,9 +156,6 @@ class FrameComposition:
             print(
                 f"stitch_frame[{stitch_global_start}:{stitch_global_end}] = stitched_frame_{i_frame}[{stitch_local_start}:{stitch_local_end}]"
             )
-        else:
-            i_frame += 1
-            raw_local_start, raw_local_end, raw_global_start, raw_global_end = list(raw_composition.browse())[-1]
-            print(
-                f"stitch_frame[{raw_global_start}:{raw_global_end}] = frame_{i_frame}[{raw_local_start}:{raw_local_end}]"
-            )
+        i_frame += 1
+        raw_local_start, raw_local_end, raw_global_start, raw_global_end = list(raw_composition.browse())[-1]
+        print(f"stitch_frame[{raw_global_start}:{raw_global_end}] = frame_{i_frame}[{raw_local_start}:{raw_local_end}]")

nabu/stitching/overlap.py

@@ -1,7 +1,7 @@
 import numpy
 import logging
 from typing import Optional, Union
-from silx.utils.enum import Enum as _Enum
+from enum import Enum
 from nabu.misc import fourier_filters
 from scipy.fft import rfftn as local_fftn
 from scipy.fft import irfftn as local_ifftn
@@ -10,7 +10,7 @@ from tomoscan.utils.geometry import BoundingBox1D
 _logger = logging.getLogger(__name__)
 
 
-class OverlapStitchingStrategy(_Enum):
+class OverlapStitchingStrategy(Enum):
     MEAN = "mean"
     COSINUS_WEIGHTS = "cosinus weights"
     LINEAR_WEIGHTS = "linear weights"
@@ -64,7 +64,7 @@ class ImageStichOverlapKernel(OverlapKernelBase):
                 f"frame_width is expected to be a positive int, {frame_unstitched_axis_size} - not {frame_unstitched_axis_size} ({type(frame_unstitched_axis_size)})"
             )
 
-        if not stitching_axis in (0, 1):
+        if stitching_axis not in (0, 1):
             raise ValueError(
                 "stitching_axis is expected to be the axis along which stitching must be done. It should be '0' or '1'"
             )
@@ -72,7 +72,7 @@ class ImageStichOverlapKernel(OverlapKernelBase):
         self._stitching_axis = stitching_axis
         self._overlap_size = abs(overlap_size)
         self._frame_unstitched_axis_size = frame_unstitched_axis_size
-        self._stitching_strategy = OverlapStitchingStrategy.from_value(stitching_strategy)
+        self._stitching_strategy = OverlapStitchingStrategy(stitching_strategy)
         self._weights_img_1 = None
         self._weights_img_2 = None
         if extra_params is None:

nabu/stitching/sample_normalization.py

@@ -1,13 +1,13 @@
+from enum import Enum
 import numpy
-from silx.utils.enum import Enum as _Enum
 
 
-class SampleSide(_Enum):
+class SampleSide(Enum):
     LEFT = "left"
     RIGHT = "right"
 
 
-class Method(_Enum):
+class Method(Enum):
     MEAN = "mean"
     MEDIAN = "median"
 
@@ -28,8 +28,8 @@ def normalize_frame(
         raise TypeError(f"Frame is expected to be a 2D numpy array.")
     if frame.ndim != 2:
         raise TypeError(f"Frame is expected to be a 2D numpy array. Get {frame.ndim}D")
-    side = SampleSide.from_value(side)
-    method = Method.from_value(method)
+    side = SampleSide(side)
+    method = Method(method)
 
     if frame.shape[1] < sample_width + margin_before_sample:
         raise ValueError(

nabu/stitching/slurm_utils.py

@@ -177,7 +177,7 @@ def split_slices(slices: Union[slice, tuple], n_parts: int):
         raise TypeError(f"slices type ({type(slices)}) is not handled. Must be a slice or an Iterable")
 
 
-def get_working_directory(obj: TomoObject) -> Optional[str]:
+def get_working_directory(obj: TomoObject) -> Optional[str]:  # noqa: PLR0911
     """
     return working directory for a specific TomoObject
     """
@@ -201,4 +201,4 @@ def get_working_directory(obj: TomoObject) -> Optional[str]:
         else:
             return os.path.abspath(os.path.dirname(obj.master_file))
     else:
-        raise RuntimeError(f"obj type not handled ({type(obj)})")
+        raise RuntimeError(f"obj type not handled ({type(obj)})")  # noqa: TRY004

nabu/stitching/stitcher/base.py

@@ -21,6 +21,8 @@ def get_obj_constant_side_length(obj: Union[NXtomoScan, VolumeBase], axis: int)
             return obj.dim_1
         elif axis in (1, 2):
             return obj.dim_2
+        else:
+            raise ValueError(f"Axis ({axis}) not handled. Should be in (0, 1, 2)")
     elif isinstance(obj, VolumeBase) and axis == 0:
         return obj.get_volume_shape()[-1]
     else:

nabu/stitching/stitcher/dumper/base.py

@@ -4,7 +4,6 @@ from typing import Union, Optional
 from tomoscan.identifier import BaseIdentifier
 from nabu.stitching.config import StitchingConfiguration
 from tomoscan.volumebase import VolumeBase
-from contextlib import AbstractContextManager
 
 
 class DumperBase:

nabu/stitching/stitcher/dumper/postprocessing.py

@@ -96,7 +96,7 @@ class OutputVolumeContext(AbstractContextManager):
         if self._file_handler is not None:
             return self._file_handler.close()
         else:
-            self._volume.save_data()
+            self._volume.save_data()  # noqa: RET503
 
 
 class OutputVolumeNoDDContext(OutputVolumeContext):

nabu/stitching/stitcher/post_processing.py

@@ -2,6 +2,7 @@ import logging
 import numpy
 import os
 import h5py
+import pint
 from typing import Union
 from nabu.stitching.config import PostProcessedSingleAxisStitchingConfiguration
 from nabu.stitching.alignment import AlignmentAxis1
@@ -13,11 +14,9 @@ from tomoscan.esrf import NXtomoScan
 from tomoscan.series import Series
 from tomoscan.volumebase import VolumeBase
 from tomoscan.esrf.volume import HDF5Volume
-from typing import Iterable
+from collections.abc import Iterable
 from contextlib import AbstractContextManager
-from pyunitsystem.metricsystem import MetricSystem
 from nabu.stitching.config import (
-    PostProcessedSingleAxisStitchingConfiguration,
     KEY_IMG_REG_METHOD,
 )
 from nabu.stitching.utils.utils import find_volumes_relative_shifts
@@ -26,6 +25,8 @@ from .single_axis import SingleAxisStitcher
 
 _logger = logging.getLogger(__name__)
 
+_ureg = pint.get_application_registry()
+
 
 class FlippingValueError(ValueError):
     pass
@@ -267,7 +268,7 @@ class PostProcessingStitching(SingleAxisStitcher):
                 axis_N_pos_px = []
                 for volume, pos_in_mm in zip(self.series, pos_as_mm):
                     voxel_size_m = self.configuration.voxel_size or volume.voxel_size
-                    axis_N_pos_px.append((pos_in_mm / MetricSystem.MILLIMETER.value) / voxel_size_m[0])
+                    axis_N_pos_px.append((pos_in_mm * _ureg.millimeter).to_base_units().magnitude / voxel_size_m[0])
                 return axis_N_pos_px
             else:
                 # deduce from motor position and pixel size
@@ -426,7 +427,7 @@ class PostProcessingStitching(SingleAxisStitcher):
 
         bunch_size = 50
         # how many frame to we stitch between two read from disk / save to disk
-        with self.dumper.OutputDatasetContext(**output_dataset_args):
+        with self.dumper.OutputDatasetContext(**output_dataset_args):  # noqa: SIM117
             # note: output_dataset is a HDF5 dataset if final volume is an HDF5 volume else is a numpy array
             with _RawDatasetsContext(
                 self._input_volumes,
@@ -528,7 +529,8 @@ class _RawDatasetsContext(AbstractContextManager):
                 else:
                     data = volume.load_data(store=False)
                     if data is None:
-                        raise ValueError(f"No data found for volume {volume.get_identifier()}")
+                        # TODO
+                        raise ValueError(f"No data found for volume {volume.get_identifier()}")  # noqa: TRY301
                 if axis_1_need_padding:
                     data = self.add_padding(data=data, axis_1_dim=axis_1_dim, alignment=self.alignment_axis_1)
                 datasets.append(data)
@@ -536,7 +538,7 @@ class _RawDatasetsContext(AbstractContextManager):
             # if some errors happen during loading HDF5
             for file_handled in self.__file_handlers:
                 file_handled.close()
-            raise e
+            raise e  # noqa: TRY201
 
         return datasets
 
@@ -544,11 +546,11 @@ class _RawDatasetsContext(AbstractContextManager):
         success = True
         for file_handler in self.__file_handlers:
             success = success and file_handler.close()
-        if exc_type is None:
+        if exc_type is None:  # noqa: RET503
             return success
 
     def add_padding(self, data: Union[h5py.Dataset, numpy.ndarray], axis_1_dim, alignment: AlignmentAxis1):
-        alignment = AlignmentAxis1.from_value(alignment)
+        alignment = AlignmentAxis1(alignment)
         if alignment is AlignmentAxis1.BACK:
             axis_1_pad_width = (axis_1_dim - data.shape[1], 0)
         elif alignment is AlignmentAxis1.CENTER: