nabu 2024.2.4__py3-none-any.whl → 2025.1.0.dev4__py3-none-any.whl

nabu/estimation/alignment.py

@@ -87,20 +87,20 @@ class AlignmentBase:
         if not len(shape_stack) == 3:
             raise ValueError(
                 "A stack of 2-dimensional images is required. Shape of stack: %s"
-                % (" ".join(("%d" % x for x in shape_stack)))
+                % (" ".join("%d" % x for x in shape_stack))
             )
         if not len(shape_pos) == 1:
             raise ValueError(
                 "Positions need to be a 1-dimensional array. Shape of the positions variable: %s"
-                % (" ".join(("%d" % x for x in shape_pos)))
+                % (" ".join("%d" % x for x in shape_pos))
             )
         if not shape_stack[0] == shape_pos[0]:
             raise ValueError(
                 "The same number of images and positions is required."
                 + " Shape of stack: %s, shape of positions variable: %s"
                 % (
-                    " ".join(("%d" % x for x in shape_stack)),
-                    " ".join(("%d" % x for x in shape_pos)),
+                    " ".join("%d" % x for x in shape_stack),
+                    " ".join("%d" % x for x in shape_pos),
                 )
             )
 
@@ -110,18 +110,18 @@ class AlignmentBase:
         shape_2 = np.squeeze(img_2).shape
         if not len(shape_1) == 2:
             raise ValueError(
-                "Images need to be 2-dimensional. Shape of image #1: %s" % (" ".join(("%d" % x for x in shape_1)))
+                "Images need to be 2-dimensional. Shape of image #1: %s" % (" ".join("%d" % x for x in shape_1))
             )
         if not len(shape_2) == 2:
             raise ValueError(
-                "Images need to be 2-dimensional. Shape of image #2: %s" % (" ".join(("%d" % x for x in shape_2)))
+                "Images need to be 2-dimensional. Shape of image #2: %s" % (" ".join("%d" % x for x in shape_2))
             )
         if not np.all(shape_1 == shape_2):
             raise ValueError(
                 "Images need to be of the same shape. Shape of image #1: %s, image #2: %s"
                 % (
-                    " ".join(("%d" % x for x in shape_1)),
-                    " ".join(("%d" % x for x in shape_2)),
+                    " ".join("%d" % x for x in shape_1),
+                    " ".join("%d" % x for x in shape_2),
                 )
             )
 
@@ -153,7 +153,7 @@ class AlignmentBase:
         if not (len(f_vals.shape) == 2):
             raise ValueError(
                 "The fitted values should form a 2-dimensional array. Array of shape: [%s] was given."
-                % (" ".join(("%d" % s for s in f_vals.shape)))
+                % (" ".join("%d" % s for s in f_vals.shape))
             )
         if fy is None:
             fy_half_size = (f_vals.shape[0] - 1) / 2
@@ -161,7 +161,7 @@ class AlignmentBase:
         elif not (len(fy.shape) == 1 and np.all(fy.size == f_vals.shape[0])):
             raise ValueError(
                 "Vertical coordinates should have the same length as values matrix. Sizes of fy: %d, f_vals: [%s]"
-                % (fy.size, " ".join(("%d" % s for s in f_vals.shape)))
+                % (fy.size, " ".join("%d" % s for s in f_vals.shape))
             )
         if fx is None:
             fx_half_size = (f_vals.shape[1] - 1) / 2
@@ -169,7 +169,7 @@ class AlignmentBase:
         elif not (len(fx.shape) == 1 and np.all(fx.size == f_vals.shape[1])):
             raise ValueError(
                 "Horizontal coordinates should have the same length as values matrix. Sizes of fx: %d, f_vals: [%s]"
-                % (fx.size, " ".join(("%d" % s for s in f_vals.shape)))
+                % (fx.size, " ".join("%d" % s for s in f_vals.shape))
             )
 
         fy, fx = np.meshgrid(fy, fx, indexing="ij")
@@ -190,14 +190,7 @@ class AlignmentBase:
         vertex_max_yx = [np.max(fy), np.max(fx)]
         if np.any(vertex_yx < vertex_min_yx) or np.any(vertex_yx > vertex_max_yx):
             raise ValueError(
-                "Fitted (y: {}, x: {}) positions are outside the input margins y: [{}, {}], and x: [{}, {}]".format(
-                    vertex_yx[0],
-                    vertex_yx[1],
-                    vertex_min_yx[0],
-                    vertex_max_yx[0],
-                    vertex_min_yx[1],
-                    vertex_max_yx[1],
-                )
+                f"Fitted (y: {vertex_yx[0]}, x: {vertex_yx[1]}) positions are outside the input margins y: [{vertex_min_yx[0]}, {vertex_max_yx[0]}], and x: [{vertex_min_yx[1]}, {vertex_max_yx[1]}]"
             )
         return vertex_yx
 
@@ -225,10 +218,10 @@ class AlignmentBase:
         float
             Estimated function max, according to the coordinates in fx.
         """
-        if not len(f_vals.shape) in (1, 2):
+        if len(f_vals.shape) not in (1, 2):
             raise ValueError(
                 "The fitted values should be either one or a collection of 1-dimensional arrays. Array of shape: [%s] was given."
-                % (" ".join(("%d" % s for s in f_vals.shape)))
+                % (" ".join("%d" % s for s in f_vals.shape))
             )
         num_vals = f_vals.shape[0]
 
@@ -264,16 +257,9 @@ class AlignmentBase:
         upper_bound_ok = vertex_x < vertex_max_x
         if not np.all(lower_bound_ok * upper_bound_ok):
             if len(f_vals.shape) == 1:
-                message = "Fitted position {} is outide the input margins [{}, {}]".format(
-                    vertex_x, vertex_min_x, vertex_max_x
-                )
+                message = f"Fitted position {vertex_x} is outide the input margins [{vertex_min_x}, {vertex_max_x}]"
             else:
-                message = "Fitted positions outside the input margins [{}, {}]: {} below and {} above".format(
-                    vertex_min_x,
-                    vertex_max_x,
-                    np.sum(1 - lower_bound_ok),
-                    np.sum(1 - upper_bound_ok),
-                )
+                message = f"Fitted positions outside the input margins [{vertex_min_x}, {vertex_max_x}]: {np.sum(1 - lower_bound_ok)} below and {np.sum(1 - upper_bound_ok)} above"
             raise ValueError(message)
         if return_vertex_val:
             vertex_val = coeffs[0, :] + vertex_x * coeffs[1, :] / 2
@@ -354,7 +340,7 @@ class AlignmentBase:
         if not (len(img_shape) == 2):
             raise ValueError(
                 "The input image should be either a 1 or 2-dimensional array. Array of shape: [%s] was given."
-                % (" ".join(("%d" % s for s in cc.shape)))
+                % (" ".join("%d" % s for s in cc.shape))
             )
         other_axis = (axis + 1) % 2
         # get pixel having the maximum value of the correlation array

nabu/estimation/cor.py

@@ -269,10 +269,9 @@ class CenterOfRotationSlidingWindow(CenterOfRotation):
         win_ind_max = np.argmax(diffs_mean)
 
         diffs_std = diffs_std.min() - diffs_std
-        if not win_ind_max == np.argmax(diffs_std):
+        if win_ind_max != np.argmax(diffs_std):
             self.logger.warning(
-                "Minimum mean difference and minimum std-dev of differences do not coincide. "
-                + "This means that the validity of the found solution might be questionable."
+                "Minimum mean difference and minimum std-dev of differences do not coincide. This means that the validity of the found solution might be questionable."
             )
             validity_check_result = cor_result_validity["questionable"]
         else:
@@ -435,10 +434,9 @@ class CenterOfRotationGrowingWindow(CenterOfRotation):
         win_ind_max = np.argmax(diffs_mean)
 
         diffs_std = diffs_std.min() - diffs_std
-        if not win_ind_max == np.argmax(diffs_std):
+        if win_ind_max != np.argmax(diffs_std):
             self.logger.warning(
-                "Minimum mean difference and minimum std-dev of differences do not coincide. "
-                + "This means that the validity of the found solution might be questionable."
+                "Minimum mean difference and minimum std-dev of differences do not coincide. This means that the validity of the found solution might be questionable."
             )
             validity_check_result = cor_result_validity["questionable"]
         else:
@@ -578,8 +576,7 @@ class CenterOfRotationAdaptiveSearch(CenterOfRotation):
 
         if lim_2 <= lim_1:
             message = (
-                "Image shape or cropped selection too small for global search."
-                + " After removal of the margins the search limits collide."
+                "Image shape or cropped selection too small for global search. After removal of the margins the search limits collide."
                 + " The cropped size is %d\n" % (dim_radio)
             )
             raise ValueError(message)
@@ -616,11 +613,11 @@ class CenterOfRotationAdaptiveSearch(CenterOfRotation):
                 if "positions are outside the input margins" in str(err):
                     x_cor = min(x_cor + x_cor * self.step_fraction, x_cor + (dim_radio - x_cor) * self.step_fraction)
                     continue
-            except:
-                message = "Unexpected error from base class CenterOfRotation.find_shift in CenterOfRotationAdaptiveSearch.find_shift  : {err}".format(
-                    err=err
+            except Exception as err:
+                self.logger.error(
+                    "Unexpected error from base class CenterOfRotation.find_shift in CenterOfRotationAdaptiveSearch.find_shift: %s"
+                    % (str(err))
                 )
-                self.logger.error(message)
                 raise
 
             p_1 = cor_position * 2
@@ -656,16 +653,13 @@ class CenterOfRotationAdaptiveSearch(CenterOfRotation):
                 diff_energy = np.array((piece_1 - piece_2) * (piece_1 - piece_2), "d").sum()
                 cost = diff_energy / energy
 
-                if not np.isnan(cost):
-                    if tmp_sigma * 2 > abs(x_cor_rel - cor_position):
-                        found_centers.append([cost, abs(x_cor_rel - cor_position), cor_position, energy])
+                if not np.isnan(cost) and tmp_sigma * 2 > abs(x_cor_rel - cor_position):
+                    found_centers.append([cost, abs(x_cor_rel - cor_position), cor_position, energy])
 
             x_cor = min(x_cor + x_cor * self.step_fraction, x_cor + (dim_radio - x_cor) * self.step_fraction)
 
         if len(found_centers) == 0:
-            message = "Unable to find any valid CoR candidate in {my_class}.find_shift ".format(
-                my_class=self.__class__.__name__
-            )
+            message = f"Unable to find any valid CoR candidate in {self.__class__.__name__}.find_shift "
             raise ValueError(message)
 
         # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -674,6 +668,7 @@ class CenterOfRotationAdaptiveSearch(CenterOfRotation):
 
         filtered_found_centers = []
         for i in range(len(found_centers)):
+            # ruff: noqa: SIM102
             if i > 0:
                 if abs(found_centers[i][2] - found_centers[i - 1][2]) < 0.5:
                     filtered_found_centers.append(found_centers[i])
@@ -711,8 +706,7 @@ class CenterOfRotationAdaptiveSearch(CenterOfRotation):
             validity_check_result = cor_result_validity["sound"]
         else:
             self.logger.warning(
-                "Minimum mean difference and minimum std-dev of differences do not coincide. "
-                + "This means that the validity of the found solution might be questionable."
+                "Minimum mean difference and minimum std-dev of differences do not coincide. This means that the validity of the found solution might be questionable."
             )
             validity_check_result = cor_result_validity["questionable"]
 
@@ -802,7 +796,7 @@ class CenterOfRotationOctaveAccurate(CenterOfRotation):
                 return res
         return res
 
-    def _interpolate(self, input, shift, mode="mean", interpolation_method="linear"):
+    def _interpolate(self, input_, shift, mode="mean", interpolation_method="linear"):
         """Applies to the input a translation by a vector `shift`. Based on
         `scipy.ndimage.affine_transform` function.
         JL: This Octave function was initially used in the refine clause of the local_correlation (Octave find_shift).
@@ -811,7 +805,7 @@ class CenterOfRotationOctaveAccurate(CenterOfRotation):
 
         Parameters
         ----------
-        input : array
+        input_ : array
             Array to which the translation is applied.
         shift : tuple, list or array of length 2.
         mode : str
@@ -862,19 +856,19 @@ class CenterOfRotationOctaveAccurate(CenterOfRotation):
 
         if mode == "mean":
             mode = "constant"
-            cval = input.mean()
-            return affine_transform(input, matrix, mode=mode, order=order, cval=cval)
+            cval = input_.mean()
+            return affine_transform(input_, matrix, mode=mode, order=order, cval=cval)
         elif mode not in admissible_modes:
             raise ValueError(f"Pad method is {mode} and should be in {admissible_modes}.")
 
-        return affine_transform(input, matrix, mode=mode, order=order)
+        return affine_transform(input_, matrix, mode=mode, order=order)
 
     def _local_correlation(
         self,
         z1,
         z2,
-        maxsize=[5, 5],
-        cor_estimate=[0, 0],
+        maxsize=(5, 5),
+        cor_estimate=(0, 0),
         refine=None,
         pmcc=False,
         normalize=True,
@@ -1005,7 +999,7 @@ class CenterOfRotationOctaveAccurate(CenterOfRotation):
                 z1p /= z1p.mean()
 
             for k in range(cc.shape[0]):
-                for l in range(cc.shape[1]):
+                for l in range(cc.shape[1]):  # noqa: E741
                     if pmcc:
                         z2p = z2[z2beg[0] - k : z2end[0] - k, z2beg[1] - l : z2end[1] - l].flatten()
                         std_z2p = z2p.std()
@@ -1096,7 +1090,7 @@ class CenterOfRotationOctaveAccurate(CenterOfRotation):
         padding_mode=None,
         low_pass=0.01,
         high_pass=None,
-        maxsize=[5, 5],
+        maxsize=(5, 5),
         refine=None,
         pmcc=False,
         normalize=True,

nabu/estimation/cor_sino.py

@@ -21,12 +21,10 @@ class SinoCor:
     """
 
     def __init__(self, img_1, img_2, logger=None):
-        """ """
         self.logger = LoggerOrPrint(logger)
         self.sx = img_1.shape[1]
 
         # algorithm cannot accept odd number of projs. This is handled in the SinoCORFinder class.
-        nproj2 = img_1.shape[0]
 
         # extract upper and lower part of sinogram, flipping H the upper part
         self.data1 = img_1
@@ -141,9 +139,6 @@ class SinoCor:
         xc1 = self.rcor_abs - int(xwin / 2)
         xc2 = self.sx - self.rcor_abs - int(xwin / 2) - 1
 
-        im1 = self.data1[:, xc1 : xc1 + xwin]
-        im2 = self.data2[:, xc2 : xc2 + xwin]
-
         pixs = p_sign * (np.arange(neighborhood) - ng2)
         diff0 = 1000000000.0
 
@@ -289,9 +284,8 @@ class CenterOfRotationFourierAngles:
 
     def _px(self, detector_width, abs_pos, near_width, near_std, crop_around_cor, near_step):
         sym_range = None
-        if abs_pos is not None:
-            if crop_around_cor:
-                sym_range = int(abs_pos - near_std * 2), int(abs_pos + near_std * 2)
+        if abs_pos is not None and crop_around_cor:
+            sym_range = int(abs_pos - near_std * 2), int(abs_pos + near_std * 2)
 
         window = near_width
         if sym_range is not None:

nabu/estimation/focus.py

@@ -159,10 +159,8 @@ class CameraFocus(CenterOfRotation):
 
         if self.verbose:
             self.logger.info(
-                "Fitted focus motor position:",
-                focus_pos,
-                "and corresponding image position:",
-                focus_ind,
+                "Fitted focus motor position: %s and corresponding image position: %s"
+                % (str(focus_pos), str(focus_ind))
             )
             f, ax = plt.subplots(1, 1)
             self._add_plot_window(f, ax=ax)
@@ -383,10 +381,8 @@ class CameraFocus(CenterOfRotation):
 
         if self.verbose:
             self.logger.info(
-                "Fitted focus motor position:",
-                focus_pos,
-                "and corresponding image position:",
-                focus_ind,
+                "Fitted focus motor position: %s and corresponding image position: %s"
+                % (str(focus_pos), str(focus_ind))
             )
             self.logger.info("Fitted tilts (to be divided by pixel size, and converted to deg): (v, h) %s" % tilts_vh)
             fig = plt.figure()

nabu/estimation/tests/test_alignment.py

@@ -2,6 +2,8 @@ import numpy as np
 import pytest
 from nabu.estimation.alignment import AlignmentBase
 
+# ruff: noqa: NPY002
+
 
 @pytest.fixture(scope="class")
 def bootstrap_base(request):

nabu/estimation/tests/test_tilt.py

@@ -1,7 +1,7 @@
 import pytest
 import numpy as np
 from nabu.estimation.tilt import CameraTilt
-from nabu.estimation.tests.test_cor import bootstrap_cor
+from nabu.estimation.tests.test_cor import bootstrap_cor  # noqa: F401
 
 try:
     import skimage.transform as skt  # noqa: F401

nabu/estimation/tilt.py

@@ -150,10 +150,11 @@ class CameraTilt(CenterOfRotation):
 
         if self.verbose:
             self.logger.info(
-                "Fitted center of rotation (pixels):",
-                cor_offset_pix,
-                "and camera tilt (degrees):",
-                tilt_deg,
+                "Fitted center of rotation (pixels): %s and camera tilt (degrees): %s"
+                % (
+                    str(cor_offset_pix),
+                    str(tilt_deg),
+                )
             )
             f, ax = plt.subplots(1, 1)
             self._add_plot_window(f, ax=ax)

nabu/io/cast_volume.py

@@ -12,7 +12,6 @@ from tomoscan.esrf.volume import (
 )
 from tomoscan.io import HDF5File
 from silx.io.utils import get_data
-from silx.utils.enum import Enum as _Enum
 import numpy
 from silx.io.url import DataUrl
 from typing import Optional
@@ -21,7 +20,7 @@ import logging
 _logger = logging.getLogger(__name__)
 
 
-__all__ = ["get_default_output_volume", "cast_volume"]
+__all__ = ["cast_volume", "get_default_output_volume"]
 
 _DEFAULT_OUTPUT_DIR = "vol_cast"
 
@@ -43,7 +42,7 @@ def get_default_output_volume(
     if not isinstance(input_volume, VolumeBase):
         raise TypeError(f"input_volume is expected to be an instance of {VolumeBase}")
     valid_file_formats = set(files_formats.values())
-    if not output_type in valid_file_formats:
+    if output_type not in valid_file_formats:
         raise ValueError(f"output_type is not a valid value ({output_type}). Valid values are {valid_file_formats}")
 
     if isinstance(input_volume, (EDFVolume, TIFFVolume, JP2KVolume)):
@@ -167,6 +166,7 @@ def cast_volume(
     if not isinstance(output_volume, VolumeBase):
         raise TypeError(f"output_volume is expected to be a {VolumeBase}. {type(output_volume)} provided")
 
+    # ruff: noqa: SIM105, S110
     try:
         output_data_type = numpy.dtype(
             output_data_type
@@ -285,7 +285,7 @@ def find_histogram(volume: VolumeBase, scan: Optional[TomoScanBase] = None) -> O
                     ]
                 )
             else:
-                data_path = "/".join((volume.url.data_path(), "histogram/results/data"))
+                data_path = f"{volume.url.data_path()}/histogram/results/data"
         else:
             # TODO: FIXME: in some case (if the users provides the full data_url and if the 'DATA_DATASET_NAME' is not used we
             # will endup with an invalid data_path. Hope this case will not happen. Anyway this is a case that we can't handle.)
@@ -343,7 +343,7 @@ def find_histogram(volume: VolumeBase, scan: Optional[TomoScanBase] = None) -> O
         return None
 
     with HDF5File(histogram_file, mode="r") as h5f:
-        if not data_path in h5f:
+        if data_path not in h5f:
             _logger.info(f"{data_path} in {histogram_file} not found")
             return None
         else:

nabu/io/detector_distortion.py

@@ -3,7 +3,6 @@ from scipy import sparse
 
 
 class DetectorDistortionBase:
-    """ """
 
     def __init__(self, detector_full_shape_vh=(0, 0)):
         """This is the basis class.
@@ -110,7 +109,7 @@ class DetectorDistortionBase:
             The sub_region contained (x_start, x_end)={(x_start, x_end)} which would slice the 
             full horizontal size which is {self.detector_full_shape_vh[1]}
             """
-            raise ValueError()
+            raise ValueError(message)
 
         x_start, x_end = 0, self.detector_full_shape_vh[1]
 
@@ -165,7 +164,8 @@ class DetectorDistortionMapsXZ(DetectorDistortionBase):
         Pixel (i,j) of the corrected image is obtained by interpolating the raw data at position
         ( map_z(i,j), map_x(i,j) ).
 
-        Parameters:
+        Parameters
+        ----------
             map_x : float 2D array
             map_z : float 2D array
         """
@@ -173,7 +173,6 @@ class DetectorDistortionMapsXZ(DetectorDistortionBase):
         self._build_full_transformation(map_x, map_z)
 
     def _build_full_transformation(self, map_x, map_z):
-        """ """
         detector_full_shape_vh = map_x.shape
         if detector_full_shape_vh != map_z.shape:
             message = f"""  map_x and map_z must have the same shape
@@ -185,7 +184,7 @@ class DetectorDistortionMapsXZ(DetectorDistortionBase):
 
         # padding
         sz, sx = detector_full_shape_vh
-        total_detector_npixs = sz * sx
+        # total_detector_npixs = sz * sx
         xs = np.clip(np.array(coordinates[1].flat), [[0]], [[sx - 1]])
         zs = np.clip(np.array(coordinates[0].flat), [[0]], [[sz - 1]])
 
@@ -253,7 +252,7 @@ class DetectorDistortionMapsXZ(DetectorDistortionBase):
             The sub_region contained (x_start, x_end)={(x_start, x_end)} which would slice the 
             full horizontal size which is {self.detector_full_shape_vh[1]}
             """
-            raise ValueError()
+            raise ValueError(message)
 
         x_start, x_end = 0, self.detector_full_shape_vh[1]
 

nabu/io/reader.py

@@ -619,7 +619,7 @@ class NXTomoReader(VolReaderBase):
             If provided, this function first argument must be the source buffer (3D array: stack of raw images),
             and the second argument must be the destination buffer (3D array, stack of output images). It can be None.
 
-        Other parameters
+        Other Parameters
         ----------------
         The other parameters are passed to "processing_func" if this parameter is not None.
 
@@ -769,7 +769,7 @@ class NXDarksFlats:
         reduced_frames = [self._reduce_func[method](frames, axis=0) for frames in raw_frames]
         reader = getattr(self, "%s_reader" % what)
         if as_dict:
-            return {k: v for k, v in zip([s.start for s in reader._image_key_slices], reduced_frames)}
+            return {k: v for k, v in zip([s.start for s in reader._image_key_slices], reduced_frames)}  # noqa: C416
         return reduced_frames
 
     def get_raw_darks(self, force_reload=False, as_multiple_array=True):
@@ -792,7 +792,7 @@ class NXDarksFlats:
 
     def get_reduced_current(self, h5_path="{entry}/control/data", method="median"):
         current = self.get_raw_current(h5_path=h5_path)
-        return {k: self._reduce_func[method](current[k]) for k in current.keys()}
+        return {k: self._reduce_func[method](current[k]) for k in current}
 
 
 class EDFStackReader(VolReaderBase):

nabu/io/reader_helical.py

@@ -1,4 +1,5 @@
-from .reader import *
+import numpy as np
+from .reader import ChunkReader, get_compacted_dataslices
 
 
 class ChunkReaderHelical(ChunkReader):
@@ -101,9 +102,9 @@ class ChunkReaderHelical(ChunkReader):
             self._load_multi(sub_total_prange_slice)
         else:
             if self.dataset_subsampling > 1:
-                assert (
-                    False
-                ), " in helica pipeline, load file _load_single has not yet been adapted to angular subsampling "
+                raise ValueError(
+                    "in helical pipeline, load file _load_single has not yet been adapted to angular subsampling"
+                )
             self._load_single(sub_total_prange_slice)
         self._loaded = True
 

nabu/io/tests/test_cast_volume.py

@@ -12,7 +12,7 @@ from tomoscan.esrf.volume import (
     MultiTIFFVolume,
     TIFFVolume,
 )
-from nabu.io.writer import __have_jp2k__
+from tomoscan.esrf.volume.jp2kvolume import has_glymur as __have_jp2k__
 from tomoscan.esrf.scan.edfscan import EDFTomoScan
 from tomoscan.esrf.scan.nxtomoscan import NXtomoScan
 import pytest
@@ -105,7 +105,7 @@ def test_find_histogram_hdf5_volume(tmp_path):
         scheme="silx",
     )
 
-    assert find_histogram(volume=HDF5Volume(file_path=h5_file, data_path="entry")) == None
+    assert find_histogram(volume=HDF5Volume(file_path=h5_file, data_path="entry")) is None
 
 
 def test_find_histogram_single_frame_volume(tmp_path):

nabu/io/tests/test_readers.py

@@ -47,7 +47,7 @@ class TestNXReader:
         with pytest.raises(FileNotFoundError):
             reader = NXTomoReader("/invalid/path", self.nx_data_path)
         with pytest.raises(KeyError):
-            reader = NXTomoReader(self.nx_fname, "/bad/data/path")
+            reader = NXTomoReader(self.nx_fname, "/bad/data/path")  # noqa: F841
 
     def test_simple_reads(self):
         """
@@ -120,7 +120,7 @@ class TestNXReader:
 
         for test_case in test_cases:
             for wrong_shape in test_case["wrong_shapes"]:
-                with pytest.raises(ValueError):
+                with pytest.raises(ValueError):  # noqa: PT012
                     data_buffer_wrong_shape = np.zeros(wrong_shape, dtype="f")
                     reader = NXTomoReader(
                         self.nx_fname,
@@ -171,7 +171,7 @@ class TestNXReader:
 
         distortion_corrector = DetectorDistortionBase(detector_full_shape_vh=data_desc.frame_shape)
         distortion_corrector.set_sub_region_transformation(target_sub_region=sub_region_xy)
-        adapted_subregion = distortion_corrector.get_adapted_subregion(sub_region_xy)
+        # adapted_subregion = distortion_corrector.get_adapted_subregion(sub_region_xy)
         sub_region = (slice(None, None), slice(*sub_region_xy[2:]), slice(*sub_region_xy[:2]))
 
         reader_distortion_corr = NXTomoReaderDistortionCorrection(
@@ -328,7 +328,7 @@ class TestEDFReader:
 
         distortion_corrector = DetectorDistortionBase(detector_full_shape_vh=self.frame_shape)
         distortion_corrector.set_sub_region_transformation(target_sub_region=sub_region_xy)
-        adapted_subregion = distortion_corrector.get_adapted_subregion(sub_region_xy)
+        # adapted_subregion = distortion_corrector.get_adapted_subregion(sub_region_xy)
         sub_region = (slice(None, None), slice(*sub_region_xy[2:]), slice(*sub_region_xy[:2]))
 
         reader_distortion_corr = EDFStackReaderDistortionCorrection(

nabu/io/tests/test_writers.py

@@ -80,7 +80,7 @@ class TestNXWriter:
         writer.write(self.data, "test_no_overwrite")
 
         writer2 = NXProcessWriter(fname, entry="entry0000", overwrite=False)
-        with pytest.raises((RuntimeError, OSError)) as ex:
+        with pytest.raises((RuntimeError, OSError)):
             writer2.write(self.data, "test_no_overwrite")
 
-        message = "Error should have been raised for trying to overwrite, but got the following: %s" % str(ex.value)
+        # message = "Error should have been raised for trying to overwrite, but got the following: %s" % str(ex.value)

nabu/io/utils.py

@@ -8,6 +8,8 @@ from tomoscan.volumebase import VolumeBase
 from tomoscan.esrf import EDFVolume, HDF5Volume, TIFFVolume, JP2KVolume, MultiTIFFVolume
 from tomoscan.io import HDF5File
 
+from nabu.utils import first_generator_item
+
 
 # This function might be moved elsewhere
 def get_compacted_dataslices(urls, subsampling=None, begin=0):
@@ -100,7 +102,7 @@ def get_compacted_dataslices(urls, subsampling=None, begin=0):
 
 def get_first_hdf5_entry(fname):
     with HDF5File(fname, "r") as fid:
-        entry = list(fid.keys())[0]
+        entry = first_generator_item(fid.keys())
     return entry
 
 
@@ -189,7 +191,7 @@ class _BaseReader(contextlib.AbstractContextManager):
         if url.scheme() not in ("silx", "h5py"):
             raise ValueError("Valid scheme are silx and h5py")
         if url.data_slice() is not None:
-            raise ValueError("Data slices are not managed. Data path should " "point to a bliss node (h5py.Group)")
+            raise ValueError("Data slices are not managed. Data path should point to a bliss node (h5py.Group)")
         self._url = url
         self._file_handler = None
 
@@ -207,7 +209,7 @@ class EntryReader(_BaseReader):
         else:
             entry = self._file_handler[self._url.data_path()]
         if not isinstance(entry, h5py.Group):
-            raise ValueError("Data path should point to a bliss node (h5py.Group)")
+            raise TypeError("Data path should point to a bliss node (h5py.Group)")
         return entry
 
 
@@ -218,7 +220,7 @@ class DatasetReader(_BaseReader):
         self._file_handler = HDF5File(self._url.file_path(), mode="r")
         entry = self._file_handler[self._url.data_path()]
         if not isinstance(entry, h5py.Dataset):
-            raise ValueError("Data path ({}) should point to a dataset (h5py.Dataset)".format(self._url.path()))
+            raise TypeError(f"Data path ({self._url.path()}) should point to a dataset (h5py.Dataset)")
         return entry
 
 
@@ -261,3 +263,5 @@ def get_output_volume(location: str, file_prefix: Optional[str], file_format: st
             return MultiTIFFVolume(file_path=location)
         else:
             return TIFFVolume(folder=location, volume_basename=file_prefix)
+    else:
+        raise ValueError