nabu 2025.1.0.dev5__py3-none-any.whl → 2025.1.0.dev13__py3-none-any.whl

nabu/reconstruction/tests/test_deringer.py

@@ -38,7 +38,7 @@ if __do_long_tests__:
             "sigma": [1.0, 2.0],
             "wname": ["db15", "haar", "rbio4.4"],
             "padding": [None, (100, 100), (50, 71)],
-            "fft_implem": ["skcuda", "vkfft"],
+            "fft_implem": ["vkfft"],
         }
     )
 
@@ -107,7 +107,7 @@ class TestDeringer:
 
     @pytest.mark.skipif(
         not (__has_cuda_deringer__) or munchetal_filter is None,
-        reason="Need pycuda, pycudwt and (scikit-cuda or pyvkfft) for this test",
+        reason="Need pycuda, pycudwt and (cupy? or pyvkfft) for this test",
     )
     @pytest.mark.parametrize("config", fw_scenarios)
     def test_cuda_munch_deringer(self, config):

nabu/reconstruction/tests/test_fbp.py

@@ -7,10 +7,10 @@ from nabu.testutils import get_data, generate_tests_scenarios, __do_long_tests__
 from nabu.cuda.utils import get_cuda_context, __has_pycuda__
 from nabu.opencl.utils import get_opencl_context, __has_pyopencl__
 
-from nabu.processing.fft_cuda import has_skcuda, has_vkfft as has_vkfft_cu
+from nabu.processing.fft_cuda import has_vkfft as has_vkfft_cu
 from nabu.processing.fft_opencl import has_vkfft as has_vkfft_cl
 
-__has_pycuda__ = __has_pycuda__ and (has_skcuda() or has_vkfft_cu())
+__has_pycuda__ = __has_pycuda__ and has_vkfft_cu()
 __has_pyopencl__ = __has_pyopencl__ and has_vkfft_cl()
 
 if __has_pycuda__:
@@ -40,7 +40,7 @@ def bootstrap(request):
     # always use contiguous arrays
     cls.sino_511 = np.ascontiguousarray(cls.sino_512[:, :-1])
     # Could be set to 5.0e-2 when using textures. When not using textures, interpolation slightly differs
-    cls.tol = 5.1e-2
+    cls.tol = 2e-2  # 5.1e-2
 
     if __has_pycuda__:
         cls.cuda_ctx = get_cuda_context(cleanup_at_exit=False)
@@ -62,7 +62,7 @@ class TestFBP:
     def _get_backprojector(self, config, *bp_args, **bp_kwargs):
         if config["backend"] == "cuda":
             if not (__has_pycuda__):
-                pytest.skip("Need pycuda + (scikit-cuda or pyvkfft)")
+                pytest.skip("Need pycuda + (cupy? or pyvkfft)")
             Backprojector = CudaBackprojector
             ctx = self.cuda_ctx
         else:
@@ -98,10 +98,14 @@ class TestFBP:
         B = self._get_backprojector(config, (500, 512))
         res = self.apply_fbp(config, B, self.sino_512)
 
-        delta_clipped = clip_to_inner_circle(res - self.ref_512)
-        err_max = np.max(np.abs(delta_clipped))
+        diff = res - self.ref_512
+        tol = self.tol
+        if not (B._use_textures):
+            diff = clip_to_inner_circle(diff)
+            tol = 5.1e-2
+        err_max = np.max(np.abs(diff))
 
-        assert err_max < self.tol, "Something wrong with config=%s" % (str(config))
+        assert err_max < tol, "Something wrong with config=%s" % (str(config))
 
     @pytest.mark.parametrize("config", scenarios)
     def test_fbp_511(self, config):
@@ -112,10 +116,29 @@ class TestFBP:
         res = self.apply_fbp(config, B, self.sino_511)
         ref = self.ref_512[:-1, :-1]
 
-        delta_clipped = clip_to_inner_circle(res - ref)
-        err_max = np.max(np.abs(delta_clipped))
-
-        assert err_max < self.tol, "Something wrong with config=%s" % (str(config))
+        diff = clip_to_inner_circle(res - ref)
+        err_max = np.max(np.abs(diff))
+        tol = self.tol
+        if not (B._use_textures):
+            tol = 5.1e-2
+
+        assert err_max < tol, "Something wrong with config=%s" % (str(config))
+
+        # Cropping the singoram to sino[:, :-1]  gives a reconstruction
+        # that is not fully equivalent to rec512[:-1, :-1]  in the upper half of the image, outside FoV.
+        # However, nabu Backprojector gives the same results as astra
+        # Probably we should check this instead:
+
+        # B = self._get_backprojector(config, (500, 511), rot_center=255.5, extra_options={"centered_axis": True})
+        # res = self.apply_fbp(config, B, self.sino_511)
+        # import astra
+        # proj_geom = astra.create_proj_geom('parallel', 1, 511, B.angles)
+        # proj_geom = astra.geom_postalignment(proj_geom, - 0.5)
+        # vol_geom = astra.create_vol_geom(511, 511)
+        # proj_id = astra.create_projector("cuda", proj_geom, vol_geom)
+        # ref = astra.create_reconstruction("FBP_CUDA", proj_id, self.sino_511, proj_id)[1]
+        # err_max = np.max(np.abs(res - ref))
+        # assert err_max < self.tol, "Something wrong with config=%s" % (str(config))
 
     @pytest.mark.parametrize("config", scenarios)
     def test_fbp_roi(self, config):
@@ -194,8 +217,7 @@ class TestFBP:
             )
             res_noclip = B0.fbp(sino)
             ref = clip_to_inner_circle(res_noclip, radius_factor=1)
-            abs_diff = np.abs(res - ref)
-            err_max = np.max(abs_diff)
+            err_max = np.max(np.abs(res - ref))
             assert err_max < tol, "Max error is too high for rot_center=%s ; %s" % (str(rot_center), str(config))
 
             # Test with custom outer circle value
@@ -223,7 +245,6 @@ class TestFBP:
         ref = B0.fbp(self.sino_512)
 
         # Check that "centered_axis" worked
-
         B = self._get_backprojector(config, sino.shape, rot_center=rot_center, extra_options={"centered_axis": True})
         res = self.apply_fbp(config, B, sino)
         # The outside region (outer circle) is different as "res" is a wider slice

nabu/reconstruction/tests/test_filtering.py

@@ -14,11 +14,13 @@ if __has_pyopencl__:
     from nabu.opencl.processing import OpenCLProcessing
     from nabu.reconstruction.filtering_opencl import OpenCLSinoFilter, __has_vkfft__
 
-filters_to_test = ["ramlak", "shepp-logan", "tukey"]
+filters_to_test = ["ramlak", "shepp-logan"]
 padding_modes_to_test = ["constant", "edge"]
+crop_filtered_data = [True]
 if __do_long_tests__:
-    filters_to_test = ["ramlak", "shepp-logan", "cosine", "hamming", "hann", "tukey", "lanczos"]
+    filters_to_test.extend(["cosine", "hamming", "hann", "lanczos"])
     padding_modes_to_test = SinoFilter.available_padding_modes
+    crop_filtered_data = [True, False]
 
 tests_scenarios = generate_tests_scenarios(
     {
@@ -26,6 +28,7 @@ tests_scenarios = generate_tests_scenarios(
         "padding_mode": padding_modes_to_test,
         "output_provided": [True, False],
         "truncated_sino": [True, False],
+        "crop_filtered_data": crop_filtered_data,
     }
 )
 
@@ -61,9 +64,10 @@ class TestSinoFilter:
             sino.shape,
             filter_name=config["filter_name"],
             padding_mode=config["padding_mode"],
+            crop_filtered_data=config["crop_filtered_data"],
         )
         if config["output_provided"]:
-            output = np.zeros_like(sino)
+            output = np.zeros(sino_filter.output_shape, "f")
         else:
             output = None
         res = sino_filter.filter_sino(sino, output=output)
@@ -71,7 +75,11 @@ class TestSinoFilter:
             assert id(res) == id(output), "when providing output, return value must not change"
 
         ref = filter_sinogram(
-            sino, sino_filter.dwidth_padded, filter_name=config["filter_name"], padding_mode=config["padding_mode"]
+            sino,
+            sino_filter.dwidth_padded,
+            filter_name=config["filter_name"],
+            padding_mode=config["padding_mode"],
+            crop_filtered_data=config["crop_filtered_data"],
         )
 
         assert np.allclose(res, ref, atol=4e-6)
@@ -86,10 +94,11 @@ class TestSinoFilter:
             sino.shape,
             filter_name=config["filter_name"],
             padding_mode=config["padding_mode"],
+            crop_filtered_data=config["crop_filtered_data"],
             cuda_options={"ctx": self.ctx_cuda},
         )
         if config["output_provided"]:
-            output = garray.zeros(sino.shape, "f")
+            output = garray.zeros(sino_filter.output_shape, "f")
         else:
             output = None
         res = sino_filter.filter_sino(sino, output=output)

nabu/reconstruction/tests/test_halftomo.py

@@ -42,7 +42,7 @@ class TestHalftomo:
     def _get_backprojector(self, config, *bp_args, **bp_kwargs):
         if config["backend"] == "cuda":
             if not (__has_pycuda__):
-                pytest.skip("Need pycuda + scikit-cuda or vkfft")
+                pytest.skip("Need pycuda + cupy? or vkfft")
             Backprojector = CudaBackprojector
             ctx = self.cuda_ctx
         else:

nabu/reconstruction/tests/test_reconstructor.py

@@ -48,7 +48,7 @@ def bootstrap(request):
 )
 @pytest.mark.usefixtures("bootstrap")
 class TestReconstructor:
-    @pytest.mark.skipif(not (__has_cuda_fbp__), reason="need pycuda and (scikit-cuda or vkfft)")
+    @pytest.mark.skipif(not (__has_cuda_fbp__), reason="need pycuda and (cupy? or vkfft)")
     @pytest.mark.parametrize("config", scenarios)
     def test_cuda_reconstructor(self, config):
         data = self.projs

nabu/resources/dataset_analyzer.py

@@ -2,10 +2,12 @@ import os
 import numpy as np
 from silx.io.url import DataUrl
 from silx.io import get_data
+from tomoscan import __version__ as __tomoscan_version__
 from tomoscan.esrf.scan.edfscan import EDFTomoScan
 from tomoscan.esrf.scan.nxtomoscan import NXtomoScan
+from packaging.version import parse as parse_version
 
-from ..utils import check_supported, indices_to_slices
+from ..utils import BaseClassError, check_supported, indices_to_slices
 from ..io.reader import EDFStackReader, NXDarksFlats, NXTomoReader
 from ..io.utils import get_compacted_dataslices
 from .utils import get_values_from_file, is_hdf5_extension
@@ -143,7 +145,10 @@ class DatasetAnalyzer:
         Return the sample-detector distance in meters.
         """
         if self._distance is None:
-            self._distance = abs(self.dataset_scanner.distance)
+            if parse_version(__tomoscan_version__) < parse_version("2.2"):
+                self._distance = abs(self.dataset_scanner.distance)
+            else:
+                self._distance = abs(self.dataset_scanner.sample_detector_distance)
         return self._distance
 
     @distance.setter
@@ -272,6 +277,14 @@ class DatasetAnalyzer:
     def darks(self, val):
         self._reduced_darks = val
 
+    @property
+    def scan_basename(self):
+        raise BaseClassError
+
+    @property
+    def scan_dirname(self):
+        raise BaseClassError
+
 
 class EDFDatasetAnalyzer(DatasetAnalyzer):
     """
@@ -328,6 +341,15 @@ class EDFDatasetAnalyzer(DatasetAnalyzer):
     def get_reader(self, **kwargs):
         return EDFStackReader(self.files, **kwargs)
 
+    @property
+    def scan_basename(self):
+        # os.path.basename(self.dataset_scanner.path)
+        return self.dataset_scanner.get_dataset_basename()
+
+    @property
+    def scan_dirname(self):
+        return self.dataset_scanner.path
+
 
 class HDF5DatasetAnalyzer(DatasetAnalyzer):
     """
@@ -460,6 +482,16 @@ class HDF5DatasetAnalyzer(DatasetAnalyzer):
     def get_reader(self, **kwargs):
         return NXTomoReader(self.dataset_hdf5_url.file_path(), data_path=self.dataset_hdf5_url.data_path(), **kwargs)
 
+    @property
+    def scan_basename(self):
+        # os.path.splitext(os.path.basename(self.dataset_hdf5_url.file_path()))[0]
+        return self.dataset_scanner.get_dataset_basename()
+
+    @property
+    def scan_dirname(self):
+        # os.path.dirname(di.dataset_hdf5_url.file_path())
+        return self.dataset_scanner.path
+
 
 def analyze_dataset(dataset_path, extra_options=None, logger=None):
     if not (os.path.isdir(dataset_path)):

nabu/resources/tests/test_extract.py

@@ -5,5 +5,7 @@ def test_list_match_queries():
 
     # entry0000 .... entry0099
     avail = ["entry%04d" % i for i in range(100)]
-    query = "entry0000"
-    list_match_queries()
+    assert list_match_queries(avail, "entry0000") == ["entry0000"]
+    assert list_match_queries(avail, ["entry0001"]) == ["entry0001"]
+    assert list_match_queries(avail, ["entry000?"]) == ["entry%04d" % i for i in range(10)]
+    assert list_match_queries(avail, ["entry*"]) == avail

nabu/stitching/config.py

@@ -128,6 +128,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"
@@ -421,6 +423,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
@@ -441,6 +444,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,6 +461,7 @@ 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, ""),
         )
 
 
@@ -774,7 +779,7 @@ class SingleAxisConfigMetaClass(type):
     warning: this class is used by tomwer as well
     """
 
-    def __new__(mcls, name, bases, attrs, axis=None):  # noqa: N804
+    def __new__(mcls, name, bases, attrs, axis=None):
         # assert axis is not None
         mcls = super().__new__(mcls, name, bases, attrs)
         mcls._axis = axis

nabu/stitching/stitcher/dumper/__init__.py

@@ -1,3 +1,4 @@
 from .postprocessing import PostProcessingStitchingDumper
 from .postprocessing import PostProcessingStitchingDumperNoDD
+from .postprocessing import PostProcessingStitchingDumperWithCache
 from .preprocessing import PreProcessingStitchingDumper

nabu/stitching/stitcher/dumper/postprocessing.py

@@ -161,7 +161,7 @@ class OutputVolumeNoDDContext(OutputVolumeContext):
 
 class PostProcessingStitchingDumper(DumperBase):
     """
-    dumper to be used when save data durint post-processing stitching (on recosntructed volume). Output is expected to be an NXtomo
+    dumper to be used when save data during post-processing stitching (on reconstructed volume). Output is expected to be an NXtomo
     """
 
     OutputDatasetContext = OutputVolumeContext
@@ -220,6 +220,110 @@ class PostProcessingStitchingDumper(DumperBase):
         )
 
 
+class PostProcessingStitchingDumperWithCache(PostProcessingStitchingDumper):
+    """
+    PostProcessingStitchingDumper with intermediate cache in order to speed up writting.
+    The cache is save to disk when full or when closing the dumper.
+    Mostly convenient for HDF5
+    """
+
+    def __init__(self, configuration):
+        super().__init__(configuration)
+        self.__cache = None
+        """cache as a numpy.ndarray"""
+        self.__cache_size = None
+        """how many frame do we want to keep in memory before dumping to disk"""
+        self.__dump_axis = None
+        """axis along which we load / save the data. Different of the stitching axis"""
+        self.__final_volume_shape = None
+        self.__output_frame_index = 0
+        self.__cache_index = 0
+
+    def init_cache(self, dump_axis, size, dtype):
+        if dump_axis not in (0, 1, 2):
+            raise ValueError(f"axis should be in (0, 1, 2). Got {dump_axis}")
+
+        self.__dump_axis = dump_axis
+        self.__cache_size = size
+        self.__cache = numpy.empty(
+            self._get_cache_shape(),
+            dtype=dtype,
+        )
+
+    def reset_cache(self):
+        self.__cache_index = 0
+
+    def set_final_volume_shape(self, shape):
+        self.__final_volume_shape = shape
+
+    def _get_cache_shape(self):
+        assert self.__final_volume_shape is not None, "final volume shape should already be defined"
+        if self.__dump_axis == 0:
+            return (
+                self.__cache_size,
+                self.__final_volume_shape[1],
+                self.__final_volume_shape[2],
+            )
+        elif self.__dump_axis == 1:
+            return (
+                self.__final_volume_shape[0],
+                self.__cache_size,
+                self.__final_volume_shape[2],
+            )
+        elif self.__dump_axis == 2:
+            return (
+                self.__final_volume_shape[0],
+                self.__final_volume_shape[1],
+                self.__cache_size,
+            )
+        else:
+            raise RuntimeError("dump axis should be defined before using the cache")
+
+    def save_stitched_frame(
+        self,
+        stitched_frame: numpy.ndarray,
+        composition_cls: dict,
+        i_frame: int,
+        axis: int,
+    ):
+        """save the frame to the volume. In this use case save the frame to the buffer. Waiting to be dump later.
+        We expect 'save_stitched_frame' to be called with contiguous frames (in the output volume space)
+        """
+        index_cache = self.__cache_index
+        if self.__dump_axis == 0:
+            self.__cache[index_cache,] = stitched_frame
+        elif self.__dump_axis == 1:
+            self.__cache[:, index_cache, :] = stitched_frame
+        elif self.__dump_axis == 2:
+            self.__cache[:, :, index_cache] = stitched_frame
+        else:
+            raise RuntimeError("dump axis should be defined before using the cache")
+        self.__cache_index += 1
+
+    def dump_cache(self, nb_frames):
+        """
+        dump the first nb_frames to disk
+        """
+        output_dataset_start_index = self.__output_frame_index
+        output_dataset_end_index = self.__output_frame_index + nb_frames
+        if self.__dump_axis == 0:
+            self.output_dataset[output_dataset_start_index:output_dataset_end_index] = self.__cache[:nb_frames]
+        elif self.__dump_axis == 1:
+            self.output_dataset[
+                :,
+                output_dataset_start_index:output_dataset_end_index,
+            ] = self.__cache[:, :nb_frames]
+        elif self.__dump_axis == 2:
+            self.output_dataset[:, :, output_dataset_start_index:output_dataset_end_index] = self.__cache[
+                :, :, :nb_frames
+            ]
+        else:
+            raise RuntimeError("dump axis should be defined before using the cache")
+
+        self.__output_frame_index = output_dataset_end_index
+        self.reset_cache()
+
+
 class PostProcessingStitchingDumperNoDD(PostProcessingStitchingDumper):
     """
     same as PostProcessingStitchingDumper but prevent to do data duplication.

nabu/stitching/stitcher/post_processing.py

@@ -396,7 +396,7 @@ class PostProcessingStitching(SingleAxisStitcher):
 
         data_type = self.get_output_data_type()
 
-        if self.progress:
+        if self.progress is not None:
             self.progress.total = final_volume_shape[1]
 
         y_index = 0
@@ -411,7 +411,7 @@ class PostProcessingStitching(SingleAxisStitcher):
             "dtype": data_type,
             "dumper": self.dumper,
         }
-        from .dumper.postprocessing import PostProcessingStitchingDumperNoDD
+        from .dumper.postprocessing import PostProcessingStitchingDumperNoDD, PostProcessingStitchingDumperWithCache
 
         # TODO: FIXME: for now not very elegant but in the case of avoiding data duplication
         # we need to provide the the information about the stitched part shape.
@@ -420,7 +420,11 @@ class PostProcessingStitching(SingleAxisStitcher):
             output_dataset_args["stitching_sources_arr_shapes"] = tuple(
                 [(abs(overlap), n_slices, self._stitching_constant_length) for overlap in self._axis_0_rel_final_shifts]
             )
+        elif isinstance(self.dumper, PostProcessingStitchingDumperWithCache):
+            self.dumper.set_final_volume_shape(final_volume_shape)
 
+        bunch_size = 50
+        # how many frame to we stitch between two read from disk / save to disk
         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(
@@ -430,11 +434,14 @@ class PostProcessingStitching(SingleAxisStitcher):
                 # note: raw_datasets can be numpy arrays or HDF5 dataset (in the case of HDF5Volume)
                 # to speed up we read by bunch of dataset. For numpy array this doesn't change anything
                 # but for HDF5 dataset this can speed up a lot the processing (depending on HDF5 dataset chuncks)
-                # note: we read trhough axis 1
+                # note: we read through axis 1
                 if isinstance(self.dumper, PostProcessingStitchingDumperNoDD):
                     self.dumper.raw_regions_hdf5_dataset = raw_datasets
+                if isinstance(self.dumper, PostProcessingStitchingDumperWithCache):
+                    self.dumper.init_cache(dump_axis=1, dtype=data_type, size=bunch_size)
+
                 for bunch_start, bunch_end in PostProcessingStitching._data_bunch_iterator(
-                    slices=self._slices_to_stitch, bunch_size=50
+                    slices=self._slices_to_stitch, bunch_size=bunch_size
                 ):
                     for data_frames in PostProcessingStitching._get_bunch_of_data(
                         bunch_start,
@@ -469,6 +476,9 @@ class PostProcessingStitching(SingleAxisStitcher):
                             self.progress.update()
                         y_index += 1
 
+                    if isinstance(self.dumper, PostProcessingStitchingDumperWithCache):
+                        self.dumper.dump_cache(nb_frames=(bunch_end - bunch_start))
+
     # alias to general API
     def _create_stitching(self, store_composition):
         self._create_stitched_volume(store_composition=store_composition)

nabu/stitching/stitcher/pre_processing.py

@@ -677,7 +677,7 @@ class PreProcessingStitching(SingleAxisStitcher):
             scans_projections_indexes = []
             for scan, reverse in zip(self.series, self.reading_orders):
                 scans_projections_indexes.append(sorted(scan.projections.keys(), reverse=(reverse == -1)))
-            if self.progress:
+            if self.progress is not None:
                 self.progress.total = self.get_n_slices_to_stitch()
 
             if isinstance(self._slices_to_stitch, slice):

nabu/stitching/stitcher/single_axis.py

@@ -37,7 +37,7 @@ class _SingleAxisMetaClass(type):
     Metaclass for single axis stitcher in order to aggregate dumper class and axis
     """
 
-    def __new__(mcls, name, bases, attrs, axis=None, dumper_cls=None):  # noqa: N804
+    def __new__(mcls, name, bases, attrs, axis=None, dumper_cls=None):
         mcls = super().__new__(mcls, name, bases, attrs)
         mcls._axis = axis
         mcls._dumperCls = dumper_cls
@@ -470,12 +470,13 @@ class SingleAxisStitcher(_StitcherBase, metaclass=_SingleAxisMetaClass):
             pad_mode=pad_mode,
             new_unstitched_axis_size=new_width,
         )
-        dumper.save_stitched_frame(
-            stitched_frame=stitched_frame,
-            composition_cls=composition_cls,
-            i_frame=i_frame,
-            axis=1,
-        )
+        if dumper is not None:
+            dumper.save_stitched_frame(
+                stitched_frame=stitched_frame,
+                composition_cls=composition_cls,
+                i_frame=i_frame,
+                axis=1,
+            )
 
         if return_composition_cls:
             return stitched_frame, composition_cls

nabu/stitching/stitcher/z_stitcher.py

@@ -1,6 +1,10 @@
 from nabu.stitching.stitcher.pre_processing import PreProcessingStitching
 from nabu.stitching.stitcher.post_processing import PostProcessingStitching
-from .dumper import PreProcessingStitchingDumper, PostProcessingStitchingDumperNoDD, PostProcessingStitchingDumper
+from .dumper import (
+    PreProcessingStitchingDumper,
+    PostProcessingStitchingDumperNoDD,
+    PostProcessingStitchingDumperWithCache,
+)
 from nabu.stitching.stitcher.single_axis import _SingleAxisMetaClass
 
 
@@ -26,12 +30,12 @@ class PreProcessingZStitcher(
 class PostProcessingZStitcher(
     PostProcessingStitching,
     metaclass=_SingleAxisMetaClass,
-    dumper_cls=PostProcessingStitchingDumper,
+    dumper_cls=PostProcessingStitchingDumperWithCache,
     axis=0,
 ):
     @property
     def serie_label(self) -> str:
-        return "z-serie"
+        return "z-series"
 
 
 class PostProcessingZStitcherNoDD(
@@ -42,4 +46,4 @@ class PostProcessingZStitcherNoDD(
 ):
     @property
     def serie_label(self) -> str:
-        return "z-serie"
+        return "z-series"

nabu/stitching/utils/utils.py

@@ -1,4 +1,4 @@
-from distutils.version import StrictVersion  # pylint: disable=E0401
+from packaging.version import parse as parse_version
 from typing import Optional, Union
 import logging
 import functools
@@ -521,7 +521,7 @@ def find_shift_with_itk(img1: numpy.ndarray, img2: numpy.ndarray) -> tuple:
         _logger.warning("itk is not installed. Please install it to find shift with it")
         return (0, 0)
 
-    if StrictVersion(itk.Version.GetITKVersion()) < StrictVersion("4.9.0"):
+    if parse_version(itk.Version.GetITKVersion()) < parse_version("4.9.0"):
         _logger.error("ITK 4.9.0 is required to find shift with it.")
         return (0, 0)
 

nabu/testutils.py

@@ -14,14 +14,14 @@ __big_testdata_dir__ = os.environ.get("NABU_BIGDATA_DIR")
 if __big_testdata_dir__ is None or not (os.path.isdir(__big_testdata_dir__)):
     __big_testdata_dir__ = None
 
-__do_long_tests__ = os.environ.get("NABU_LONG_TESTS", False)
+__do_long_tests__ = os.environ.get("NABU_LONG_TESTS", False)  # noqa: PLW1508
 if __do_long_tests__:
     try:
         __do_long_tests__ = bool(int(__do_long_tests__))
     except:
         __do_long_tests__ = False
 
-__do_large_mem_tests__ = os.environ.get("NABU_LARGE_MEM_TESTS", False)
+__do_large_mem_tests__ = os.environ.get("NABU_LARGE_MEM_TESTS", False)  # noqa: PLW1508
 if __do_large_mem_tests__:
     try:
         __do_large_mem_tests__ = bool(int(__do_large_mem_tests__))

nabu/utils.py

@@ -180,6 +180,8 @@ def list_match_queries(available, queries):
     Given a list of strings, return all items matching any of one elements of "queries"
     """
     matches = []
+    if isinstance(queries, str):
+        queries = [queries]
     for a in available:
         for q in queries:
             if fnmatch(a, q):
@@ -711,9 +713,9 @@ def concatenate_dict(dict_1, dict_2) -> dict:
     return res
 
 
-class BaseClassError:
+class BaseClassError(BaseException):
     def __init__(self, *args, **kwargs):
-        raise ValueError("Base class")
+        raise NotImplementedError("Base class")
 
 
 def MissingComponentError(msg):
@@ -796,6 +798,11 @@ def median2(img):
 # ---------------------------- Decorators --------------------------------------
 # ------------------------------------------------------------------------------
 
+
+def no_decorator(func):
+    return func
+
+
 _warnings = {}