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

nabu/resources/gpu.py

@@ -131,7 +131,7 @@ def pick_gpus_auto(cuda_gpus, opencl_platforms, n_gpus):
         return (gpu1["device_id"] == gpu2["device_id"]) and (gpu1["name"] == gpu2["name"])
 
     def is_in_gpus(avail_gpus, query_gpu):
-        for gpu in avail_gpus:
+        for gpu in avail_gpus:  # noqa: SIM110
             if gpu_equal(gpu, query_gpu):
                 return True
         return False
@@ -142,8 +142,8 @@ def pick_gpus_auto(cuda_gpus, opencl_platforms, n_gpus):
     chosen_gpus = list(cuda_gpus.values())
     if len(chosen_gpus) >= n_gpus:
         return chosen_gpus
-    for platform, gpus in opencl_platforms.items():
-        for gpu_id, gpu in gpus.items():
+    for platform, gpus in opencl_platforms.items():  # noqa: PERF102
+        for gpu_id, gpu in gpus.items():  # noqa: PERF102
             if not (is_in_gpus(chosen_gpus, gpu)):
                 # TODO prioritize some OpenCL implementations ?
                 chosen_gpus.append(gpu)
@@ -166,5 +166,5 @@ def pick_gpus_nvidia(cuda_gpus, n_gpus):
     gpus_cc_sorted = sorted(gpus_cc, key=lambda x: x[1], reverse=True)
     res = []
     for i in range(n_gpus):
-        res.append(cuda_gpus[gpus_cc_sorted[i][0]])
+        res.append(cuda_gpus[gpus_cc_sorted[i][0]])  # noqa: PERF401
     return res

nabu/resources/logger.py

@@ -2,7 +2,7 @@ import logging
 import logging.config
 
 
-class Logger(object):
+class Logger:
     def __init__(self, loggername, level="DEBUG", logfile="logger.log", console=True):
         """
         Configure a Logger object.
@@ -30,7 +30,7 @@ class Logger(object):
 
     def _configure_logger(self):
         conf = self._get_default_config_dict()
-        for handler in conf["handlers"].keys():
+        for handler in conf["handlers"]:
             conf["handlers"][handler]["level"] = self.level.upper()
         conf["loggers"][self.loggername]["level"] = self.level.upper()
         if not (self.console):
@@ -103,7 +103,7 @@ def LoggerOrPrint(logger):
     return logger
 
 
-class PrinterLogger(object):
+class PrinterLogger:
     def __init__(self):
         methods = [
             "debug",
@@ -122,7 +122,7 @@ LogLevel = {
     "notset": logging.NOTSET,
     "debug": logging.DEBUG,
     "info": logging.INFO,
-    "warn": logging.WARN,
+    "warn": logging.WARNING,
     "warning": logging.WARNING,
     "error": logging.ERROR,
     "critical": logging.CRITICAL,

nabu/resources/nxflatfield.py

@@ -202,7 +202,7 @@ def update_dataset_info_flats_darks(dataset_info, flatfield_mode, output_dir=Non
     elif _can_load_from("output"):
         where_to_load_from = "output"
 
-    if where_to_load_from == None and flatfield_mode == "force-load":
+    if where_to_load_from is None and flatfield_mode == "force-load":
         raise ValueError("Could not load darks/flats (using 'force-load')")
 
     if where_to_load_from is not None:
@@ -218,7 +218,7 @@ def update_dataset_info_flats_darks(dataset_info, flatfield_mode, output_dir=Non
             setattr(
                 dataset_info,
                 frame_type,
-                {k: get_data(red_frames_dict[k]) for k in red_frames_dict.keys()},
+                {k: get_data(red_frames_dict[k]) for k in red_frames_dict},
             )
             if frame_type == "flats":
                 dataset_info.flats_srcurrent = red_frames_info.machine_electric_current

nabu/resources/tests/test_nxflatfield.py

@@ -83,8 +83,8 @@ class TestNXFlatField:
         update_dataset_info_flats_darks(dataset_info, True, output_dir=output_dir)
         # After reduction (median/mean), the flats/darks are located in another file.
         # median(series_1) goes to entry/flats/idx1, mean(series_2) goes to entry/flats/idx2, etc.
-        assert set(dataset_info.flats.keys()) == set(s.start for s in self.params["flats_pos"])
-        assert set(dataset_info.darks.keys()) == set(s.start for s in self.params["darks_pos"])
+        assert set(dataset_info.flats.keys()) == set(s.start for s in self.params["flats_pos"])  # noqa: C401
+        assert set(dataset_info.darks.keys()) == set(s.start for s in self.params["darks_pos"])  # noqa: C401
 
         # Check that the computations were correct
         # Loads the entire volume in memory ! So keep the data volume small for the tests
@@ -97,8 +97,8 @@ class TestNXFlatField:
             expected_darks[s.start] = self._reduction_func["darks"](data_volume[s.start : s.stop], axis=0)
 
         flats = dataset_info.flats
-        for idx in flats.keys():
+        for idx in flats:
             assert np.allclose(flats[idx], expected_flats[idx])
         darks = dataset_info.darks
-        for idx in darks.keys():
+        for idx in darks:
             assert np.allclose(darks[idx], expected_darks[idx])

nabu/stitching/alignment.py

@@ -2,9 +2,6 @@ import h5py
 import numpy
 from typing import Union
 from silx.utils.enum import Enum as _Enum
-from tomoscan.volumebase import VolumeBase
-from tomoscan.esrf.volume.hdf5volume import HDF5Volume
-from nabu.io.utils import DatasetReader
 
 
 class AlignmentAxis2(_Enum):
@@ -151,7 +148,7 @@ class PaddedRawData:
     @property
     def shape(self):
         if self._shape is None:
-            self._shape = tuple(
+            self._shape = tuple(  # noqa: C409
                 (
                     self._raw_data_shape[0],
                     numpy.sum(

nabu/stitching/config.py

@@ -1,5 +1,6 @@
 from math import ceil
-from typing import Any, Iterable, Optional, Union, Sized
+from typing import Optional, Union
+from collections.abc import Iterable, Sized
 from dataclasses import dataclass
 import numpy
 from pyunitsystem.metricsystem import MetricSystem
@@ -12,13 +13,12 @@ from ..pipeline.config_validators import (
     convert_to_bool,
 )
 from ..utils import concatenate_dict, convert_str_to_tuple
-from ..io.utils import get_output_volume
 from .overlap import OverlapStitchingStrategy
 from .utils.utils import ShiftAlgorithm
 from .definitions import StitchingType
 from .alignment import AlignmentAxis1, AlignmentAxis2
-from pyunitsystem.metricsystem import MetricSystem
 
+# ruff: noqa: S105
 
 KEY_IMG_REG_METHOD = "img_reg_method"
 
@@ -205,7 +205,7 @@ def _str_to_dict(my_str: Union[str, dict]):
 
 
 def _dict_to_str(ddict: dict):
-    return ";".join([f"{str(key)}={str(value)}" for key, value in ddict.items()])
+    return ";".join([f"{key!s}={value!s}" for key, value in ddict.items()])
 
 
 def str_to_shifts(my_str: Optional[str]) -> Union[str, tuple]:
@@ -235,8 +235,8 @@ def _valid_stitching_kernels_params(my_dict: Union[dict, str]):
         my_dict = _str_to_dict(my_str=my_dict)
 
     valid_keys = (KEY_THRESHOLD_FREQUENCY, KEY_SIDE)
-    for key in my_dict.keys():
-        if not key in valid_keys:
+    for key in my_dict:
+        if key not in valid_keys:
             raise KeyError(f"{key} is a unrecognized key")
     return my_dict
 
@@ -253,8 +253,8 @@ def _valid_shifts_params(my_dict: Union[dict, str]):
         KEY_LOW_PASS_FILTER,
         KEY_SIDE,
     )
-    for key in my_dict.keys():
-        if not key in valid_keys:
+    for key in my_dict:
+        if key not in valid_keys:
             raise KeyError(f"{key} is a unrecognized key")
     return my_dict
 
@@ -401,16 +401,17 @@ class NormalizationBySample:
             NORMALIZATION_BY_SAMPLE_WIDTH: self.width,
         }
 
-    def __eq__(self, __value: object) -> bool:
-        if not isinstance(__value, NormalizationBySample):
+    def __eq__(self, value: object, /) -> bool:
+        if not isinstance(value, NormalizationBySample):
             return False
         else:
-            return self.to_dict() == __value.to_dict()
+            return self.to_dict() == value.to_dict()
 
 
 @dataclass
 class SlurmConfig:
-    "configuration for slurm jobs"
+    """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
@@ -429,7 +430,7 @@ class SlurmConfig:
             )
 
     def to_dict(self) -> dict:
-        "dump configuration to dict"
+        """dump configuration to dict"""
         return {
             SLURM_PARTITION: self.partition if self.partition is not None else "",
             SLURM_MEM: self.mem,
@@ -459,15 +460,17 @@ class SlurmConfig:
         )
 
 
-def _cast_shift_to_str(shifts: Union[tuple, str, None]) -> str:
+def _cast_shift_to_str(shifts: Union[tuple, numpy.ndarray, str, None]) -> str:
     if shifts is None:
         return ""
     elif isinstance(shifts, ShiftAlgorithm):
         return shifts.value
     elif isinstance(shifts, str):
         return shifts
-    elif isinstance(shifts, (tuple, list)):
+    elif isinstance(shifts, (tuple, list, numpy.ndarray)):
         return ";".join([str(value) for value in shifts])
+    else:
+        raise TypeError(f"unexpected type: {type(shifts)}")
 
 
 @dataclass
@@ -771,7 +774,7 @@ class SingleAxisConfigMetaClass(type):
     warning: this class is used by tomwer as well
     """
 
-    def __new__(mcls, name, bases, attrs, axis=None):
+    def __new__(mcls, name, bases, attrs, axis=None):  # noqa: N804
         # assert axis is not None
         mcls = super().__new__(mcls, name, bases, attrs)
         mcls._axis = axis

nabu/stitching/frame_composition.py

@@ -31,7 +31,7 @@ class FrameComposition:
             )
 
     def compose(self, output_frame: numpy.ndarray, input_frames: tuple):
-        if not output_frame.ndim in (2, 3):
+        if output_frame.ndim not in (2, 3):
             raise TypeError(
                 f"output_frame is expected to be 2D (gray scale) or 3D (RGB(A)) and not {output_frame.ndim}"
             )
@@ -74,9 +74,10 @@ class FrameComposition:
         local_start_indices.extend(
             [ceil(key_line[1] + kernel.overlap_size / 2) for (key_line, kernel) in zip(key_lines, overlap_kernels)]
         )
-        local_end_indices = list(
-            [ceil(key_line[0] - kernel.overlap_size / 2) for (key_line, kernel) in zip(key_lines, overlap_kernels)]
-        )
+        local_end_indices = [
+            ceil(key_line[0] - kernel.overlap_size / 2) for (key_line, kernel) in zip(key_lines, overlap_kernels)
+        ]
+
         local_end_indices.append(frames[-1].shape[stitching_axis])
 
         for (
@@ -155,9 +156,6 @@ class FrameComposition:
             print(
                 f"stitch_frame[{stitch_global_start}:{stitch_global_end}] = stitched_frame_{i_frame}[{stitch_local_start}:{stitch_local_end}]"
             )
-        else:
-            i_frame += 1
-            raw_local_start, raw_local_end, raw_global_start, raw_global_end = list(raw_composition.browse())[-1]
-            print(
-                f"stitch_frame[{raw_global_start}:{raw_global_end}] = frame_{i_frame}[{raw_local_start}:{raw_local_end}]"
-            )
+        i_frame += 1
+        raw_local_start, raw_local_end, raw_global_start, raw_global_end = list(raw_composition.browse())[-1]
+        print(f"stitch_frame[{raw_global_start}:{raw_global_end}] = frame_{i_frame}[{raw_local_start}:{raw_local_end}]")

nabu/stitching/overlap.py

@@ -64,7 +64,7 @@ class ImageStichOverlapKernel(OverlapKernelBase):
                 f"frame_width is expected to be a positive int, {frame_unstitched_axis_size} - not {frame_unstitched_axis_size} ({type(frame_unstitched_axis_size)})"
             )
 
-        if not stitching_axis in (0, 1):
+        if stitching_axis not in (0, 1):
             raise ValueError(
                 "stitching_axis is expected to be the axis along which stitching must be done. It should be '0' or '1'"
             )
@@ -391,7 +391,7 @@ def check_overlaps(frames: Union[tuple, numpy.ndarray], positions: tuple, axis:
 
         :return: (tested_bounding_box, bounding_boxes_to_test)
         """
-        my_bounding_boxes = {bb_index: bb for bb_index, bb in enumerate(my_bounding_boxes)}
+        my_bounding_boxes = {bb_index: bb for bb_index, bb in enumerate(my_bounding_boxes)}  # noqa: C416
         bounding_boxes = dict(
             filter(
                 lambda pair: pair[0] not in (index - 1, index, index + 1),

nabu/stitching/slurm_utils.py

@@ -177,7 +177,7 @@ def split_slices(slices: Union[slice, tuple], n_parts: int):
         raise TypeError(f"slices type ({type(slices)}) is not handled. Must be a slice or an Iterable")
 
 
-def get_working_directory(obj: TomoObject) -> Optional[str]:
+def get_working_directory(obj: TomoObject) -> Optional[str]:  # noqa: PLR0911
     """
     return working directory for a specific TomoObject
     """
@@ -201,4 +201,4 @@ def get_working_directory(obj: TomoObject) -> Optional[str]:
         else:
             return os.path.abspath(os.path.dirname(obj.master_file))
     else:
-        raise RuntimeError(f"obj type not handled ({type(obj)})")
+        raise RuntimeError(f"obj type not handled ({type(obj)})")  # noqa: TRY004

nabu/stitching/stitcher/base.py

@@ -21,6 +21,8 @@ def get_obj_constant_side_length(obj: Union[NXtomoScan, VolumeBase], axis: int)
             return obj.dim_1
         elif axis in (1, 2):
             return obj.dim_2
+        else:
+            raise ValueError(f"Axis ({axis}) not handled. Should be in (0, 1, 2)")
     elif isinstance(obj, VolumeBase) and axis == 0:
         return obj.get_volume_shape()[-1]
     else:

nabu/stitching/stitcher/dumper/base.py

@@ -4,7 +4,6 @@ from typing import Union, Optional
 from tomoscan.identifier import BaseIdentifier
 from nabu.stitching.config import StitchingConfiguration
 from tomoscan.volumebase import VolumeBase
-from contextlib import AbstractContextManager
 
 
 class DumperBase:

nabu/stitching/stitcher/dumper/postprocessing.py

@@ -96,7 +96,7 @@ class OutputVolumeContext(AbstractContextManager):
         if self._file_handler is not None:
             return self._file_handler.close()
         else:
-            self._volume.save_data()
+            self._volume.save_data()  # noqa: RET503
 
 
 class OutputVolumeNoDDContext(OutputVolumeContext):

nabu/stitching/stitcher/post_processing.py

@@ -13,11 +13,10 @@ from tomoscan.esrf import NXtomoScan
 from tomoscan.series import Series
 from tomoscan.volumebase import VolumeBase
 from tomoscan.esrf.volume import HDF5Volume
-from typing import Iterable
+from collections.abc import Iterable
 from contextlib import AbstractContextManager
 from pyunitsystem.metricsystem import MetricSystem
 from nabu.stitching.config import (
-    PostProcessedSingleAxisStitchingConfiguration,
     KEY_IMG_REG_METHOD,
 )
 from nabu.stitching.utils.utils import find_volumes_relative_shifts
@@ -422,7 +421,7 @@ class PostProcessingStitching(SingleAxisStitcher):
                 [(abs(overlap), n_slices, self._stitching_constant_length) for overlap in self._axis_0_rel_final_shifts]
             )
 
-        with self.dumper.OutputDatasetContext(**output_dataset_args):
+        with self.dumper.OutputDatasetContext(**output_dataset_args):  # noqa: SIM117
             # note: output_dataset is a HDF5 dataset if final volume is an HDF5 volume else is a numpy array
             with _RawDatasetsContext(
                 self._input_volumes,
@@ -518,7 +517,8 @@ class _RawDatasetsContext(AbstractContextManager):
                 else:
                     data = volume.load_data(store=False)
                     if data is None:
-                        raise ValueError(f"No data found for volume {volume.get_identifier()}")
+                        # TODO
+                        raise ValueError(f"No data found for volume {volume.get_identifier()}")  # noqa: TRY301
                 if axis_1_need_padding:
                     data = self.add_padding(data=data, axis_1_dim=axis_1_dim, alignment=self.alignment_axis_1)
                 datasets.append(data)
@@ -526,7 +526,7 @@ class _RawDatasetsContext(AbstractContextManager):
             # if some errors happen during loading HDF5
             for file_handled in self.__file_handlers:
                 file_handled.close()
-            raise e
+            raise e  # noqa: TRY201
 
         return datasets
 
@@ -534,7 +534,7 @@ class _RawDatasetsContext(AbstractContextManager):
         success = True
         for file_handler in self.__file_handlers:
             success = success and file_handler.close()
-        if exc_type is None:
+        if exc_type is None:  # noqa: RET503
             return success
 
     def add_padding(self, data: Union[h5py.Dataset, numpy.ndarray], axis_1_dim, alignment: AlignmentAxis1):

nabu/stitching/stitcher/pre_processing.py

@@ -2,7 +2,7 @@ import numpy
 import logging
 import h5py
 import os
-from typing import Iterable
+from collections.abc import Iterable
 from silx.io.url import DataUrl
 from silx.io.utils import get_data
 from datetime import datetime
@@ -40,7 +40,6 @@ class PreProcessingStitching(SingleAxisStitcher):
     """
 
     def __init__(self, configuration, progress=None) -> None:
-        """ """
         if not isinstance(configuration, PreProcessedSingleAxisStitchingConfiguration):
             raise TypeError(
                 f"configuration is expected to be an instance of {PreProcessedSingleAxisStitchingConfiguration}. Get {type(configuration)} instead"
@@ -526,9 +525,9 @@ class PreProcessingStitching(SingleAxisStitcher):
             if isinstance(slices, slice):
                 return array[slices.start : slices.stop : 1]
             elif isinstance(slices, Iterable):
-                return list([array[index] for index in slices])
+                return [array[index] for index in slices]
             else:
-                raise RuntimeError("slices must be instance of a slice or of an iterable")
+                raise RuntimeError("slices must be instance of a slice or of an iterable")  # noqa: TRY004
 
         nx_tomo.sample.rotation_angle = apply_slices_selection(
             array=nx_tomo.sample.rotation_angle, slices=self._slices_to_stitch
@@ -794,7 +793,7 @@ class PreProcessingStitching(SingleAxisStitcher):
         ):
             i_frame = 0
             _, set_of_compacted_slices = get_compacted_dataslices(scan_urls, return_url_set=True)
-            for _, url in set_of_compacted_slices.items():
+            for url in set_of_compacted_slices.values():
                 scan = scans[i_scan]
                 url = DataUrl(
                     file_path=url.file_path(),
@@ -886,6 +885,9 @@ class PreProcessingStitching(SingleAxisStitcher):
         """
         make sure reduced dark and flats are existing otherwise compute them
         """
+        # TODO
+        # ruff: noqa: SIM105, S110
+        # --
         for scan in self.series:
             try:
                 reduced_darks, darks_infos = scan.load_reduced_darks(return_info=True)
@@ -896,7 +898,7 @@ class PreProcessingStitching(SingleAxisStitcher):
                 try:
                     # if we don't have write in the folder containing the .nx for example
                     scan.save_reduced_darks(reduced_darks, darks_infos=darks_infos)
-                except Exception as e:
+                except Exception:
                     pass
             scan.set_reduced_darks(reduced_darks, darks_infos=darks_infos)
 
@@ -909,7 +911,7 @@ class PreProcessingStitching(SingleAxisStitcher):
                 try:
                     # if we don't have write in the folder containing the .nx for example
                     scan.save_reduced_flats(reduced_flats, flats_infos=flats_infos)
-                except Exception as e:
+                except Exception:
                     pass
             scan.set_reduced_flats(reduced_flats, flats_infos=flats_infos)
 
@@ -979,7 +981,7 @@ class PreProcessingStitching(SingleAxisStitcher):
         ):
             i_frame = 0
             _, set_of_compacted_slices = get_compacted_dataslices(scan_urls, return_url_set=True)
-            for _, url in set_of_compacted_slices.items():
+            for url in set_of_compacted_slices.values():
                 scan = scans[i_scan]
                 url = DataUrl(
                     file_path=url.file_path(),
@@ -1000,12 +1002,12 @@ class PreProcessingStitching(SingleAxisStitcher):
 
                 missing = []
                 if len(scan.reduced_flats) == 0:
-                    missing = "flats"
+                    missing.append("flats")
                 if len(scan.reduced_darks) == 0:
-                    missing = "darks"
+                    missing.append("darks")
 
                 if len(missing) > 0:
-                    _logger.warning(f"missing {'and'.join(missing)}. Unable to do flat field correction")
+                    _logger.warning(f"missing {' and '.join(missing)}. Unable to do flat field correction")
                     ff_arrays = None
                     data = raw_radios
                 else:

nabu/stitching/stitcher/single_axis.py

@@ -1,8 +1,7 @@
-import h5py
 import numpy
 import logging
-from math import ceil
-from typing import Optional, Iterable, Union
+from typing import Optional, Union
+from collections.abc import Iterable
 from tomoscan.series import Series
 from tomoscan.identifier import BaseIdentifier
 from nabu.stitching.stitcher.base import _StitcherBase, get_obj_constant_side_length
@@ -38,7 +37,7 @@ class _SingleAxisMetaClass(type):
     Metaclass for single axis stitcher in order to aggregate dumper class and axis
     """
 
-    def __new__(mcls, name, bases, attrs, axis=None, dumper_cls=None):
+    def __new__(mcls, name, bases, attrs, axis=None, dumper_cls=None):  # noqa: N804
         mcls = super().__new__(mcls, name, bases, attrs)
         mcls._axis = axis
         mcls._dumperCls = dumper_cls

nabu/stitching/stitcher_2D.py

@@ -1,3 +1,4 @@
+# ruff: noqa: N999
 import numpy
 from math import ceil
 from typing import Union, Optional
@@ -19,7 +20,7 @@ def stitch_raw_frames(
     pad_mode="constant",
     new_unstitched_axis_size: Optional[int] = None,
 ) -> numpy.ndarray:
-    """
+    r"""
     stitches raw frames (already shifted and flat fielded !!!) together using
     raw stitching (no pixel interpolation, y_overlap_in_px is expected to be a int).
     Sttiching depends on the kernel used.

nabu/stitching/tests/test_config.py

@@ -43,12 +43,10 @@ def test_stitching_config(stitching_type, option_level):
                 stiching_config.dict_to_config_obj(config),
                 stiching_config.PostProcessedSingleAxisStitchingConfiguration,
             )
-        elif stitching_type is stiching_config.StitchingType.Z_PREPROC:
-            assert isinstance(
-                stiching_config.dict_to_config_obj(config),
-                stiching_config.PreProcessedSingleAxisStitchingConfiguration,
-            )
-        elif stitching_type is stiching_config.StitchingType.Y_PREPROC:
+        elif (
+            stitching_type is stiching_config.StitchingType.Z_PREPROC
+            or stitching_type is stiching_config.StitchingType.Y_PREPROC
+        ):
             assert isinstance(
                 stiching_config.dict_to_config_obj(config),
                 stiching_config.PreProcessedSingleAxisStitchingConfiguration,
@@ -92,7 +90,7 @@ def test_stitching_config(stitching_type, option_level):
         "",
         None,
         "None",
-        "",
+        "",  # noqa: PT014
         "skimage",
         "nabu-fft",
     ),
@@ -176,7 +174,8 @@ def test_PreProcessedZStitchingConfiguration(
 
     from_dict = stiching_config.PreProcessedZStitchingConfiguration.from_dict(pre_process_config.to_dict())
     # workaround for scans because a new object is created each time
-    pre_process_config.settle_inputs
+    # ???
+    pre_process_config.settle_inputs  # noqa: B018
     assert len(from_dict.input_scans) == len(pre_process_config.input_scans)
     from_dict.input_scans = None
     pre_process_config.input_scans = None

nabu/stitching/tests/test_sample_normalization.py

@@ -1,6 +1,6 @@
 import numpy
 import pytest
-from nabu.stitching.sample_normalization import normalize_frame, SampleSide, Method
+from nabu.stitching.sample_normalization import normalize_frame
 
 
 def test_normalize_frame():

nabu/stitching/tests/test_slurm_utils.py

@@ -1,5 +1,4 @@
 import os
-import numpy
 import pytest
 from tomoscan.esrf import NXtomoScan
 from tomoscan.esrf.volume import HDF5Volume
@@ -14,7 +13,7 @@ from nabu.stitching.slurm_utils import (
 from tomoscan.esrf.mock import MockNXtomo
 
 try:
-    import sluurp
+    import sluurp  # noqa: F401
 except ImportError:
     has_sluurp = False
 else:

nabu/stitching/tests/test_z_postprocessing_stitching.py

@@ -770,6 +770,6 @@ def test_data_duplication(tmp_path, data_duplication):
     if not data_duplication:
         # make sure an error is raised if we try to ask for no data duplication and if we get some flips
         z_stich_config.flip_ud = (False, True, False)
-        with pytest.raises(ValueError):
+        with pytest.raises(ValueError):  # noqa: PT012
             stitcher = PostProcessZStitcherNoDD(z_stich_config, progress=None)
             stitcher.stitch()

nabu/stitching/tests/test_z_preprocessing_stitching.py

@@ -5,11 +5,11 @@ import numpy
 import pytest
 from nabu.stitching.config import PreProcessedZStitchingConfiguration
 from nabu.stitching.config import KEY_IMG_REG_METHOD
-from nabu.stitching.overlap import ImageStichOverlapKernel, OverlapStitchingStrategy
+from nabu.stitching.overlap import OverlapStitchingStrategy
 from nabu.stitching.z_stitching import (
     PreProcessZStitcher,
 )
-from nabu.stitching.stitcher_2D import stitch_raw_frames, get_overlap_areas
+from nabu.stitching.stitcher_2D import get_overlap_areas
 from nxtomo.nxobject.nxdetector import ImageKey
 from nxtomo.utils.transformation import DetYFlipTransformation, DetZFlipTransformation
 from nxtomo.application.nxtomo import NXtomo
@@ -301,11 +301,11 @@ def test_DistributePreProcessZStitcher(tmp_path, configuration_dist):
     )
 
     if complete:
-        len(final_nx_tomo.instrument.detector.data) == 128
+        assert len(final_nx_tomo.instrument.detector.data) == 100
         # test middle
         numpy.testing.assert_array_almost_equal(raw_data[1], final_nx_tomo.instrument.detector.data[1, :, :])
     else:
-        len(final_nx_tomo.instrument.detector.data) == 3
+        assert len(final_nx_tomo.instrument.detector.data) == 3
         # test middle
         numpy.testing.assert_array_almost_equal(raw_data[49], final_nx_tomo.instrument.detector.data[1, :, :])
     # in the case of first, middle and last frames

nabu/stitching/utils/tests/test_post-processing.py

@@ -1,3 +1,4 @@
+# noqa: N999
 import pytest
 
 from nabu.stitching.stitcher.single_axis import PROGRESS_BAR_STITCH_VOL_DESC