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

nabu/pipeline/helical/helical_utils.py

@@ -9,9 +9,8 @@ def find_mirror_indexes(angles_deg, tolerance_factor=1.0):
     contains the index of the angles_deg array element which has the value the closest
     to angles_deg[i] + 180. It is used for padding in halftomo.
 
-    Parameters:
+    Parameters
     -----------
-
     angles_deg: a nd.array of floats
 
     tolerance: float

nabu/pipeline/helical/nabu_config.py

@@ -1,3 +1,4 @@
+# ruff: noqa
 from ..fullfield.nabu_config import *
 import copy
 

nabu/pipeline/helical/span_strategy.py

@@ -1,3 +1,4 @@
+# ruff: noqa
 import math
 import numpy as np
 from ...resources.logger import LoggerOrPrint

nabu/pipeline/helical/weight_balancer.py

@@ -12,8 +12,7 @@ class WeightBalancer:
         to Nabu, we create this class and follow the scheme initialisation + application.
 
         Parameters
-        ==========
-
+        ----------
         rot_center : float
                     the center of rotation in pixel units
         angles_rad :

nabu/pipeline/utils.py

@@ -72,7 +72,7 @@ def get_subregion(sub_region, ndim=3):
     if sub_region is None:
         res = ((None, None),)
     elif hasattr(sub_region[0], "__iter__"):
-        if set(map(len, sub_region)) != set([2]):
+        if set(map(len, sub_region)) != {2}:
             raise ValueError("Expected each tuple to be in the form (start, end)")
         res = sub_region
     else:

nabu/pipeline/writer.py

@@ -163,7 +163,7 @@ class WriterManager:
     def _init_histogram_writer(self):
         if not self.histogram:
             return
-        separate_histogram_file = not (self.file_format == "hdf5")
+        separate_histogram_file = self.file_format != "hdf5"
         if separate_histogram_file:
             fmode = "w"
             hist_fname = path.join(self.output_dir, "histogram_%05d.hdf5" % self.start_index)

nabu/preproc/alignment.py

@@ -1,11 +1 @@
 # Backward compat.
-from ..estimation.alignment import AlignmentBase
-from ..estimation.cor import (
-    CenterOfRotation,
-    CenterOfRotationAdaptiveSearch,
-    CenterOfRotationGrowingWindow,
-    CenterOfRotationSlidingWindow,
-)
-from ..estimation.translation import DetectorTranslationAlongBeam
-from ..estimation.focus import CameraFocus
-from ..estimation.tilt import CameraTilt

nabu/preproc/ctf.py

@@ -67,7 +67,7 @@ class GeoPars:
         else:
             self.M_vh = np.array([1, 1])
 
-        self.logger.debug("Magnification : h ({}) ;  v ({}) ".format(self.M_vh[1], self.M_vh[0]))
+        self.logger.debug(f"Magnification : h ({self.M_vh[1]}) ;  v ({self.M_vh[0]}) ")
 
         self.length_scale = length_scale
         self.wavelength = wavelength
@@ -80,17 +80,17 @@ class GeoPars:
 
         which_unit = int(np.sum(np.array([self.pix_size_rec > small for small in [1.0e-6, 1.0e-7]]).astype(np.int32)))
         self.pixelsize_string = [
-            "{:.1f} nm".format(self.pix_size_rec * 1e9),
-            "{:.3f} um".format(self.pix_size_rec * 1e6),
-            "{:.1f} um".format(self.pix_size_rec * 1e6),
+            f"{self.pix_size_rec * 1e9:.1f} nm",
+            f"{self.pix_size_rec * 1e6:.3f} um",
+            f"{self.pix_size_rec * 1e6:.1f} um",
         ][which_unit]
 
         if self.magnification:
             self.logger.debug(
-                "All images are resampled to smallest pixelsize: {}".format(self.pixelsize_string),
+                f"All images are resampled to smallest pixelsize: {self.pixelsize_string}",
             )
         else:
-            self.logger.debug("Pixelsize images:  {}".format(self.pixelsize_string))
+            self.logger.debug(f"Pixelsize images:  {self.pixelsize_string}")
 
 
 class CTFPhaseRetrieval:
@@ -157,7 +157,7 @@ class CTFPhaseRetrieval:
         """
         self.logger = LoggerOrPrint(logger)
         if not isinstance(geo_pars, GeoPars):
-            raise ValueError("Expected GeoPars instance for 'geo_pars' parameter")
+            raise TypeError("Expected GeoPars instance for 'geo_pars' parameter")
         self.geo_pars = geo_pars
         self._calc_shape(shape, padded_shape, padding_mode)
         self.delta_beta = delta_beta
@@ -292,7 +292,7 @@ class CTFPhaseRetrieval:
         self.cut_v = math.sqrt(1.0 / 2 / lambda_dist_vh[0]) / fsample_vh[0]
         self.cut_v = min(self.cut_v, 0.5)
 
-        self.logger.debug("Normalized cut-off = {:5.3f}".format(self.cut_v))
+        self.logger.debug(f"Normalized cut-off = {self.cut_v:5.3f}")
 
         self.r = fourier_filters.get_lowpass_filter(
             padded_img_shape,

nabu/preproc/ctf_cuda.py

@@ -48,7 +48,7 @@ class CudaCTFPhaseRetrieval(CTFPhaseRetrieval):
         padding_mode: str
             Padding mode. Default is "reflect".
 
-        Other parameters
+        Other Parameters
         -----------------
         Please refer to CTFPhaseRetrieval documentation.
         """

nabu/preproc/double_flatfield_cuda.py

@@ -7,7 +7,7 @@ from .ccd_cuda import CudaLog
 
 if __has_pycuda__:
     import pycuda.gpuarray as garray
-    import pycuda.cumath as cumath
+    from pycuda import cumath
 
 
 class CudaDoubleFlatField(DoubleFlatField):
@@ -109,7 +109,7 @@ class CudaDoubleFlatField(DoubleFlatField):
             Whether to recompute the double flatfield if already computed.
         """
         if not (isinstance(radios, garray.GPUArray)):  # pylint: disable=E0606
-            raise ValueError("Expected pycuda.gpuarray.GPUArray for radios")
+            raise TypeError("Expected pycuda.gpuarray.GPUArray for radios")
         if self._computed and not (recompute):
             return self.doubleflatfield
         acc = garray.zeros(radios[0].shape, "f")

nabu/preproc/double_flatfield_variable_region.py

@@ -1,5 +1,4 @@
 from .double_flatfield import (
-    DoubleFlatField,
     DoubleFlatField,
     check_shape,
     get_2D_3D_shape,

nabu/preproc/flatfield.py

@@ -91,7 +91,7 @@ class FlatFieldArrays:
           flatfield_normalization(X') = (X' - D)/(F' - D) = (X - D) / (F - D) * sF/sX
         So current normalization boils down to a scalar multiplication after flat-field.
         """
-        if self._full_shape:
+        if self._full_shape:  # noqa: SIM102
             # this is never going to happen in this base class. But in the derived class for helical
             # which needs to keep the full shape
             if radios_indices is not None:

nabu/preproc/flatfield_cuda.py

@@ -4,7 +4,6 @@ from nabu.cuda.processing import CudaProcessing
 from ..preproc.flatfield import FlatFieldArrays
 from ..utils import deprecated_class, get_cuda_srcfile
 from ..io.reader import load_images_from_dataurl_dict
-from ..cuda.utils import __has_pycuda__
 
 
 class CudaFlatFieldArrays(FlatFieldArrays):
@@ -90,7 +89,7 @@ class CudaFlatFieldArrays(FlatFieldArrays):
             Radios chunk.
         """
         if not (isinstance(radios, self.cuda_processing.array_class)):
-            raise ValueError("Expected a pycuda.gpuarray (got %s)" % str(type(radios)))
+            raise TypeError("Expected a pycuda.gpuarray (got %s)" % str(type(radios)))
         if radios.dtype != np.float32:
             raise ValueError("radios must be in float32 dtype (got %s)" % str(radios.dtype))
         if radios.shape != self.radios_shape:

nabu/preproc/flatfield_variable_region.py

@@ -1,5 +1,5 @@
 import numpy as np
-from .flatfield import FlatFieldArrays, load_images_from_dataurl_dict, check_supported
+from .flatfield import FlatFieldArrays, load_images_from_dataurl_dict
 
 
 class FlatFieldArraysVariableRegion(FlatFieldArrays):
@@ -27,9 +27,9 @@ class FlatFieldArraysVariableRegion(FlatFieldArrays):
             does not correspond to the length of sub_indexes which is {len(sub_indexes)}
             """
             raise ValueError(message)
-        do_flats_distortion_correction = self.distortion_correction is not None
+        # do_flats_distortion_correction = self.distortion_correction is not None
 
-        whole_dark = self.get_dark()
+        # whole_dark = self.get_dark()
         for i, (idx, sub_r) in enumerate(zip(sub_indexes, sub_regions_per_radio)):
             start_x, end_x, start_y, end_y = sub_r
             slice_x = slice(start_x, end_x)

nabu/preproc/phase.py

@@ -5,13 +5,12 @@ from scipy.fft import rfft2, irfft2, fft2, ifft2
 from ..utils import generate_powers, get_decay, check_supported, get_num_threads, deprecation_warning
 
 # COMPAT.
-from .ctf import CTFPhaseRetrieval
 
 #
 
 
 def lmicron_to_db(Lmicron, energy, distance):
-    """
+    r"""
     Utility to convert the "Lmicron" parameter of PyHST
     to a value of delta/beta.
 
@@ -55,7 +54,7 @@ class PaganinPhaseRetrieval:
         fftw_num_threads=None,
         fft_num_threads=None,
     ):
-        """
+        r"""
         Paganin Phase Retrieval for an infinitely distant point source.
         Formula (10) in [1].
 
@@ -98,7 +97,6 @@ class PaganinPhaseRetrieval:
 
         Notes
         ------
-
         **Padding methods**
 
         The phase retrieval is a convolution done in Fourier domain using FFT,

nabu/preproc/phase_cuda.py

@@ -107,13 +107,13 @@ class CudaPaganinPhaseRetrieval(PaganinPhaseRetrieval):
         assert data.dtype == np.float32
         # Rectangular memcopy
         # TODO profile, and if needed include this copy in the padding kernel
-        if isinstance(data, np.ndarray) or isinstance(data, self.cuda_processing.array_class):
+        if isinstance(data, np.ndarray) or isinstance(data, self.cuda_processing.array_class):  # noqa: SIM101
             self.d_radio_padded[: self.shape[0], : self.shape[1]] = data[:, :]
         elif isinstance(data, cuda.DeviceAllocation):
             # TODO manual memcpy2D
             raise NotImplementedError("pycuda buffers are not supported yet")
         else:
-            raise ValueError("Expected either numpy array, pycuda array or pycuda buffer")
+            raise TypeError("Expected either numpy array, pycuda array or pycuda buffer")
 
     def get_output(self, output):
         s0, s1 = self.shape

nabu/preproc/shift_cuda.py

@@ -1,5 +1,4 @@
 import numpy as np
-from ..cuda.utils import __has_pycuda__
 from ..cuda.processing import CudaProcessing
 from ..processing.muladd_cuda import CudaMulAdd
 from .shift import VerticalShift

nabu/preproc/tests/test_ctf.py

@@ -10,7 +10,7 @@ from nabu.preproc import ctf
 from nabu.estimation.distortion import estimate_flat_distortion
 from nabu.misc.filters import correct_spikes
 from nabu.preproc.distortion import DistortionCorrection
-from nabu.cuda.utils import __has_pycuda__, get_cuda_context
+from nabu.cuda.utils import __has_pycuda__
 
 __has_cufft__ = False
 if __has_pycuda__:
@@ -220,7 +220,7 @@ class TestCtf:
         # Test multi-core FFT
         ctf_fft = ctf.CtfFilter(*ctf_args, **ctf_kwargs, use_rfft=True, fft_num_threads=0)
         if ctf_fft.use_rfft:
-            phase_fft = ctf_fft.retrieve_phase(img)
+            # phase_fft = ctf_fft.retrieve_phase(img)
             self.check_result(phase_r2c, self.ref_plain, "Something wrong with CtfFilter-FFT")
 
     @pytest.mark.skipif(not (__has_pycuda__ and __has_cufft__), reason="pycuda and (scikit-cuda or vkfft)")
@@ -232,7 +232,7 @@ class TestCtf:
         pix_size_m = 0.1e-6
 
         geo_pars = ctf.GeoPars(z2=distance_m, pix_size_det=pix_size_m, wavelength=1.23984199e-9 / energy_kev)
-        ctx = get_cuda_context()
+        # ctx = get_cuda_context()
 
         for normalize in [True, False]:
             ctf_filter = ctf.CTFPhaseRetrieval(

nabu/preproc/tests/test_double_flatfield.py

@@ -1,4 +1,4 @@
-import os.path as path
+from os import path
 from math import exp
 import tempfile
 import numpy as np

nabu/preproc/tests/test_flatfield.py

@@ -411,7 +411,7 @@ class FlatFieldTestDataset:
         self._generate_projections()
 
     def get_flat_idx(self, proj_idx):
-        flats_idx = sorted(list(self.flats.keys()))
+        flats_idx = sorted(self.flats.keys())
         if proj_idx <= flats_idx[0]:
             return (flats_idx[0],)
         elif proj_idx > flats_idx[0] and proj_idx < flats_idx[1]:

nabu/preproc/tests/test_vshift.py

@@ -70,4 +70,7 @@ class TestVerticalShift:
         Shifter_neg_cuda = CudaVerticalShift(d_radios.shape, -self.shifts)
         Shifter_neg_cuda.apply_vertical_shifts(d_radios2, self.indexes)
         err_max = np.max(np.abs(d_radios2.get() - radios2))
-        assert err_max < 1e-6, "Something wrong for negative translations: max error = %.2e" % err_max
+        #
+        # FIXME tolerance was downgraded from 1e-6 to 8e-6 when switching to numpy 2
+        #
+        assert err_max < 8e-6, "Something wrong for negative translations: max error = %.2e" % err_max

nabu/processing/azim.py

@@ -123,11 +123,11 @@ def do_radial_distribution(ip, X0, Y0, mR, nBins=None, use_calibration=False, ca
     if use_calibration and cal is not None:
         # Apply calibration if units are provided
         radii = cal.pixel_width * mR * (np.arange(1, nBins + 1) / nBins)
-        units = cal.units
+        # units = cal.units
     else:
         # Use pixel units
         radii = mR * (np.arange(1, nBins + 1) / nBins)
-        units = "pixels"
+        # units = "pixels"
 
     if return_radii:
         return radii, Accumulator[1]

nabu/processing/convolution_cuda.py

@@ -159,7 +159,7 @@ class Convolution:
             self.d_kernel = self.cuda.to_device("d_kernel", self.kernel)
         else:
             if not (isinstance(self.kernel, self.cuda.array_class)):
-                raise ValueError("kernel must be either numpy array or pycuda array")
+                raise TypeError("kernel must be either numpy array or pycuda array")
             self.d_kernel = self.kernel
         self._old_input_ref = None
         self._old_output_ref = None
@@ -185,7 +185,7 @@ class Convolution:
         self._c_conv_mode = mp[self.mode]
 
     def _init_kernels(self):
-        if self.kernel_ndim > 1:
+        if self.kernel_ndim > 1:  # noqa: SIM102
             if np.abs(np.diff(self.kernel.shape)).max() > 0:
                 raise NotImplementedError("Non-separable convolution with non-square kernels is not implemented yet")
         # Compile source module
@@ -290,7 +290,7 @@ class Convolution:
         return ndim
 
     def _check_array(self, arr):
-        if not (isinstance(arr, self.cuda.array_class) or isinstance(arr, np.ndarray)):
+        if not (isinstance(arr, self.cuda.array_class) or isinstance(arr, np.ndarray)):  # noqa: SIM101
             raise TypeError("Expected either pycuda.gpuarray or numpy.ndarray")
         if arr.dtype != np.float32:
             raise TypeError("Data must be float32")
@@ -305,7 +305,7 @@ class Convolution:
             self._old_input_ref = self.data_in
             self.data_in = array
         data_in_ref = self.data_in
-        if output is not None:
+        if output is not None:  # noqa: SIM102
             if not (isinstance(output, np.ndarray)):
                 self._old_output_ref = self.data_out
                 self.data_out = output
@@ -324,11 +324,13 @@ class Convolution:
         cuda_kernel = self.cuda_kernels[axis]
         cuda_kernel_args = self._configure_kernel_args(self.kernel_args, input_ref, output_ref)
         ev = cuda_kernel.prepared_call(*cuda_kernel_args)
+        return ev
 
     def _nd_convolution(self):
         assert len(self.use_case_kernels) == 1
         cuda_kernel = self._module.get_function(self.use_case_kernels[0])
         ev = cuda_kernel.prepared_call(*self.kernel_args)
+        return ev
 
     def _recover_arrays_references(self):
         if self._old_input_ref is not None:

nabu/processing/fft_base.py

@@ -35,7 +35,7 @@ class _BaseFFT:
                 the transform is unitary. Both FFT and IFFT are scaled with 1/sqrt(N).
               * "none": no normalizatio is done : IFFT(FFT(data)) = data*N
 
-        Other parameters
+        Other Parameters
         -----------------
         backend_options: dict, optional
             Parameters to pass to CudaProcessing or OpenCLProcessing class.

nabu/processing/fft_cuda.py

@@ -25,6 +25,7 @@ def init_skcuda():
     # This needs to be done here, because scikit-cuda creates a Cuda context at import,
     # which can mess things up in some cases.
     # Ugly solution to an ugly problem.
+    # ruff: noqa: PLW0603
     global __has_skcuda__, Plan, cu_fft, cu_ifft
     try:
         from skcuda.fft import Plan
@@ -167,7 +168,7 @@ def _has_vkfft(x):
 
         if not __has_vkfft__:
             return False
-        vk = VKCUFFT((16,), "f")
+        _ = VKCUFFT((16,), "f")
         avail = True
     except (ImportError, RuntimeError, OSError, NameError):
         avail = False
@@ -184,9 +185,14 @@ def has_vkfft(safe=True):
     """
     if not safe:
         return _has_vkfft(None)
-    ctx = get_context("spawn")
-    with Pool(1, context=ctx) as p:
-        v = p.map(_has_vkfft, [1])[0]
+    try:
+        ctx = get_context("spawn")
+        with Pool(1, context=ctx) as p:
+            v = p.map(_has_vkfft, [1])[0]
+    except AssertionError:
+        # Can get AssertionError: daemonic processes are not allowed to have children
+        # if the calling code is already a subprocess
+        return _has_vkfft(None)
     return v
 
 
@@ -195,7 +201,7 @@ def _has_skfft(x):
     try:
         from nabu.processing.fft_cuda import SKCUFFT
 
-        sk = SKCUFFT((16,), "f")
+        _ = SKCUFFT((16,), "f")
         avail = True
     except (ImportError, RuntimeError, OSError, NameError):
         avail = False
@@ -210,9 +216,14 @@ def has_skcuda(safe=True):
     """
     if not safe:
         return _has_skfft(None)
-    ctx = get_context("spawn")
-    with Pool(1, context=ctx) as p:
-        v = p.map(_has_skfft, [1])[0]
+    try:
+        ctx = get_context("spawn")
+        with Pool(1, context=ctx) as p:
+            v = p.map(_has_skfft, [1])[0]
+    except AssertionError:
+        # Can get AssertionError: daemonic processes are not allowed to have children
+        # if the calling code is already a subprocess
+        return _has_skfft(None)
     return v
 
 

nabu/processing/fft_opencl.py

@@ -34,7 +34,7 @@ def _has_vkfft(x):
 
         if not __has_vkfft__:
             return False
-        vk = VKCLFFT((16,), "f")
+        _ = VKCLFFT((16,), "f")
         avail = True
     except (RuntimeError, OSError):
         avail = False
@@ -48,7 +48,12 @@ def has_vkfft(safe=True):
     """
     if not safe:
         return _has_vkfft(None)
-    ctx = get_context("spawn")
-    with Pool(1, context=ctx) as p:
-        v = p.map(_has_vkfft, [1])[0]
+    try:
+        ctx = get_context("spawn")
+        with Pool(1, context=ctx) as p:
+            v = p.map(_has_vkfft, [1])[0]
+    except AssertionError:
+        # Can get AssertionError: daemonic processes are not allowed to have children
+        # if the calling code is already a subprocess
+        return _has_vkfft(None)
     return v

nabu/processing/fftshift.py

@@ -25,7 +25,7 @@ class FFTshiftBase:
         axes: tuple, optional
             Axes over which to shift.  Default is None, which shifts all axes.
 
-        Other parameters
+        Other Parameters
         ----------------
         backend_options:
             named arguments to pass to CudaProcessing or OpenCLProcessing

nabu/processing/histogram.py

@@ -146,7 +146,7 @@ class PartialHistogram:
         elif self.bin_width == "uint16":
             return self._bin_width_u16(dmin, dmax)
         else:
-            raise ValueError()
+            raise ValueError
 
     def _compute_histogram_fixed_bw(self, data, data_range=None):
         dmin, dmax = data.min(), data.max() if data_range is None else data_range

nabu/processing/muladd.py

@@ -1,4 +1,3 @@
-import numpy as np
 from .processing_base import ProcessingBase
 
 

nabu/processing/padding_base.py

@@ -23,7 +23,7 @@ class PaddingBase:
         mode: str
             Padding mode
 
-        Other parameters
+        Other Parameters
         ----------------
         constant_values: tuple
             Tuple containing the values to fill when mode="constant" (as in numpy.pad)

nabu/processing/padding_cuda.py

@@ -1,7 +1,6 @@
 import numpy as np
 from ..utils import get_cuda_srcfile, updiv
 from ..cuda.processing import CudaProcessing
-from ..cuda.utils import __has_pycuda__
 from .padding_base import PaddingBase
 
 

nabu/processing/processing_base.py

@@ -88,7 +88,7 @@ class ProcessingBase:
             self.allocate_array(array_name, array_ref.shape, dtype=dtype)
             getattr(self, array_name).set(array_ref)
         else:
-            raise ValueError("Expected numpy array or pycuda array")
+            raise TypeError("Expected numpy array or pycuda array")
         return getattr(self, array_name)
 
     def get_array(self, array_name):

nabu/processing/tests/test_fft.py

@@ -190,7 +190,7 @@ class TestFFT:
             pytest.skip("R2C with odd-sized fast dimension is not supported in VKFFT")
 
         # FIXME - vkfft + POCL fail for R2C in one dimension
-        if config["backend"] == "opencl" and r2c and ndim == 1:
+        if config["backend"] == "opencl" and r2c and ndim == 1:  # noqa: SIM102
             if self.cl_ctx.devices[0].platform.name.strip().lower() == "portable computing language":
                 pytest.skip("Something wrong with vkfft + pocl for R2C 1D")
         # ---

nabu/processing/tests/test_fftshift.py

@@ -2,7 +2,7 @@ import numpy as np
 import pytest
 from nabu.cuda.utils import get_cuda_context, __has_pycuda__
 from nabu.opencl.utils import __has_pyopencl__, get_opencl_context
-from nabu.testutils import get_data, generate_tests_scenarios, __do_long_tests__
+from nabu.testutils import get_data, generate_tests_scenarios
 
 if __has_pyopencl__:
     from nabu.processing.fftshift import OpenCLFFTshift

nabu/processing/tests/test_medfilt.py

@@ -34,16 +34,14 @@ def bootstrap(request):
 
 @pytest.mark.skipif(not (__has_pycuda__), reason="Need Cuda/pycuda for this test")
 @pytest.mark.usefixtures("bootstrap")
-class TestMedianFilter(object):
+class TestMedianFilter:
     @classmethod
     def allocate_numpy_arrays(cls):
-        shape = cls.data.shape
         cls.input = cls.data
         cls.input3d = np.tile(cls.input, (2, 1, 1))
 
     @classmethod
     def allocate_cuda_arrays(cls):
-        shape = cls.data.shape
         cls.d_input = garray.to_gpu(cls.input)
         cls.d_output = garray.zeros_like(cls.d_input)
         cls.d_input3d = garray.to_gpu(cls.input3d)

nabu/processing/tests/test_padding.py

@@ -108,7 +108,7 @@ class TestPadding:
             d_img.set(data)
             d_out = padding.processing.allocate_array("d_out", padding.padded_shape, dtype="f")
 
-            res = padding.pad(d_img, output=d_out)
+            padding.pad(d_img, output=d_out)
 
             ref = np.roll(np.pad(data, pad_width, mode=mode), (-pad_width[0][0], -pad_width[1][0]), axis=(0, 1))
 

nabu/processing/tests/test_roll.py

@@ -2,7 +2,7 @@ import numpy as np
 import pytest
 from nabu.cuda.utils import get_cuda_context, __has_pycuda__
 from nabu.opencl.utils import __has_pyopencl__, get_opencl_context
-from nabu.testutils import get_data, generate_tests_scenarios, __do_long_tests__
+from nabu.testutils import get_data, generate_tests_scenarios
 from nabu.processing.roll_opencl import OpenCLRoll
 
 configs_roll = {

nabu/processing/unsharp_opencl.py

@@ -1,5 +1,5 @@
 try:
-    import pyopencl.array as parray
+    import pyopencl.array as parray  # noqa: F401
     from pyopencl.elementwise import ElementwiseKernel
     from ..opencl.processing import OpenCLProcessing