nabu 2024.1.9__py3-none-any.whl → 2024.2.0__py3-none-any.whl

nabu/__init__.py

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

nabu/app/bootstrap.py

@@ -12,15 +12,14 @@ def bootstrap():
     args = parse_params_values(BootstrapConfig, parser_description="Initialize a nabu configuration file")
 
     do_bootstrap = bool(args["bootstrap"])
-    do_convert = args["convert"] != ""
     no_comments = bool(args["nocomments"])
+    overwrite = bool(args["overwrite"])
 
     if do_bootstrap:
         print(
             "The --bootstrap option is now the default behavior of the nabu-config command. This option is therefore not needed anymore."
         )
-
-    if path.isfile(args["output"]):
+    if path.isfile(args["output"]) and not (overwrite):
         rep = input("File %s already exists. Overwrite ? [y/N]" % args["output"])
         if rep.lower() != "y":
             print("Stopping")

nabu/app/cast_volume.py

@@ -7,6 +7,7 @@ import sys
 import logging
 from argparse import RawTextHelpFormatter
 import numpy
+from silx.io.url import DataUrl
 from tomoscan.esrf.volume.utils import guess_volumes
 from tomoscan.factory import Factory
 from tomoscan.esrf.volume import (
@@ -26,7 +27,6 @@ from nabu.pipeline.params import files_formats
 from nabu.utils import convert_str_to_tuple
 from nabu.io.cast_volume import _min_max_from_histo
 
-from silx.io.url import DataUrl
 
 _logger = logging.getLogger(__name__)
 
@@ -212,7 +212,9 @@ def main(argv=None):
     elif options.output_type is None:
         raise ValueError("'output_type' or 'output_volume' is expected")
     else:
-        output_volume = get_default_output_volume(input_volume=input_volume, output_type=output_format)
+        output_volume = get_default_output_volume(
+            input_volume=input_volume, output_type=output_format  # pylint: disable=E0606
+        )
     try:
         output_data_type = numpy.dtype(getattr(numpy, options.output_data_type))
     except Exception as e:

nabu/app/cli_configs.py

@@ -41,6 +41,11 @@ BootstrapConfig = {
         "default": "",
     },
     "helical": {"help": "Prepare configuration file for helical", "default": 0, "required": False, "type": int},
+    "overwrite": {
+        "help": "Whether to overwrite the output file if exists",
+        "action": "store_const",
+        "const": 1,
+    },
 }
 
 # Default configuration for "zsplit" command

nabu/app/composite_cor.py

@@ -99,7 +99,7 @@ def composite_cor_entry_point(args_dict):
         # if "near_pos" not in args.cor_options:
         #    scan = NXtomo()
         #    scan.load(file_path=nexus_name, data_path=args.entry_name)
-        #    estimated_near = scan.instrument.detector.estimated_cor_from_motor
+        #    estimated_near = scan.instrument.detector.x_rotation_axis_pixel_position
         #
         #    cor_options = args.cor_options + f" ; near_pos = {estimated_near} "
         #

nabu/app/create_distortion_map_from_poly.py

@@ -1,12 +1,11 @@
-from .. import version
+import sys
 import numpy as np
 import h5py
-import argparse
-import sys
+from .. import version
+from ..utils import DictToObj
+from ..resources.logger import Logger
 from .cli_configs import CreateDistortionMapHorizontallyMatchedFromPolyConfig
 from .utils import parse_params_values
-from ..utils import DictToObj
-from ..resources.logger import Logger, LoggerOrPrint
 
 
 def create_distortion_maps_entry_point(user_args=None):
@@ -52,7 +51,7 @@ def create_distortion_maps_entry_point(user_args=None):
 
     logger = Logger("create_distortion_maps", level=user_args["loglevel"], logfile="create_distortion_maps.log")
 
-    coords_source_x, coords_source_z, new_axis_pos = create_maps_x_and_z(args_dict)
+    coords_source_x, coords_source_z, new_axis_pos = create_maps_x_and_z(args_dict)  # pylint: disable=E0606
 
     with h5py.File(args_dict["target_file"], "w") as f:
         f["coords_source_x"] = coords_source_x

nabu/app/diag_to_pix.py

@@ -1,28 +1,16 @@
-from .. import version
-from os import environ
-
-import shutil
 import os
+from multiprocessing import Pool
 import sys
-import re
-import h5py
 import numpy as np
-import silx.math.fft
+from scipy.ndimage import gaussian_filter
+import h5py
 from silx.io.dictdump import h5todict
-
-
-from ..resources.logger import LoggerOrPrint
-
+from nxtomo.application.nxtomo import NXtomo
+from .. import version
+from ..utils import DictToObj, get_available_threads
 from .utils import parse_params_values
 from .cli_configs import DiagToPixConfig
-
-import h5py
-from nabu.utils import DictToObj
-from nabu.pipeline.estimators import oversample
-from scipy.ndimage import gaussian_filter
-from nxtomo.application.nxtomo import NXtomo
-from multiprocessing import Pool
-from ..utils import get_available_threads
+from ..pipeline.estimators import oversample
 
 
 """

nabu/app/diag_to_rot.py

@@ -1,30 +1,16 @@
-from .. import version
-from os import environ
-
-import argparse
-import shutil
 import os
 import sys
-import re
-import h5py
-import numpy as np
-
-
-from ..resources.logger import LoggerOrPrint
-from .utils import parse_params_values
-from .cli_configs import DiagToRotConfig
-
-from ..utils import get_available_threads
-
-from nxtomo.application.nxtomo import NXtomo
-
 from multiprocessing import Pool
-
-import h5py
-from nabu.utils import DictToObj
-from nabu.pipeline.estimators import oversample
+import numpy as np
 from scipy.ndimage import gaussian_filter
+import h5py
 from silx.io.dictdump import h5todict
+from nxtomo.application.nxtomo import NXtomo
+from .. import version
+from ..utils import get_available_threads, DictToObj
+from ..pipeline.estimators import oversample
+from .utils import parse_params_values
+from .cli_configs import DiagToRotConfig
 
 
 """
@@ -225,12 +211,11 @@ def find_best_interpolating_line(args):
 
             error = (diff_enes / (orig_enes + 1.0e-30)).astype("d").sum()
 
-            if error == error:
-                if not (error > best_error):
-                    best_error = error
-                    best_error_pair = index_ovlp_a, index_ovlp_b
+            if not (error > best_error):
+                best_error = error
+                best_error_pair = index_ovlp_a, index_ovlp_b
 
-    return best_error, best_error_pair
+    return best_error, best_error_pair  # pylint: disable=E0606
 
 
 def main(user_args=None):
@@ -262,7 +247,7 @@ def main(user_args=None):
 
         scan = NXtomo()
         scan.load(file_path=args.original_scan, data_path=args.entry_name)
-        args.near = scan.instrument.detector.estimated_cor_from_motor
+        args.near = scan.instrument.detector.x_rotation_axis_pixel_position
     else:
         pass
 
@@ -305,7 +290,7 @@ def main(user_args=None):
                 """
                 raise ValueError(message)
 
-        arguments_for_multiprocessing.append((diag, overlap_list, args))
+        arguments_for_multiprocessing.append((diag, overlap_list, args))  # pylint: disable=E0606
 
     ncpus = get_available_threads()
     with Pool(processes=ncpus) as pool:

nabu/app/double_flatfield.py

@@ -1,7 +1,6 @@
 import numpy as np
 from ..preproc.double_flatfield import DoubleFlatField
-from ..preproc.flatfield import FlatFieldDataUrls
-from ..io.reader import ChunkReader
+from ..preproc.flatfield import FlatField
 from ..io.writer import NXProcessWriter
 from ..resources.dataset_analyzer import analyze_dataset
 from ..resources.nxflatfield import update_dataset_info_flats_darks
@@ -16,44 +15,45 @@ class DoubleFlatFieldChunks:
     ):
         self.logger = LoggerOrPrint(logger)
         self.dataset_info = analyze_dataset(dataset_path, extra_options={"hdf5_entry": h5_entry}, logger=logger)
+        self.chunk_size = min(chunk_size, self.dataset_info.radio_dims[-1])
         self.do_flatfield = bool(do_flatfield)
         if self.do_flatfield:
-            update_dataset_info_flats_darks(self.dataset_info, flatfield_mode="force-compute")
+            update_dataset_info_flats_darks(self.dataset_info, flatfield_mode=True)
         self.output_file = output_file
         self.sigma = sigma if sigma is not None and abs(sigma) > 1e-5 else None
-        self._init_reader(chunk_size)
-        self._init_flatfield((None, None, 0, self.chunk_size))
-        self._init_dff()
 
-    def _init_reader(self, chunk_size, start_idx=0):
-        self.chunk_size = min(chunk_size, self.dataset_info.radio_dims[-1])
-        self.reader = ChunkReader(
-            self.dataset_info.projections,
-            sub_region=(None, None, start_idx, start_idx + self.chunk_size),
-            convert_float=True,
-        )
-        self.projections = self.reader.files_data
+    def _get_config(self):
+        conf = {
+            "dataset": self.dataset_info.location,
+            "entry": self.dataset_info.hdf5_entry or None,
+            "dff_sigma": self.sigma,
+            "do_flatfield": self.do_flatfield,
+        }
+        return conf
+
+    def _read_projections(self, chunk_size, start_idx=0):
+        reader_kwargs = {"sub_region": (slice(None), slice(start_idx, start_idx + chunk_size), slice(None))}
+        if self.dataset_info.kind == "edf":
+            reader_kwargs = {"n_reading_threads": 4}
+        self.reader = self.dataset_info.get_reader(**reader_kwargs)
+        self.projections = self.reader.load_data()
 
-    def _init_flatfield(self, subregion):
+    def _init_flatfield(self, start_z=None, end_z=None):
         if not self.do_flatfield:
             return
-        self.flatfield = FlatFieldDataUrls(
-            (self.dataset_info.n_angles, self.chunk_size, self.dataset_info.radio_dims[0]),
-            self.dataset_info.flats,
-            self.dataset_info.darks,
-            sorted(self.dataset_info.projections.keys()),
-            sub_region=subregion,
+        chunk_size = end_z - start_z if start_z is not None else self.chunk_size
+        self.flatfield = FlatField(
+            (self.dataset_info.n_angles, chunk_size, self.dataset_info.radio_dims[0]),
+            flats={k: arr[start_z:end_z, :] for k, arr in self.dataset_info.flats.items()},
+            darks={k: arr[start_z:end_z, :] for k, arr in self.dataset_info.darks.items()},
+            radios_indices=sorted(self.dataset_info.projections.keys()),
         )
 
-    def _apply_flatfield(self):
+    def _apply_flatfield(self, start_z=None, end_z=None):
         if self.do_flatfield:
+            self._init_flatfield(start_z=start_z, end_z=end_z)
             self.flatfield.normalize_radios(self.projections)
 
-    def _set_reader_subregion(self, subregion):
-        self.reader._set_subregion(subregion)
-        self.reader._init_reader()
-        self.reader._loaded = False
-
     def _init_dff(self):
         self.double_flatfield = DoubleFlatField(
             self.projections.shape,
@@ -63,15 +63,6 @@ class DoubleFlatFieldChunks:
             sigma_filter=self.sigma,
         )
 
-    def _get_config(self):
-        conf = {
-            "dataset": self.dataset_info.location,
-            "entry": self.dataset_info.hdf5_entry or None,
-            "dff_sigma": self.sigma,
-            "do_flatfield": self.do_flatfield,
-        }
-        return conf
-
     def compute_double_flatfield(self):
         """
         Compute the double flatfield for the current dataset.
@@ -84,21 +75,18 @@ class DoubleFlatFieldChunks:
         for i in range(n_steps):
             self.logger.debug("Computing DFF batch %d/%d" % (i + 1, n_steps + int(extra_step)))
             subregion = (None, None, i * chunk_size, (i + 1) * chunk_size)
-            self._set_reader_subregion(subregion)
-            self._init_flatfield(subregion)
-            self.reader.load_files()
-            self._apply_flatfield()
+            self._read_projections(chunk_size, start_idx=i * chunk_size)
+            self._apply_flatfield(start_z=i * chunk_size, end_z=(i + 1) * chunk_size)
+            self._init_dff()
             dff = self.double_flatfield.compute_double_flatfield(self.projections, recompute=True)
             res[subregion[-2] : subregion[-1]] = dff[:]
         # Need to initialize objects with a different shape
         if extra_step:
             curr_idx = (i + 1) * self.chunk_size
             self.logger.debug("Computing DFF batch %d/%d" % (i + 2, n_steps + int(extra_step)))
-            self._init_reader(n_z - curr_idx, start_idx=curr_idx)
-            self._init_flatfield(self.reader.sub_region)
+            self._read_projections(n_z - curr_idx, start_idx=curr_idx)
+            self._apply_flatfield(start_z=(i + 1) * chunk_size, end_z=n_z)
             self._init_dff()
-            self.reader.load_files()
-            self._apply_flatfield()
             dff = self.double_flatfield.compute_double_flatfield(self.projections, recompute=True)
             res[curr_idx:] = dff[:]
         return res

nabu/app/parse_reconstruction_log.py

@@ -73,11 +73,14 @@ def parse_logfile(fname, separator=" - "):
     start_text = "Going to reconstruct slices"
     end_text = "Merging reconstructions to"
 
+    start_line = None
     rec_log_bounds = []
     for i, line in enumerate(lines):
         if start_text in line:
             start_line = i
         if end_text in line:
+            if start_line is None:
+                raise ValueError("Could not find reconstruction start string indicator")
             rec_log_bounds.append((start_line, i))
             rec_file_basename = path.basename(line.split(end_text)[-1])
 

nabu/app/reconstruct.py

@@ -1,4 +1,6 @@
+from tomoscan.io import HDF5File
 from .. import version
+from ..utils import list_match_queries
 from ..pipeline.config import parse_nabu_config_file
 from ..pipeline.config_validators import convert_to_int
 from .cli_configs import ReconstructConfig
@@ -64,17 +66,6 @@ def get_reconstructor(args, overwrite_options=None):
 
     #
 
-    # A crash with scikit-cuda happens only on PPC64 platform if and nvidia-persistenced is running.
-    # On such machines, a warm-up has to be done.
-    import platform
-
-    if platform.machine() == "ppc64le":
-        try:
-            from silx.math.fft.cufft import CUFFT
-        except:  # can't catch narrower - cublasNotInitialized requires cublas !
-            CUFFT = None
-    #
-
     logfile = get_log_file(args["logfile"], args["log_file"], forbidden=[args["input_file"]])
     conf_dict = parse_nabu_config_file(args["input_file"])
     update_reconstruction_start_end(conf_dict, args["slice"].strip())
@@ -101,18 +92,65 @@ def get_reconstructor(args, overwrite_options=None):
     return reconstructor
 
 
+def list_hdf5_entries(fname):
+    with HDF5File(fname, "r") as f:
+        entries = list(f.keys())
+    return entries
+
+
 def main():
     args = parse_params_values(
         ReconstructConfig,
         parser_description=f"Perform a tomographic reconstruction.",
         program_version="nabu " + version,
     )
+    # Get extra options
+    extra_options = {
+        "gpu_mem_fraction": args["gpu_mem_fraction"],
+        "cpu_mem_fraction": args["cpu_mem_fraction"],
+        "chunk_size": args["max_chunk_size"] if args["max_chunk_size"] > 0 else None,
+        "margin": args["phase_margin"],
+        "force_grouped_mode": bool(args["force_use_grouped_pipeline"]),
+    }
+    #
+
+    logfile = get_log_file(args["logfile"], args["log_file"], forbidden=[args["input_file"]])
+    conf_dict = parse_nabu_config_file(args["input_file"])
+    update_reconstruction_start_end(conf_dict, args["slice"].strip())
 
-    R = get_reconstructor(args)
-    proc = R.process_config
+    # Imports are done here, otherwise "nabu --version" takes forever
+    from ..pipeline.fullfield.processconfig import ProcessConfig
+    from ..pipeline.fullfield.reconstruction import FullFieldReconstructor
+
+    #
 
-    R.reconstruct()
-    R.finalize_files_saving()
+    hdf5_entries = conf_dict["dataset"].get("hdf5_entry", "").strip(",")
+    # spit by coma and remove empty spaces
+    hdf5_entries = [e.strip() for e in hdf5_entries.split(",")]
+    # clear '/' at beginning of the entry (so both entry like 'entry0000' and '/entry0000' are handled)
+    hdf5_entries = [e.lstrip("/") for e in hdf5_entries]
+
+    if hdf5_entries != [""]:
+        file_hdf5_entries = list_hdf5_entries(conf_dict["dataset"]["location"])
+        hdf5_entries = list_match_queries(file_hdf5_entries, hdf5_entries)
+        if hdf5_entries == []:
+            raise ValueError("No entry found matching pattern '%s'" % conf_dict["dataset"]["hdf5_entry"])
+
+    for hdf5_entry in hdf5_entries:
+        if len(hdf5_entries) > 1:
+            print("-" * 80)
+            print("Processing entry: %s" % hdf5_entry)
+            print("-" * 80)
+        conf_dict["dataset"]["hdf5_entry"] = hdf5_entry
+        proc = ProcessConfig(conf_dict=conf_dict, create_logger=logfile)  # logger is in append mode
+        logger = proc.logger
+        logger.info("Going to reconstruct slices (%d, %d)" % (proc.rec_region["start_z"], proc.rec_region["end_z"]))
+
+        R = FullFieldReconstructor(proc, logger=logger, extra_options=extra_options)
+        proc = R.process_config
+
+        R.reconstruct()
+        R.finalize_files_saving()
     return 0
 
 

nabu/app/reconstruct_helical.py

@@ -49,10 +49,10 @@ def main_helical():
     proc = ProcessConfig(conf_dict=conf_dict, create_logger=logfile)
     logger = proc.logger
 
-    if "rotate_projections" in proc.processing_steps:
+    if "tilt_correction" in proc.processing_steps:
         message = """ The rotate_projections step is activated. The Helical pipelines are not yet suited for  projection rotation
         it will soon be implemented. For the moment
-        you should desactivate the rotation options in nabu.conf
+        you should deactivate the rotation options in nabu.conf
         """
         raise ValueError(message)
 

nabu/app/stitching.py

@@ -1,12 +1,12 @@
 import logging
-from nabu.utils import Progress
+from pprint import pformat
+
+from tqdm import tqdm
 from nabu.stitching.slurm_utils import split_stitching_configuration_to_slurm_job
 from .cli_configs import StitchingConfig
 from ..pipeline.config import parse_nabu_config_file
-from nabu.stitching.z_stitching import (
-    z_stitching,
-    StitchingPostProcAggregation,
-)
+from nabu.stitching.single_axis_stitching import stitching
+from nabu.stitching.utils.post_processing import StitchingPostProcAggregation
 from nabu.stitching.config import dict_to_config_obj
 from .utils import parse_params_values
 
@@ -30,11 +30,13 @@ def main():
     conf_dict = parse_nabu_config_file(args["input-file"], allow_no_value=True)
 
     stitching_config = dict_to_config_obj(conf_dict)
+    assert stitching_config.axis is not None, "axis must be defined to know how to stitch"
+    _logger.info(" when loaded axis is %s", stitching_config.axis)
     stitching_config.settle_inputs()
     if args["only_create_master_file"]:
         # option to ease creation of the master in the following cases:
-        # * user has submitted all the job but has been quicked out of the cluster
-        # * only a few slurm job for some random version (cluster update...) and user want to retriger only those job and process the aggragation only. On those cases no need to redo it all.
+        # * user has submitted all the job but has been kicked out of the cluster
+        # * only a few slurm job for some random version (cluster update...) and user want to retrigger only those job and process the aggregation only. On those cases no need to redo it all.
         tomo_objs = []
         for _, sub_config in split_stitching_configuration_to_slurm_job(stitching_config, yield_configuration=True):
             tomo_objs.append(sub_config.get_output_object().get_identifier().to_str())
@@ -47,34 +49,46 @@ def main():
 
     elif stitching_config.slurm_config.partition in (None, ""):
         # case 1: run locally
-        _logger.info(f"run stitching locally with {stitching_config}")
+        _logger.info("run stitching locally with: %s", pformat(stitching_config.to_dict()))
 
-        progress = Progress("z-stitching")
-        progress.set_name("initialize z-stitching")
-        progress.set_advancement(0)
-        z_stitching(stitching_config, progress=progress)
+        main_progress = tqdm(total=100, desc="stitching", leave=True)
+        stitching(stitching_config, progress=main_progress)
     else:
         if not has_sluurp:
             raise ImportError(
-                "sluurp not install. Please install it to distribute stitching on slurm (pip install sluurm)"
+                "sluurp not install. Please install it to distribute stitching on slurm (pip install slurm)"
             )
+        main_progress = tqdm(total=100, position=0, desc="stitching")
+
         # case 2: run on slurm
         # note: to speed up we could do shift research on pre processing and run it only once (if manual of course). Here it will be run for all part
         _logger.info(f"will distribute stitching")
 
         futures = {}
         # 2.1 launch jobs
+        slurm_job_progress_bars: dict = {}
         for i_job, (job, sub_config) in enumerate(
             split_stitching_configuration_to_slurm_job(stitching_config, yield_configuration=True)
         ):
             _logger.info(f"submit job nb {i_job}: handles {sub_config.slices}")
             output_volume = sub_config.get_output_object().get_identifier().to_str()
             futures[output_volume] = submit(job, timeout=999999)
+            # note on total=100: we only consider percentage in this case (providing advancement from slurm jobs)
+            slurm_job_progress_bars[job] = tqdm(
+                total=100,
+                position=i_job + 1,
+                desc=f"   part {str(i_job).ljust(3)}",
+                delay=0.5,  # avoid to mess with terminal and (near) future logs
+                bar_format="{l_bar}{bar}",  # avoid using 'r_bar' as 'total' is set to 100 (percentage)
+                leave=False,
+            )
 
+        main_progress.n = 50
         # 2.2 wait for future to be done and concatenate the result
         post_processing = StitchingPostProcAggregation(
             futures=futures,
             stitching_config=stitching_config,
+            progress_bars=slurm_job_progress_bars,
         )
         post_processing.process()
 

nabu/app/tests/test_reduce_dark_flat.py

@@ -3,7 +3,10 @@ import pytest
 from nabu.app.reduce_dark_flat import reduce_dark_flat
 
 #####
-from tomoscan.test.utils import NXtomoMockContext
+try:
+    from tomoscan.tests.utils import NXtomoMockContext
+except ImportError:
+    from tomoscan.test.utils import NXtomoMockContext
 
 
 @pytest.fixture(scope="function")

nabu/cuda/kernel.py

@@ -1,6 +1,7 @@
 import pycuda.gpuarray as garray
 from pycuda.compiler import SourceModule
 from ..processing.kernel_base import KernelBase
+from ..utils import catch_warnings  # TODO use warnings.catch_warnings once python < 3.11 is dropped
 
 
 class CudaKernel(KernelBase):
@@ -37,16 +38,24 @@ class CudaKernel(KernelBase):
         signature=None,
         texrefs=None,
         automation_params=None,
+        silent_compilation_warnings=False,
         **sourcemodule_kwargs,
     ):
-        super().__init__(kernel_name, filename=filename, src=src, automation_params=automation_params)
+        super().__init__(
+            kernel_name,
+            filename=filename,
+            src=src,
+            automation_params=automation_params,
+            silent_compilation_warnings=silent_compilation_warnings,
+        )
         self.compile_kernel_source(kernel_name, sourcemodule_kwargs)
         self.prepare(signature, texrefs)
 
     def compile_kernel_source(self, kernel_name, sourcemodule_kwargs):
         self.sourcemodule_kwargs = sourcemodule_kwargs
         self.kernel_name = kernel_name
-        self.module = SourceModule(self.src, **self.sourcemodule_kwargs)
+        with catch_warnings(action=("ignore" if self.silent_compilation_warnings else None)):  # pylint: disable=E1123
+            self.module = SourceModule(self.src, **self.sourcemodule_kwargs)
         self.func = self.module.get_function(kernel_name)
 
     def prepare(self, kernel_signature, texrefs):

nabu/cuda/processing.py

@@ -49,7 +49,7 @@ class CudaProcessing(ProcessingBase):
         self.stream = stream
         self.device = self.ctx.get_device()
         self.device_name = self.device.name()
-        self.device_id = self.device.get_attribute(dev_attrs.MULTI_GPU_BOARD_GROUP_ID)
+        self.device_id = self.device.get_attribute(dev_attrs.MULTI_GPU_BOARD_GROUP_ID)  # pylint: disable=E0606
 
     def push_context(self):
         self.ctx.push()
@@ -64,7 +64,7 @@ class CudaProcessing(ProcessingBase):
     def kernel(
         self, kernel_name, filename=None, src=None, signature=None, texrefs=None, automation_params=None, **build_kwargs
     ):
-        return CudaKernel(
+        return CudaKernel(  # pylint: disable=E0606
             kernel_name,
             filename=filename,
             src=src,