nabu 2024.2.10__tar.gz → 2024.2.12__tar.gz

{nabu-2024.2.10/nabu.egg-info → nabu-2024.2.12}/PKG-INFO

@@ -1,31 +1,10 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: nabu
-Version: 2024.2.10
+Version: 2024.2.12
 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>
-License: MIT License
-        
-        Copyright (c) 2020-2024 ESRF
-        
-        Permission is hereby granted, free of charge, to any person obtaining a copy
-        of this software and associated documentation files (the "Software"), to deal
-        in the Software without restriction, including without limitation the rights
-        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-        copies of the Software, and to permit persons to whom the Software is
-        furnished to do so, subject to the following conditions:
-        
-        The above copyright notice and this permission notice shall be included in all
-        copies or substantial portions of the Software.
-        
-        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-        SOFTWARE.
-        
+License-Expression: MIT
 Project-URL: Homepage, https://gitlab.esrf.fr/tomotools/nabu
 Project-URL: Documentation, http://www.silx.org/pub/nabu/doc
 Project-URL: Repository, https://gitlab.esrf.fr/tomotools/nabu/-/releases
@@ -40,7 +19,6 @@ Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Environment :: Console
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: Unix
 Classifier: Operating System :: MacOS :: MacOS X
 Classifier: Operating System :: POSIX
@@ -53,7 +31,7 @@ Requires-Dist: numpy<2,>1.9.0
 Requires-Dist: scipy
 Requires-Dist: h5py>=3.0
 Requires-Dist: silx>=0.15.0
-Requires-Dist: tomoscan>=2.1.0
+Requires-Dist: tomoscan>=2.1.5
 Requires-Dist: psutil
 Requires-Dist: pytest
 Requires-Dist: tifffile
@@ -78,6 +56,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.10 → nabu-2024.2.12}/nabu/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "2024.2.10"
+__version__ = "2024.2.12"
 __nabu_modules__ = [
     "app",
     "cuda",

{nabu-2024.2.10 → nabu-2024.2.12}/nabu/io/cast_volume.py

@@ -1,4 +1,6 @@
 import os
+
+from tomoscan.esrf.volume.singleframebase import VolumeSingleFrameBase
 from nabu.misc.utils import rescale_data
 from nabu.pipeline.params import files_formats
 from tomoscan.volumebase import VolumeBase
@@ -176,6 +178,17 @@ def cast_volume(
     if not isinstance(output_data_type, numpy.dtype):
         raise TypeError(f"output_data_type is expected to be a {numpy.dtype}. {type(output_data_type)} provided")
 
+    # Make sure the output volume has the same "start_index" as input volume, if relevant
+    if isinstance(input_volume, VolumeSingleFrameBase) and isinstance(output_volume, VolumeSingleFrameBase):
+        try:
+            first_file_name = next(input_volume.browse_data_files())
+            start_idx = int(first_file_name.split(".")[0].split("_")[-1])
+        except (StopIteration, ValueError, TypeError):
+            # StopIteration: Input volume has no file - should not happen
+            # ValueError / TypeError: fail to convert to int, something wrong when extracting slice number (non-default file name scheme)
+            start_idx = 0
+        output_volume.start_index = start_idx
+
     # start processing
     #  check for data_min and data_max
     if data_min is None or data_max is None:

{nabu-2024.2.10 → nabu-2024.2.12}/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-2024.2.10 → nabu-2024.2.12}/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-2024.2.12/nabu/resources/tests/test_extract.py

@@ -0,0 +1,9 @@
+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()

{nabu-2024.2.10 → nabu-2024.2.12}/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-2024.2.10 → nabu-2024.2.12}/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-2024.2.10 → nabu-2024.2.12}/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-2024.2.10 → nabu-2024.2.12}/nabu/stitching/stitcher/post_processing.py

@@ -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-2024.2.10 → nabu-2024.2.12}/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-2024.2.10 → nabu-2024.2.12}/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.10 → nabu-2024.2.12/nabu.egg-info}/PKG-INFO

@@ -1,31 +1,10 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: nabu
-Version: 2024.2.10
+Version: 2024.2.12
 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>
-License: MIT License
-        
-        Copyright (c) 2020-2024 ESRF
-        
-        Permission is hereby granted, free of charge, to any person obtaining a copy
-        of this software and associated documentation files (the "Software"), to deal
-        in the Software without restriction, including without limitation the rights
-        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-        copies of the Software, and to permit persons to whom the Software is
-        furnished to do so, subject to the following conditions:
-        
-        The above copyright notice and this permission notice shall be included in all
-        copies or substantial portions of the Software.
-        
-        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-        SOFTWARE.
-        
+License-Expression: MIT
 Project-URL: Homepage, https://gitlab.esrf.fr/tomotools/nabu
 Project-URL: Documentation, http://www.silx.org/pub/nabu/doc
 Project-URL: Repository, https://gitlab.esrf.fr/tomotools/nabu/-/releases
@@ -40,7 +19,6 @@ Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Environment :: Console
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: Unix
 Classifier: Operating System :: MacOS :: MacOS X
 Classifier: Operating System :: POSIX
@@ -53,7 +31,7 @@ Requires-Dist: numpy<2,>1.9.0
 Requires-Dist: scipy
 Requires-Dist: h5py>=3.0
 Requires-Dist: silx>=0.15.0
-Requires-Dist: tomoscan>=2.1.0
+Requires-Dist: tomoscan>=2.1.5
 Requires-Dist: psutil
 Requires-Dist: pytest
 Requires-Dist: tifffile
@@ -78,6 +56,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.10 → nabu-2024.2.12}/nabu.egg-info/SOURCES.txt

@@ -271,6 +271,7 @@ nabu/resources/templates/id16_holo.conf
 nabu/resources/templates/id16a_fluo.conf
 nabu/resources/templates/id19_pag.conf
 nabu/resources/tests/__init__.py
+nabu/resources/tests/test_extract.py
 nabu/resources/tests/test_nxflatfield.py
 nabu/resources/tests/test_units.py
 nabu/stitching/__init__.py

{nabu-2024.2.10 → nabu-2024.2.12}/nabu.egg-info/requires.txt

@@ -2,7 +2,7 @@ numpy<2,>1.9.0
 scipy
 h5py>=3.0
 silx>=0.15.0
-tomoscan>=2.1.0
+tomoscan>=2.1.5
 psutil
 pytest
 tifffile

{nabu-2024.2.10 → nabu-2024.2.12}/nabu.egg-info/top_level.txt

@@ -1,3 +1,4 @@
 dist
 doc
 nabu
+scripts

{nabu-2024.2.10 → nabu-2024.2.12}/pyproject.toml

@@ -29,7 +29,8 @@ keywords = [
     "Ring artefact correction",
     "Geometric calibration",
 ]
-license = {file = "LICENSE"}
+license = "MIT"
+license-files = ["LICENSE"]
 classifiers = [
     "Development Status :: 5 - Production/Stable",
     "Intended Audience :: Developers",
@@ -40,7 +41,6 @@ classifiers = [
     "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Environment :: Console",
-    "License :: OSI Approved :: MIT License",
     "Operating System :: Unix",
     "Operating System :: MacOS :: MacOS X",
     "Operating System :: POSIX",
@@ -53,7 +53,7 @@ dependencies = [
     "scipy",
     "h5py>=3.0",
     "silx >= 0.15.0",
-    "tomoscan >= 2.1.0",
+    "tomoscan >= 2.1.5",
     "psutil",
     "pytest",
     "tifffile",