nabu 2024.2.0rc2__py3-none-any.whl → 2024.2.0rc4__py3-none-any.whl

doc/doc_config.py

@@ -0,0 +1,32 @@
+#!/usr/bin/env python
+
+from nabu.resources.nabu_config import nabu_config
+
+
+def generate(file_):
+    def write(content):
+        print(content, file=file_)
+    for section, values in nabu_config.items():
+        if section == "about":
+            continue
+        write("## %s\n" % section)
+        for key, val in values.items():
+            if val["type"] == "unsupported":
+                continue
+            write(val["help"] + "\n")
+            write(
+                "```ini\n%s = %s\n```"
+                % (key, val["default"])
+            )
+
+
+
+if __name__ == "__main__":
+
+    import sys, os
+    print(os.path.abspath(__file__))
+    exit(0)
+
+    fname = "/tmp/test.md"
+    with open(fname, "w") as f:
+        generate(f)

nabu/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "2024.2.0-rc2"
+__version__ = "2024.2.0-rc4"
 __nabu_modules__ = [
     "app",
     "cuda",

nabu/estimation/cor.py

@@ -239,7 +239,7 @@ class CenterOfRotationSlidingWindow(CenterOfRotation):
                 win_2_start = img_width // 2 - window_shift
         else:
             abs_pos = int(side + img_width // 2)
-            window_fraction = 0.2  # Hard-coded ?
+            window_fraction = 0.1  # Hard-coded ?
 
             window_width = round(window_fraction * img_width)
             window_shift = window_width // 2

nabu/pipeline/estimators.py

@@ -243,13 +243,13 @@ class CORFinder(CORFinderBase):
         # All find_shift() methods in self.search_methods have the same API with "img_1" and "img_2"
         cor_exec_kwargs = update_func_kwargs(self.cor_finder.find_shift, self.cor_options)
         cor_exec_kwargs["return_relative_to_middle"] = False
-        # FIXME
+        # ----- FIXME -----
         # 'self.cor_options' can contain 'side="from_file"', and we should not modify it directly
         # because it's entered by the user.
         # Either make a copy of self.cor_options, or change the inspect() mechanism
-        if cor_exec_kwargs["side"] == "from_file":
+        if cor_exec_kwargs.get("side", None) == "from_file":
             cor_exec_kwargs["side"] = self._lookup_side or "center"
-        #
+        # ------
         if self._lookup_side is not None:
             cor_exec_kwargs["side"] = self._lookup_side
         self.logger.debug("%s.find_shift(%s)" % (self.cor_finder.__class__.__name__, str(cor_exec_kwargs)))

nabu/pipeline/fullfield/chunked.py

@@ -668,7 +668,10 @@ class ChunkedPipeline:
             "jpeg2000_compression_ratio": options["jpeg2000_compression_ratio"],
             "float_clip_values": options["float_clip_values"],
             "tiff_single_file": options.get("tiff_single_file", False),
-            "single_output_file_initialized": getattr(self.process_config, "single_output_file_initialized", False),
+            "single_output_file_initialized": getattr(
+                self.process_config, "single_output_file_initialized", False
+            ),  # COMPAT.
+            "writer_initialized": getattr(self.process_config, "_writer_initialized", False),
             "raw_vol_metadata": {"voxelSize": self.dataset_info.pixel_size},  # legacy...
         }
         writer_extra_options.update(extra_options)
@@ -853,7 +856,8 @@ class ChunkedPipeline:
         self.writer.write_data(data)
         self.logger.info("Wrote %s" % self.writer.fname)
         self._write_histogram()
-        self.process_config.single_output_file_initialized = True
+        self.process_config.single_output_file_initialized = True  # COMPAT.
+        self.process_config._writer_initialized = True
 
     def _write_histogram(self):
         if "histogram" not in self.processing_steps:

nabu/pipeline/writer.py

@@ -1,5 +1,6 @@
 from os import path
 from tomoscan.esrf import TIFFVolume, MultiTIFFVolume, EDFVolume, JP2KVolume
+from tomoscan.esrf.volume.singleframebase import VolumeSingleFrameBase
 from ..utils import check_supported, get_num_threads
 from ..resources.logger import LoggerOrPrint
 from ..io.writer import NXProcessWriter, HSTVolVolume, NXVolVolume
@@ -113,6 +114,7 @@ class WriterManager:
         return vol_writer.data_url.file_path()
 
     def _init_writer(self):
+        self._writer_was_already_initialized = self.extra_options.get("writer_initialized", False)
         if self.file_format in ["tiff", "edf", "jp2", "hdf5"]:
             writer_kwargs = {
                 "folder": self.output_dir,
@@ -143,6 +145,11 @@ class WriterManager:
         self._h5_entry = self.metadata.get("entry", "entry")
         self.writer = self._writer_classes[self.file_format](**writer_kwargs)
         self.fname = self.get_fname(self.writer)
+        # In certain cases, tomoscan needs to remove any previous existing volume filess
+        # and avoid calling 'clean_output_data' when writing downstream (for chunk processing)
+        if isinstance(self.writer, VolumeSingleFrameBase):
+            self.writer.skip_existing_data_files_removal = self._writer_was_already_initialized
+        # ---
         if path.exists(self.fname):
             err = "File already exists: %s" % self.fname
             if self.overwrite:

nabu/reconstruction/astra.py

@@ -0,0 +1,244 @@
+try:
+    import astra
+
+    __have_astra__ = True
+except ImportError:
+    __have_astra__ = False
+    astra = None
+
+
+class AstraReconstructor:
+    """
+    Base class for reconstructors based on the Astra toolbox
+    """
+
+    default_extra_options = {
+        "axis_correction": None,
+        "clip_outer_circle": False,
+        "scale_factor": None,
+        "filter_cutoff": 1.0,
+        "outer_circle_value": 0.0,
+    }
+
+    def __init__(
+        self,
+        sinos_shape,
+        angles=None,
+        volume_shape=None,
+        rot_center=None,
+        pixel_size=None,
+        padding_mode="zeros",
+        filter_name=None,
+        slice_roi=None,
+        cuda_options=None,
+        extra_options=None,
+    ):
+        self._configure_extra_options(extra_options)
+        self._init_cuda(cuda_options)
+        self._set_sino_shape(sinos_shape)
+        self._orig_prog_geom = None
+        self._init_geometry(
+            source_origin_dist,
+            origin_detector_dist,
+            pixel_size,
+            angles,
+            volume_shape,
+            rot_center,
+            relative_z_position,
+            slice_roi,
+        )
+        self._init_fdk(padding_mode, filter_name)
+        self._alg_id = None
+        self._vol_id = None
+        self._proj_id = None
+
+    def _configure_extra_options(self, extra_options):
+        self.extra_options = self.default_extra_options.copy()
+        self.extra_options.update(extra_options or {})
+
+    def _init_cuda(self, cuda_options):
+        cuda_options = cuda_options or {}
+        self.cuda = CudaProcessing(**cuda_options)
+
+    def _set_sino_shape(self, sinos_shape):
+        if len(sinos_shape) != 3:
+            raise ValueError("Expected a 3D shape")
+        self.sinos_shape = sinos_shape
+        self.n_sinos, self.n_angles, self.prj_width = sinos_shape
+
+    def _set_pixel_size(self, pixel_size):
+        if pixel_size is None:
+            det_spacing_y = det_spacing_x = 1
+        elif np.iterable(pixel_size):
+            det_spacing_y, det_spacing_x = pixel_size
+        else:
+            # assuming scalar
+            det_spacing_y = det_spacing_x = pixel_size
+        self._det_spacing_y = det_spacing_y
+        self._det_spacing_x = det_spacing_x
+
+    def _set_slice_roi(self, slice_roi):
+        self.slice_roi = slice_roi
+        self._vol_geom_n_x = self.n_x
+        self._vol_geom_n_y = self.n_y
+        self._crop_data = True
+        if slice_roi is None:
+            return
+        start_x, end_x, start_y, end_y = slice_roi
+        if roi_is_centered(self.volume_shape[1:], (slice(start_y, end_y), slice(start_x, end_x))):
+            # Astra can only reconstruct subregion centered around the origin
+            self._vol_geom_n_x = self.n_x - start_x * 2
+            self._vol_geom_n_y = self.n_y - start_y * 2
+        else:
+            raise NotImplementedError(
+                "Astra supports only slice_roi centered around origin (got slice_roi=%s with n_x=%d, n_y=%d)"
+                % (str(slice_roi), self.n_x, self.n_y)
+            )
+
+    def _init_geometry(
+        self,
+        source_origin_dist,
+        origin_detector_dist,
+        pixel_size,
+        angles,
+        volume_shape,
+        rot_center,
+        relative_z_position,
+        slice_roi,
+    ):
+        if angles is None:
+            self.angles = np.linspace(0, 2 * np.pi, self.n_angles, endpoint=True)
+        else:
+            self.angles = angles
+        if volume_shape is None:
+            volume_shape = (self.sinos_shape[0], self.sinos_shape[2], self.sinos_shape[2])
+        self.volume_shape = volume_shape
+        self.n_z, self.n_y, self.n_x = self.volume_shape
+        self.source_origin_dist = source_origin_dist
+        self.origin_detector_dist = origin_detector_dist
+        self.magnification = 1 + origin_detector_dist / source_origin_dist
+        self._set_slice_roi(slice_roi)
+        self.vol_geom = astra.create_vol_geom(self._vol_geom_n_y, self._vol_geom_n_x, self.n_z)
+        self.vol_shape = astra.geom_size(self.vol_geom)
+        self._cor_shift = 0.0
+        self.rot_center = rot_center
+        if rot_center is not None:
+            self._cor_shift = (self.sinos_shape[-1] - 1) / 2.0 - rot_center
+        self._set_pixel_size(pixel_size)
+        self._axis_corrections = self.extra_options.get("axis_correction", None)
+        self._create_astra_proj_geometry(relative_z_position)
+
+    def _create_astra_proj_geometry(self, relative_z_position):
+        # This object has to be re-created each time, because once the modifications below are done,
+        # it is no more a "cone" geometry but a "cone_vec" geometry, and cannot be updated subsequently
+        # (see astra/functions.py:271)
+        self.proj_geom = astra.create_proj_geom(
+            "cone",
+            self._det_spacing_x,
+            self._det_spacing_y,
+            self.n_sinos,
+            self.prj_width,
+            self.angles,
+            self.source_origin_dist,
+            self.origin_detector_dist,
+        )
+        self.relative_z_position = relative_z_position or 0.0
+        # This will turn the geometry of type "cone" into a geometry of type "cone_vec"
+        if self._orig_prog_geom is None:
+            self._orig_prog_geom = self.proj_geom
+        self.proj_geom = astra.geom_postalignment(self.proj_geom, (self._cor_shift, 0))
+        # (src, detector_center, u, v) = (srcX, srcY, srcZ, dX, dY, dZ, uX, uY, uZ, vX, vY, vZ)
+        vecs = self.proj_geom["Vectors"]
+
+        # To adapt the center of rotation:
+        # dX = cor_shift * cos(theta) - origin_detector_dist * sin(theta)
+        # dY = origin_detector_dist * cos(theta) + cor_shift * sin(theta)
+        if self._axis_corrections is not None:
+            # should we check that dX and dY match the above formulas ?
+            cor_shifts = self._cor_shift + self._axis_corrections
+            vecs[:, 3] = cor_shifts * np.cos(self.angles) - self.origin_detector_dist * np.sin(self.angles)
+            vecs[:, 4] = self.origin_detector_dist * np.cos(self.angles) + cor_shifts * np.sin(self.angles)
+
+        # To adapt the z position:
+        # Component 2 of vecs is the z coordinate of the source, component 5 is the z component of the detector position
+        # We need to re-create the same inclination of the cone beam, thus we need to keep the inclination of the two z positions.
+        # The detector is centered on the rotation axis, thus moving it up or down, just moves it out of the reconstruction volume.
+        # We can bring back the detector in the correct volume position, by applying a rigid translation of both the detector and the source.
+        # The translation is exactly the amount that brought the detector up or down, but in the opposite direction.
+        vecs[:, 2] = -self.relative_z_position
+
+    def _set_output(self, volume):
+        if volume is not None:
+            expected_shape = self.vol_shape  # if not (self._crop_data) else self._output_cropped_shape
+            self.cuda.check_array(volume, expected_shape)
+            self.cuda.set_array("output", volume)
+        if volume is None:
+            self.cuda.allocate_array("output", self.vol_shape)
+        d_volume = self.cuda.get_array("output")
+        z, y, x = d_volume.shape
+        self._vol_link = astra.data3d.GPULink(d_volume.ptr, x, y, z, d_volume.strides[-2])
+        self._vol_id = astra.data3d.link("-vol", self.vol_geom, self._vol_link)
+
+    def _set_input(self, sinos):
+        self.cuda.check_array(sinos, self.sinos_shape)
+        self.cuda.set_array("sinos", sinos)  # self.cuda.sinos is now a GPU array
+        # TODO don't create new link/proj_id if ptr is the same ?
+        # But it seems Astra modifies the input sinogram while doing FDK, so this might be not relevant
+        d_sinos = self.cuda.get_array("sinos")
+
+        # self._proj_data_link = astra.data3d.GPULink(d_sinos.ptr, self.prj_width, self.n_angles, self.n_z, sinos.strides[-2])
+        self._proj_data_link = astra.data3d.GPULink(
+            d_sinos.ptr, self.prj_width, self.n_angles, self.n_sinos, d_sinos.strides[-2]
+        )
+        self._proj_id = astra.data3d.link("-sino", self.proj_geom, self._proj_data_link)
+
+    def _preprocess_data(self):
+        d_sinos = self.cuda.sinos
+        for i in range(d_sinos.shape[0]):
+            self.sino_filter.filter_sino(d_sinos[i], output=d_sinos[i])
+
+    def _update_reconstruction(self):
+        cfg = astra.astra_dict("BP3D_CUDA")
+        cfg["ReconstructionDataId"] = self._vol_id
+        cfg["ProjectionDataId"] = self._proj_id
+        if self._alg_id is not None:
+            astra.algorithm.delete(self._alg_id)
+        self._alg_id = astra.algorithm.create(cfg)
+
+    def reconstruct(self, sinos, output=None, relative_z_position=None):
+        """
+        sinos: numpy.ndarray or pycuda.gpuarray
+            Sinograms, with shape (n_sinograms, n_angles, width)
+        output: pycuda.gpuarray, optional
+            Output array. If not provided, a new numpy array is returned
+        relative_z_position: int, optional
+            Position of the central slice of the slab, with respect to the full stack of slices.
+            By default it is set to zero, meaning that the current slab is assumed in the middle of the stack
+        """
+        self._create_astra_proj_geometry(relative_z_position)
+        self._set_input(sinos)
+        self._set_output(output)
+        self._preprocess_data()
+        self._update_reconstruction()
+        astra.algorithm.run(self._alg_id)
+        #
+        # NB: Could also be done with
+        # from astra.experimental import direct_BP3D
+        # projector_id = astra.create_projector("cuda3d", self.proj_geom, self.vol_geom, options=None)
+        # direct_BP3D(projector_id, self._vol_link, self._proj_data_link)
+        #
+        result = self.cuda.get_array("output")
+        if output is None:
+            result = result.get()
+        if self.extra_options.get("scale_factor", None) is not None:
+            result *= np.float32(self.extra_options["scale_factor"])  # in-place for pycuda
+        self.cuda.recover_arrays_references(["sinos", "output"])
+        return result
+
+    def __del__(self):
+        if getattr(self, "_alg_id", None) is not None:
+            astra.algorithm.delete(self._alg_id)
+        if getattr(self, "_vol_id", None) is not None:
+            astra.data3d.delete(self._vol_id)
+        if getattr(self, "_proj_id", None) is not None:
+            astra.data3d.delete(self._proj_id)

nabu/resources/dataset_analyzer.py

@@ -52,7 +52,7 @@ class DatasetAnalyzer:
             "output_dir": None,
             "exclude_projections": None,
             "hdf5_entry": None,
-            "nx_version": 1.0,
+            # "nx_version": 1.0,
         }
         # --
         advanced_options.update(extra_options)
@@ -302,7 +302,7 @@ class EDFDatasetAnalyzer(DatasetAnalyzer):
         return np.deg2rad(self.dataset_scanner.rotation_angle())
 
     def get_reduced_flats(self, **reader_kwargs):
-        if self.flats in [None, {}]:
+        if self.raw_flats in [None, {}]:
             raise FileNotFoundError("No reduced flat ('refHST') found in %s" % self.location)
         # A few notes:
         # (1) In principle we could do the reduction (mean/median) from raw frames (ref_xxxx_yyyy)
@@ -311,15 +311,15 @@ class EDFDatasetAnalyzer(DatasetAnalyzer):
         #  (eg. subsampling, binning, distortion correction...)
         # (3) The following spawns one reader instance per file, which is not elegant,
         #   but in principle there are typically 1-2 reduced flats in a scan
-        readers = {k: EDFStackReader([self.flats[k].file_path()], **reader_kwargs) for k in self.flats.keys()}
-        return {k: readers[k].load_data()[0] for k in self.flats.keys()}
+        readers = {k: EDFStackReader([self.raw_flats[k].file_path()], **reader_kwargs) for k in self.raw_flats.keys()}
+        return {k: readers[k].load_data()[0] for k in self.raw_flats.keys()}
 
     def get_reduced_darks(self, **reader_kwargs):
         # See notes in get_reduced_flats() above
-        if self.darks in [None, {}]:
+        if self.raw_darks in [None, {}]:
             raise FileNotFoundError("No reduced dark ('darkend.edf' or 'dark.edf') found in %s" % self.location)
-        readers = {k: EDFStackReader([self.darks[k].file_path()], **reader_kwargs) for k in self.darks.keys()}
-        return {k: readers[k].load_data()[0] for k in self.darks.keys()}
+        readers = {k: EDFStackReader([self.raw_darks[k].file_path()], **reader_kwargs) for k in self.raw_darks.keys()}
+        return {k: readers[k].load_data()[0] for k in self.raw_darks.keys()}
 
     @property
     def files(self):
@@ -365,10 +365,10 @@ class HDF5DatasetAnalyzer(DatasetAnalyzer):
     def _get_dataset_hdf5_url(self):
         if len(self.projections) > 0:
             frames_to_take = self.projections
-        elif len(self.flats) > 0:
-            frames_to_take = self.flats
-        elif len(self.darks) > 0:
-            frames_to_take = self.darks
+        elif len(self.raw_flats) > 0:
+            frames_to_take = self.raw_flats
+        elif len(self.raw_darks) > 0:
+            frames_to_take = self.raw_darks
         else:
             raise ValueError("No projections, no flats and no darks ?!")
         first_proj_idx = sorted(frames_to_take.keys())[0]

{nabu-2024.2.0rc2.dist-info → nabu-2024.2.0rc4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nabu
-Version: 2024.2.0rc2
+Version: 2024.2.0rc4
 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>
@@ -53,7 +53,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.0a14
+Requires-Dist: tomoscan >=2.1.0
 Requires-Dist: psutil
 Requires-Dist: pytest
 Requires-Dist: tifffile

{nabu-2024.2.0rc2.dist-info → nabu-2024.2.0rc4.dist-info}/RECORD

@@ -1,7 +1,8 @@
 doc/conf.py,sha256=3xtCarCHrXPr50GbeRDuH-o3Jzojw7mpr7vpGfZPLAE,3787
 doc/create_conf_doc.py,sha256=IVOdP70KvbW9WS_UQu3Iyd0YfS60E2fJ5IDtQ_s4cDw,1143
+doc/doc_config.py,sha256=anqeOVjqE2e7eVzg7yuh9dvIneTkrA5doGl1cVBqT7Q,730
 doc/get_mathjax.py,sha256=VIvKRCdDuF2VoY8JD3mSey9XX13AZMmwTJBHdt1tUs4,1012
-nabu/__init__.py,sha256=GU7YEox3KaUtQMTS4mUVSVO6IWhXqQ_Ad6wWGkVsDyk,274
+nabu/__init__.py,sha256=NEQPS4U8T5nfg0_kumGk9YWMlO5RkFqOihedIBF9z_A,274
 nabu/tests.py,sha256=cew9OY2uTyncHI_HM32W8CP6B1GTGKaOW65XtMEqs7o,1417
 nabu/testutils.py,sha256=VkSL9tbY0XEH49Z5OjDFFhzkSxrCv4UIuvSVFgegSUY,7632
 nabu/utils.py,sha256=V1B_sD54XGNKn5pORa2yNCATyswOzybey3sv8BuIYWY,26355
@@ -31,7 +32,6 @@ nabu/app/shrink_dataset.py,sha256=P9dorO0Q-gPAWgSHyZi3XQp4jkMTJacDYzNvJY4oh98,35
 nabu/app/stitching.py,sha256=T5nQVp7D6jNg86vMi8BCQANJJsKstvwItJWZDs05t64,4194
 nabu/app/utils.py,sha256=XUBRWDmth4i3BZHd27rfarFAUP7OEcsMeVmDJ6T4EXA,1178
 nabu/app/validator.py,sha256=IR-DcUV5h1Fc5CChBfBIaglrGpfKNICX7tGirAroMiw,3368
-nabu/app/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nabu/app/tests/test_reduce_dark_flat.py,sha256=qD52JL6fgJh7UEeGLssmsmGkqPTL8YTu29Hj1Nk9Bjg,2725
 nabu/cuda/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nabu/cuda/convolution.py,sha256=n8KsJ7IZdPOs_K5QZC6qblnOvIKYwxtdt03oNa0GiMU,241
@@ -64,7 +64,7 @@ nabu/cuda/src/transpose.cu,sha256=Enim7vLxTCFZbK3BmYdQ6ZatA_FLp6601VOSl8iGFjg,47
 nabu/cuda/tests/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 nabu/estimation/__init__.py,sha256=HWE3ivArjlJx4FjFh2Q73VmpIyzod80KTmXvFo1AP1s,379
 nabu/estimation/alignment.py,sha256=DWe4PBLsAOt95m_UEinVXUhXyYDmV0NOHW-oHpVEjVk,21185
-nabu/estimation/cor.py,sha256=b8dv047g8AYL9mV6vAAkIloSgNeN3w2bozZY1ox7bII,50415
+nabu/estimation/cor.py,sha256=HcE0xw0ECSkx_kG30taw964rWZwh6lfgg8m9wnKdXik,50415
 nabu/estimation/cor_sino.py,sha256=Wh0t8Ak6h8kf3rn5azD1XqD4e0Xa90oZUy90n9Ory8c,19116
 nabu/estimation/distortion.py,sha256=DEXizQpgHBXmrhbQ0kuEchicxmiDgmU2qrh8bCgSezg,4701
 nabu/estimation/focus.py,sha256=I2B5ODmGToE0-Y-B_6v1zJv7XcWdkXPZzrs2uYpiPlc,18029
@@ -131,14 +131,14 @@ nabu/pipeline/config_validators.py,sha256=ocAKB26iRjm5qs1Ay4B_rgGcg8aZjAP34XpEZR
 nabu/pipeline/datadump.py,sha256=lK36YlsVSeE4fdkD7cgVCl4RKn-Wa9KYgOw4DNtH8Ow,6982
 nabu/pipeline/dataset_validator.py,sha256=etQw9NC_YGsdWCgjsn8aJ3WfvcRuJlLVZlWoqhvvo-8,9263
 nabu/pipeline/detector_distortion_provider.py,sha256=ru1AxbcuO-FA8FYooPBWgp1lzdSDUtzFUC1A_sS8jME,920
-nabu/pipeline/estimators.py,sha256=a-6ISR6ii8J7xMvr6oKFJO8yMFT_QzO7L5kMcg4RJmw,40269
+nabu/pipeline/estimators.py,sha256=AZXDmz7hngbVEfytpcu3E2QkOG4IqtXjQN8uUMBJTa0,40298
 nabu/pipeline/params.py,sha256=EoovjCUTUXmj5HQ3qE0RhP7XD3cndaiT21TdvjTIhE8,3746
 nabu/pipeline/processconfig.py,sha256=3xx2Lc8uEzPAqSMwUncr4RCiCtKn2c7wnXXbPSn8GNo,7719
 nabu/pipeline/reader.py,sha256=wkxPHYOi_C8dHNc7kddB8AMtFuW7GjsP_tm6SJeHlEY,4792
 nabu/pipeline/utils.py,sha256=0O1GLyYLQ8oA2ErI_T3BIfEVjP48dl-u_gl91eX7pjU,3543
-nabu/pipeline/writer.py,sha256=V4b6tGHMj5KpTl2RmDltSP-a-BEw5lfR96cBAdm_6FQ,7649
+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=LxT9LxViYIihgy0N34BgY9uvMlupfJYiX9l6Hp2EdlA,40348
+nabu/pipeline/fullfield/chunked.py,sha256=_LauzrZSMO0y6E1g_zYFweK8wb07u1p2JulrVDRnA04,40549
 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
@@ -221,6 +221,7 @@ nabu/processing/tests/test_rotation.py,sha256=vedRXV9RePJywBKoyBkGANP1dhZCjphbYO
 nabu/processing/tests/test_transpose.py,sha256=hTG17wTaB5Wv6twbW3ZFhBv6BYfqJY7DTQPoO0-KdkM,2760
 nabu/processing/tests/test_unsharp.py,sha256=R3ovbwDDp3ccy2A8t6CcUVELXRWkED5EnQdN2FQOfQM,4391
 nabu/reconstruction/__init__.py,sha256=EmKVvx_-FJvzJngG4ielIC7FhMCpI1Waaflg_lF44tk,163
+nabu/reconstruction/astra.py,sha256=qTAkUe6UGN5CRqS9ie-nDsvZTYrXBIjUl0JzPKQjkMg,10431
 nabu/reconstruction/cone.py,sha256=WObFcHvv7NkaZhUoC_xTlvl95f38AjsAJkePSOzngVk,18870
 nabu/reconstruction/fbp.py,sha256=uwEniGdEOn1atc9mTAHEDeF1y-ZqneifCKVr-ieHZss,5015
 nabu/reconstruction/fbp_base.py,sha256=DwZCilPXgGMRPV8_XfkWiaXUzWFM8rNBa8IyMdy5nno,17092
@@ -250,7 +251,7 @@ nabu/reconstruction/tests/test_reconstructor.py,sha256=3p2Wk_OqgZqkNOkhK_NJWlHkO
 nabu/reconstruction/tests/test_sino_normalization.py,sha256=fGv5Dlidxgm8ZC70Nk6oqVgpY2jzOW9NJaGlo44IJOo,3692
 nabu/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nabu/resources/cor.py,sha256=-mcrTbj3G7o4PP5E_gIRo2j6_-ADmMkkOc_0CyQv84c,170
-nabu/resources/dataset_analyzer.py,sha256=_M7EQcRgldhtGeXCsOUNdx6M1nlLRWW8rKPWMB-lfN0,18518
+nabu/resources/dataset_analyzer.py,sha256=e3AqYR9ORW9Q03mGYCiC66nXld-X0LPnx9E8X3zFIGU,18568
 nabu/resources/gpu.py,sha256=GgpMb5umRQAUsEDEAefb4wSA5qm4JSMhkWmCEpW3X9g,5702
 nabu/resources/logger.py,sha256=-lOzhN_sU4R3BIfC69aMj2O8S_ocsvXsmwkhWlcxVEc,3758
 nabu/resources/nxflatfield.py,sha256=XlhLYj1TmSQ4s36W48kn0lNTvqXlFCuZxKHfTveltow,9225
@@ -263,7 +264,6 @@ 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=pDFvgwPNH4n-UjhJibRH2vTkjDWYF2wSImUtfNq1ITo,220
 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
@@ -311,9 +311,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.0rc2.dist-info/LICENSE,sha256=1eAIPSnEsnSFNUODnLtNtQTs76exG3ZxJ1DJR6zoUBA,1066
-nabu-2024.2.0rc2.dist-info/METADATA,sha256=nJCwt8-vLEu5ZeqjsatPynMDbqdIILum0iPK23dEqD0,5544
-nabu-2024.2.0rc2.dist-info/WHEEL,sha256=5sUXSg9e4bi7lTLOHcm6QEYwO5TIF1TNbTSVFVjcJcc,92
-nabu-2024.2.0rc2.dist-info/entry_points.txt,sha256=cJKGkBeykVL7uK3E4R0RLRqMXifTL2qdO573syPAvJc,1288
-nabu-2024.2.0rc2.dist-info/top_level.txt,sha256=fsm_N3eXLRZk2QXF9OSKPNDPFXOz8FAQjHh5avT3dok,9
-nabu-2024.2.0rc2.dist-info/RECORD,,
+nabu-2024.2.0rc4.dist-info/LICENSE,sha256=1eAIPSnEsnSFNUODnLtNtQTs76exG3ZxJ1DJR6zoUBA,1066
+nabu-2024.2.0rc4.dist-info/METADATA,sha256=X82wyEoBnquYyUlKh6UBebcpBLAS9ieXX7EETWAe068,5541
+nabu-2024.2.0rc4.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+nabu-2024.2.0rc4.dist-info/entry_points.txt,sha256=cJKGkBeykVL7uK3E4R0RLRqMXifTL2qdO573syPAvJc,1288
+nabu-2024.2.0rc4.dist-info/top_level.txt,sha256=fsm_N3eXLRZk2QXF9OSKPNDPFXOz8FAQjHh5avT3dok,9
+nabu-2024.2.0rc4.dist-info/RECORD,,

{nabu-2024.2.0rc2.dist-info → nabu-2024.2.0rc4.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.41.1)
+Generator: bdist_wheel (0.42.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

nabu/resources/tests/test_extract.py

@@ -1,10 +0,0 @@
-import pytest
-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()