nabu 2024.2.9__py3-none-any.whl → 2024.2.11__py3-none-any.whl

nabu/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "2024.2.9"
+__version__ = "2024.2.11"
 __nabu_modules__ = [
     "app",
     "cuda",

nabu/pipeline/fullfield/chunked.py

@@ -781,7 +781,7 @@ class ChunkedPipeline:
     @pipeline_step("sino_deringer", "Removing rings on sinograms")
     def _destripe_sinos(self):
         sinos = np.rollaxis(self.radios, 1, 0)  # view
-        self.sino_deringer.remove_rings(sinos)  # TODO check it works with non-contiguous view
+        self.sino_deringer.remove_rings(sinos)
 
     @pipeline_step("reconstruction", "Reconstruction")
     def _reconstruct(self):

nabu/reconstruction/rings_cuda.py

@@ -264,13 +264,7 @@ class CudaSinoMeanDeringer(SinoMeanDeringer):
             filename=get_cuda_srcfile("normalization.cu"),
             signature="PPiii",
         )
-        self._mean_kernel_block = (32, 1, 32)
-        self._mean_kernel_grid = [updiv(a, b) for a, b in zip(self.sinos_shape[::-1], self._mean_kernel_block)]
-        self._mean_kernel_args = [self.d_sino_profile, np.int32(self.n_x), np.int32(self.n_angles), np.int32(self.n_z)]
-        self._mean_kernel_kwargs = {
-            "grid": self._mean_kernel_grid,
-            "block": self._mean_kernel_block,
-        }
+        self._set_kernel_args_normalization()
 
         self._op_kernel = self.processing.kernel(
             "inplace_generic_op_3Dby1D",
@@ -278,9 +272,25 @@ class CudaSinoMeanDeringer(SinoMeanDeringer):
             signature="PPiii",
             options=["-DGENERIC_OP=%d" % (3 if self.mode == "divide" else 1)],
         )
-        self._op_kernel_block = (16, 16, 4)
-        self._op_kernel_grid = [updiv(a, b) for a, b in zip(self.sinos_shape[::-1], self._op_kernel_block)]
-        self._op_kernel_args = [self.d_sino_profile, np.int32(self.n_x), np.int32(self.n_angles), np.int32(self.n_z)]
+        self._set_kernel_args_mult()
+
+    def _set_kernel_args_normalization(self, blk_z=32, n_z=None):
+        n_z = n_z or self.n_z
+        self._mean_kernel_block = (32, 1, blk_z)
+        sinos_shape_xyz = self.sinos_shape[1:][::-1] + (n_z,)
+        self._mean_kernel_grid = [updiv(a, b) for a, b in zip(sinos_shape_xyz, self._mean_kernel_block)]
+        self._mean_kernel_args = [self.d_sino_profile, np.int32(self.n_x), np.int32(self.n_angles), np.int32(n_z)]
+        self._mean_kernel_kwargs = {
+            "grid": self._mean_kernel_grid,
+            "block": self._mean_kernel_block,
+        }
+
+    def _set_kernel_args_mult(self, blk_z=4, n_z=None):
+        n_z = n_z or self.n_z
+        self._op_kernel_block = (16, 16, blk_z)
+        sinos_shape_xyz = self.sinos_shape[1:][::-1] + (n_z,)
+        self._op_kernel_grid = [updiv(a, b) for a, b in zip(sinos_shape_xyz, self._op_kernel_block)]
+        self._op_kernel_args = [self.d_sino_profile, np.int32(self.n_x), np.int32(self.n_angles), np.int32(n_z)]
         self._op_kernel_kwargs = {
             "grid": self._op_kernel_grid,
             "block": self._op_kernel_block,
@@ -315,23 +325,41 @@ class CudaSinoMeanDeringer(SinoMeanDeringer):
         self.d_sino_profile[:] = sino_profile_p[self._pad_left : -self._pad_right]
         return self.d_sino_profile
 
+    def _remove_rings_sino(self, d_sino):
+        self._mean_kernel(d_sino, *self._mean_kernel_args, **self._mean_kernel_kwargs)
+        self._apply_filter(self.d_sino_profile)
+        self._op_kernel(d_sino, *self._op_kernel_args, **self._op_kernel_kwargs)
+
     def remove_rings_sinogram(self, sino, output=None):
         #
         if output is not None:
             raise NotImplementedError
         #
         if not (sino.flags.c_contiguous):
+            # If the sinogram (or stack of sinogram) is not C-Contiguous, we'll proceed by looping over each
+            # C-Contiguous sinogram
             d_sino = self.processing.allocate_array("d_sino", sino.shape, np.float32)
             d_sino[:] = sino[:]
         else:
             d_sino = sino
-        self._mean_kernel(d_sino, *self._mean_kernel_args, **self._mean_kernel_kwargs)
-        self._apply_filter(self.d_sino_profile)
-        self._op_kernel(d_sino, *self._op_kernel_args, **self._op_kernel_kwargs)
+        self._remove_rings_sino(d_sino)
         if not (sino.flags.c_contiguous):
             sino[:] = self.processing.d_sino[:]
         return sino
 
     def remove_rings_sinograms(self, sinograms):
+        if sinograms.flags.c_contiguous:
+            self._remove_rings_sino(sinograms)
+            return sinograms
+
+        # If the stack of sinograms is not C-Contiguous, we have to proceed by looping over each C-Contiguous sinogram
+        # (i.e don't copy the entire stack, just one sinogram at a time)
+        self._set_kernel_args_normalization(blk_z=1, n_z=1)
+        self._set_kernel_args_mult(blk_z=1, n_z=1)
         for i in range(sinograms.shape[0]):
             self.remove_rings_sinogram(sinograms[i])
+        self._set_kernel_args_normalization()
+        self._set_kernel_args_mult()
+        return sinograms
+
+    remove_rings = remove_rings_sinograms

nabu/stitching/config.py

@@ -411,6 +411,7 @@ class NormalizationBySample:
 @dataclass
 class SlurmConfig:
     "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"
     n_jobs: int = 1

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

@@ -397,7 +397,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
@@ -412,7 +412,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.
@@ -421,7 +421,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):
             # note: output_dataset is a HDF5 dataset if final volume is an HDF5 volume else is a numpy array
             with _RawDatasetsContext(
@@ -431,11 +435,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,
@@ -470,6 +477,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

@@ -678,7 +678,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

@@ -471,12 +471,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-2024.2.9.dist-info → nabu-2024.2.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: nabu
-Version: 2024.2.9
+Version: 2024.2.11
 Summary: Nabu - Tomography software
 Author-email: Pierre Paleo <pierre.paleo@esrf.fr>, Henri Payno <henri.payno@esrf.fr>, Alessandro Mirone <mirone@esrf.fr>, Jérôme Lesaint <jerome.lesaint@esrf.fr>
 Maintainer-email: Pierre Paleo <pierre.paleo@esrf.fr>
@@ -78,6 +78,7 @@ Requires-Dist: sphinx; extra == "doc"
 Requires-Dist: cloud_sptheme; extra == "doc"
 Requires-Dist: myst-parser; extra == "doc"
 Requires-Dist: nbsphinx; extra == "doc"
+Dynamic: license-file
 
 # Nabu
 

{nabu-2024.2.9.dist-info → nabu-2024.2.11.dist-info}/RECORD

@@ -1,7 +1,7 @@
 doc/conf.py,sha256=3xtCarCHrXPr50GbeRDuH-o3Jzojw7mpr7vpGfZPLAE,3787
 doc/create_conf_doc.py,sha256=IVOdP70KvbW9WS_UQu3Iyd0YfS60E2fJ5IDtQ_s4cDw,1143
 doc/get_mathjax.py,sha256=VIvKRCdDuF2VoY8JD3mSey9XX13AZMmwTJBHdt1tUs4,1012
-nabu/__init__.py,sha256=zC_MI_KzALbmsIMyTOjFfDsgHH2yb1ywfTdyPnYdFYU,270
+nabu/__init__.py,sha256=pcf3vfOOGAWNkBnrtmOVzs63rfkJ3PfQoNhZsCBkDF0,271
 nabu/tests.py,sha256=cew9OY2uTyncHI_HM32W8CP6B1GTGKaOW65XtMEqs7o,1417
 nabu/testutils.py,sha256=VkSL9tbY0XEH49Z5OjDFFhzkSxrCv4UIuvSVFgegSUY,7632
 nabu/utils.py,sha256=V1B_sD54XGNKn5pORa2yNCATyswOzybey3sv8BuIYWY,26355
@@ -137,7 +137,7 @@ nabu/pipeline/reader.py,sha256=wkxPHYOi_C8dHNc7kddB8AMtFuW7GjsP_tm6SJeHlEY,4792
 nabu/pipeline/utils.py,sha256=0O1GLyYLQ8oA2ErI_T3BIfEVjP48dl-u_gl91eX7pjU,3543
 nabu/pipeline/writer.py,sha256=MG_R1oU8Ff9NdKRHiBkLMz0CmvEXY47zBUE-DpjXElQ,8172
 nabu/pipeline/fullfield/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nabu/pipeline/fullfield/chunked.py,sha256=UhNbaxfGgiTdeDdfSBPJhCd3Xo1bNR0EHfEHYf5SQxs,40939
+nabu/pipeline/fullfield/chunked.py,sha256=NQ5ArZdw1kzTBczSPYm0u5iTAKMh73Z93O9vPNAn-HE,40891
 nabu/pipeline/fullfield/chunked_cuda.py,sha256=Jdkk6ZIt3S6UZYbupHtSj2vrj3krWMcqRHHprfblDfk,5848
 nabu/pipeline/fullfield/computations.py,sha256=AEp3qvwyY-l8-GzjH1E6kmcmU6OgDp6sB-mltq0Jnxg,9970
 nabu/pipeline/fullfield/dataset_validator.py,sha256=Iy6oOnXnBldDcg0ifm_zzrzMQ6YdkR_hkHFySZgxbno,2943
@@ -233,7 +233,7 @@ nabu/reconstruction/projection.py,sha256=7WVPlYLUmCmB2yR1JYmVLJ5fZ3CMMKQ3vS9yuTU
 nabu/reconstruction/reconstructor.py,sha256=16xxHcK4iie-uh-trf6x_IuvgxJKBvQRTE5B8tnc4F8,7358
 nabu/reconstruction/reconstructor_cuda.py,sha256=m_3GzG44PRyiSEfTvYjgr5atLwl26hMfZOMyqTWxp0g,1644
 nabu/reconstruction/rings.py,sha256=mpbCLuFM_6Uy9oNJkyQ8tZwhGhrbWtzRlArSRsC90bI,9527
-nabu/reconstruction/rings_cuda.py,sha256=yBGv_MITcWzD1VWLIchloV8IB43D_5Rxf1MoqYoTvMw,13704
+nabu/reconstruction/rings_cuda.py,sha256=yWUQ-XK-2htZ59GM5aNORA4sjxUswEwWUZuWqKJXiNY,14878
 nabu/reconstruction/sinogram.py,sha256=KTSGP_JJABf4Yr9l628HPbyWsBnpbnyGKyPEq3ZrPIE,17026
 nabu/reconstruction/sinogram_cuda.py,sha256=DmTWdI9JhINjBpBuPiEt5mSqFmqu2FitIV94g3hSTAI,10659
 nabu/reconstruction/sinogram_opencl.py,sha256=vxJa5BeOd2NVdUayXYfQGAfO1AEbJfTGotuijT8qgCs,1486
@@ -262,12 +262,11 @@ nabu/resources/templates/id16_holo.conf,sha256=sDd_rEJGZjOGVAsGub5sT2arfXDnc_sxy
 nabu/resources/templates/id16a_fluo.conf,sha256=Nz1etzO2fSwksi7CThWJ5T1kZEdyBe8rMO7puNJ93Hc,542
 nabu/resources/templates/id19_pag.conf,sha256=u4fFPEBprzOW9_5_ChkIgowQcYpLhjmA8Gwm5XgC4Jc,384
 nabu/resources/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nabu/resources/tests/test_extract.py,sha256=msYWFP96LjpEntq1ucTWgKZMhUvZcLpJ-AQB3oGOh2E,206
 nabu/resources/tests/test_nxflatfield.py,sha256=XRGbYwqJv0NYAVQnAB224TwTZP_W2Bs3-yu0zQnDzEM,4179
 nabu/resources/tests/test_units.py,sha256=F2jFTck-1UwYET1MwTtX6ntzYUosfwOJkugSencGgz8,2155
 nabu/stitching/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nabu/stitching/alignment.py,sha256=2ehpuWDz38AFAoJk3yA0DXf-18Kb329YaCCBBpa7Txc,9078
-nabu/stitching/config.py,sha256=CP5g3f4sXpUBLAlG7LRg-90Ebon-janurbuORgYGi1c,52783
+nabu/stitching/config.py,sha256=C7O7np7nZryL6T33Mwe3sf7Ox75BHjoW78WmJ2TD53Q,52784
 nabu/stitching/definitions.py,sha256=JbmYwXKxOTYCr2LDXbHO-uNE2OLOBm4ir9AQ7e-Q3lY,158
 nabu/stitching/frame_composition.py,sha256=7HebOFzSBirJT-MG10T7dzR8Gu0YVwfJb27LDk8lln4,6687
 nabu/stitching/overlap.py,sha256=JkLM8gNyacEY7BE9vyF8M28Rer97-ExK8ZEvOKeFbPw,17200
@@ -279,15 +278,15 @@ nabu/stitching/y_stitching.py,sha256=Urt2lBXokxXxX5HFHEiLBqC69yy5b_KyuKFoU8smah4
 nabu/stitching/z_stitching.py,sha256=gNwj7qWvDFQaGroLVoQnKBPlbvr_CReUQEqxW15m2Ag,1835
 nabu/stitching/stitcher/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nabu/stitching/stitcher/base.py,sha256=t6nb9pWPQjijVjlUO-LHauPUxohjwhTkpo-X0Yj1VV8,4229
-nabu/stitching/stitcher/post_processing.py,sha256=PDjMaFRLsnX_UD-vVviiOjzQ8DRewaJ_06XVFp183zE,26154
-nabu/stitching/stitcher/pre_processing.py,sha256=RpaJcgP2bhxqRXiX6GQUps7WSy9ThzYa0PgAV4GgZR4,51404
-nabu/stitching/stitcher/single_axis.py,sha256=INsUgWmSKAcuFiE7NhJ72ChRLBqrlaUCSW6PG19XrYE,19978
+nabu/stitching/stitcher/post_processing.py,sha256=3sEF0M6A4uQPKdtYNXm3Fx8Zh3RREFbdryObhtu8M2c,26811
+nabu/stitching/stitcher/pre_processing.py,sha256=pI1ypS6HVTwb-OBXPKT5tXv-wQa7noetesV2GuUHShg,51416
+nabu/stitching/stitcher/single_axis.py,sha256=4nwdD66rGNqoABBwaB2f50Liv_vcMiT0Hfk2v_93Qmw,20033
 nabu/stitching/stitcher/stitcher.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nabu/stitching/stitcher/y_stitcher.py,sha256=KXwkyw6cCFcuSBCq5OyAait2Ob_5WRrtawrAlAhk60k,317
-nabu/stitching/stitcher/z_stitcher.py,sha256=S22nkQZ_6NwQm8h9mOhMvEZgUxXGQf6xadR5j6A91gI,1360
-nabu/stitching/stitcher/dumper/__init__.py,sha256=065KlsJai-Q3BnfuzmTP4XzO9wDV2a0CjlMdcV28Hc8,176
+nabu/stitching/stitcher/z_stitcher.py,sha256=pb8IezJOD9U7hTc6LCExRtkxOgBsUUCgf4G8yuvq11k,1397
+nabu/stitching/stitcher/dumper/__init__.py,sha256=FcSlb-AvGWZHm_4x9GYvmTrB1488vKeHv6uVR1pKAa0,243
 nabu/stitching/stitcher/dumper/base.py,sha256=hhImPme-E7_o_wXSduqVP0AeojpCj2QQjyfGGqmV6tc,3443
-nabu/stitching/stitcher/dumper/postprocessing.py,sha256=DShYc3hDfrUtyK2LEG9DNO42r9SdeUiMGEChKq-uNuM,14352
+nabu/stitching/stitcher/dumper/postprocessing.py,sha256=sdwD6QgoSzTbaUnsNuhTuNqCXorTxQabkSLAXc1f9w0,18258
 nabu/stitching/stitcher/dumper/preprocessing.py,sha256=7qOx27p92Tbbiah6gYEjkxfax7L8ictdrvzqfDm3vHo,2219
 nabu/stitching/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nabu/stitching/tests/test_alignment.py,sha256=MACak1ILOr8nRKeT0mWfMd-ZvhCl3SWjjcp6GjRbITc,2735
@@ -310,9 +309,9 @@ nabu/thirdparty/pore3d_deringer_munch.py,sha256=o4bisnFc-wMjuohWBT8wgWmfNehPQGtC
 nabu/thirdparty/tomocupy_remove_stripe.py,sha256=Khe4zFf0kRzu65Yxnvq58gt1ljOztqJGdMDhVAiM7lM,24363
 nabu/thirdparty/tomopy_phase.py,sha256=hK4oPpkogLOhv23XzzEXQY2u3r8fJvASY_bINVs6ERE,8634
 nabu/thirdparty/tomwer_load_flats_darks.py,sha256=ZNoVAinUb_wGYbfvs_4BVnWsjsQmNxSvCh1bWhR2WWg,5611
-nabu-2024.2.9.dist-info/LICENSE,sha256=1eAIPSnEsnSFNUODnLtNtQTs76exG3ZxJ1DJR6zoUBA,1066
-nabu-2024.2.9.dist-info/METADATA,sha256=IbwpeUPJlDnVH70Y0shTvexUML3YTap0wCiOw4lhWY4,5514
-nabu-2024.2.9.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-nabu-2024.2.9.dist-info/entry_points.txt,sha256=cJKGkBeykVL7uK3E4R0RLRqMXifTL2qdO573syPAvJc,1288
-nabu-2024.2.9.dist-info/top_level.txt,sha256=fsm_N3eXLRZk2QXF9OSKPNDPFXOz8FAQjHh5avT3dok,9
-nabu-2024.2.9.dist-info/RECORD,,
+nabu-2024.2.11.dist-info/licenses/LICENSE,sha256=1eAIPSnEsnSFNUODnLtNtQTs76exG3ZxJ1DJR6zoUBA,1066
+nabu-2024.2.11.dist-info/METADATA,sha256=dsMISANCk2gHi-RZbdyIXTUkAbqsmMoQ3A_TXENN9nI,5537
+nabu-2024.2.11.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+nabu-2024.2.11.dist-info/entry_points.txt,sha256=cJKGkBeykVL7uK3E4R0RLRqMXifTL2qdO573syPAvJc,1288
+nabu-2024.2.11.dist-info/top_level.txt,sha256=fsm_N3eXLRZk2QXF9OSKPNDPFXOz8FAQjHh5avT3dok,9
+nabu-2024.2.11.dist-info/RECORD,,

{nabu-2024.2.9.dist-info → nabu-2024.2.11.dist-info}/WHEEL

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

nabu/resources/tests/test_extract.py

@@ -1,9 +0,0 @@
-from nabu.utils import list_match_queries
-
-
-def test_list_match_queries():
-
-    # entry0000 .... entry0099
-    avail = ["entry%04d" % i for i in range(100)]
-    query = "entry0000"
-    list_match_queries()