misc: Manual linting for Devito

Author: JDBetteridge

devito/arch/archinfo.py

@@ -18,7 +18,7 @@
 from devito.logger import warning
 from devito.tools import all_equal, as_tuple, memoized_func
 
-__all__ = [
+__all__ = [  # noqa: RUF022
     'platform_registry', 'get_cpu_info', 'get_gpu_info', 'get_visible_devices',
     'get_nvidia_cc', 'get_cuda_path', 'get_cuda_version', 'get_hip_path',
     'check_cuda_runtime', 'get_m1_llvm_path', 'get_advisor_path', 'Platform',
@@ -391,7 +391,7 @@ def cbk(deviceid=0):
                     return None
                 return cbk
 
-            gpu_info['mem.%s' % i] = make_cbk(i)
+            gpu_info[f'mem.{i}'] = make_cbk(i)
 
         gpu_info['architecture'] = 'unspecified'
         gpu_info['vendor'] = 'INTEL'
@@ -780,7 +780,7 @@ def __str__(self):
         return self.name
 
     def __repr__(self):
-        return "TargetPlatform[%s]" % self.name
+        return f'TargetPlatform[{self.name}]'
 
     def _detect_isa(self):
         return 'unknown'
@@ -1141,7 +1141,7 @@ def supports(self, query, language=None):
         elif query == 'async-loads' and cc >= 80:
             # Asynchronous pipeline loads -- introduced in Ampere
             return True
-        elif query in ('tma', 'thread-block-cluster') and cc >= 90:
+        elif query in ('tma', 'thread-block-cluster') and cc >= 90:  # noqa: SIM103
             # Tensor Memory Accelerator -- introduced in Hopper
             return True
         else:
@@ -1202,10 +1202,8 @@ def march(cls):
         try:
             p1 = Popen(['offload-arch'], stdout=PIPE, stderr=PIPE)
         except OSError:
-            try:
+            with suppress(OSError):
                 p1 = Popen(['mygpu', '-d', fallback], stdout=PIPE, stderr=PIPE)
-            except OSError:
-                pass
             return fallback
 
         output, _ = p1.communicate()
@@ -1248,7 +1246,7 @@ def node_max_mem_trans_nbytes(platform):
     elif isinstance(platform, Device):
         return max(Cpu64.max_mem_trans_nbytes, mmtb0)
     else:
-        assert False, f"Unknown platform type: {type(platform)}"
+        raise AssertionError(f"Unknown platform type: {type(platform)}")
 
 
 # CPUs

devito/arch/compiler.py

@@ -1,6 +1,7 @@
 import platform
 import time
 import warnings
+from contextlib import suppress
 from functools import partial
 from hashlib import sha1
 from itertools import filterfalse
@@ -43,16 +44,20 @@ def sniff_compiler_version(cc, allow_fail=False):
             return Version("0")
     except UnicodeDecodeError:
         return Version("0")
-    except OSError:
+    except OSError as e:
         if allow_fail:
             return Version("0")
         else:
-            raise RuntimeError(f"The `{cc}` compiler isn't available on this system")
+            raise RuntimeError(
+                f"The `{cc}` compiler isn't available on this system"
+            ) from e
 
     ver = ver.strip()
     if ver.startswith("gcc"):
         compiler = "gcc"
-    elif ver.startswith("clang") or ver.startswith("Apple LLVM") or ver.startswith("Homebrew clang"):
+    elif ver.startswith("clang") \
+            or ver.startswith("Apple LLVM") \
+            or ver.startswith("Homebrew clang"):
         compiler = "clang"
     elif ver.startswith("Intel"):
         compiler = "icx"
@@ -92,10 +97,8 @@ def sniff_compiler_version(cc, allow_fail=False):
             pass
 
     # Pure integer versions (e.g., ggc5, rather than gcc5.0) need special handling
-    try:
+    with suppress(TypeError):
         ver = Version(float(ver))
-    except TypeError:
-        pass
 
     return ver
 
@@ -335,21 +338,21 @@ def make(self, loc, args):
         logfile = path.join(self.get_jit_dir(), f"{hash_key}.log")
         errfile = path.join(self.get_jit_dir(), f"{hash_key}.err")
 
-        with change_directory(loc), open(logfile, "w") as lf:
-            with open(errfile, "w") as ef:
-
-                command = ['make'] + args
-                lf.write("Compilation command:\n")
-                lf.write(" ".join(command))
-                lf.write("\n\n")
-                try:
-                    check_call(command, stderr=ef, stdout=lf)
-                except CalledProcessError as e:
-                    raise CompilationError(f'Command "{e.cmd}" return error status'
-                                           f'{e.returncode}. '
-                                           f'Unable to compile code.\n'
-                                           f'Compile log in {logfile}\n'
-                                           f'Compile errors in {errfile}\n')
+        with change_directory(loc), open(logfile, "w") as lf, open(errfile, "w") as ef:
+            command = ['make'] + args
+            lf.write("Compilation command:\n")
+            lf.write(" ".join(command))
+            lf.write("\n\n")
+            try:
+                check_call(command, stderr=ef, stdout=lf)
+            except CalledProcessError as e:
+                raise CompilationError(
+                    f'Command "{e.cmd}" return error status'
+                    f'{e.returncode}. '
+                    f'Unable to compile code.\n'
+                    f'Compile log in {logfile}\n'
+                    f'Compile errors in {errfile}\n'
+                ) from e
         debug(f"Make <{' '.join(args)}>")
 
     def _cmdline(self, files, object=False):
@@ -395,9 +398,11 @@ def jit_compile(self, soname, code):
                 # ranks would end up creating different cache dirs
                 cache_dir = cache_dir.joinpath('jit-backdoor')
                 cache_dir.mkdir(parents=True, exist_ok=True)
-            except FileNotFoundError:
-                raise ValueError(f"Trying to use the JIT backdoor for `{src_file}`, but "
-                                 "the file isn't present")
+            except FileNotFoundError as e:
+                raise ValueError(
+                    f"Trying to use the JIT backdoor for `{src_file}`, but "
+                    "the file isn't present"
+                ) from e
 
         # Should the compilation command be emitted?
         debug = configuration['log-level'] == 'DEBUG'
@@ -708,12 +713,10 @@ def __init_finalize__(self, **kwargs):
             # explicitly pass the flags that an `mpicc` would implicitly use
             compile_flags, link_flags = sniff_mpi_flags('mpicxx')
 
-            try:
+            with suppress(ValueError):
                 # No idea why `-pthread` would pop up among the `compile_flags`
+                # Just in case they fix it, we wrap it up within a suppress
                 compile_flags.remove('-pthread')
-            except ValueError:
-                # Just in case they fix it, we wrap it up within a try-except
-                pass
             self.cflags.extend(compile_flags)
 
             # Some arguments are for the host compiler
@@ -1005,15 +1008,9 @@ def __new__(cls, *args, **kwargs):
         elif isinstance(platform, IntelDevice):
             _base = OneapiCompiler
         elif isinstance(platform, NvidiaDevice):
-            if language == 'cuda':
-                _base = CudaCompiler
-            else:
-                _base = NvidiaCompiler
+            _base = CudaCompiler if language == 'cuda' else NvidiaCompiler
         elif platform is AMDGPUX:
-            if language == 'hip':
-                _base = HipCompiler
-            else:
-                _base = AOMPCompiler
+            _base = HipCompiler if language == 'hip' else AOMPCompiler
         else:
             _base = GNUCompiler
 

devito/builtins/arithmetic.py

@@ -33,7 +33,7 @@ def norm(f, order=2):
 
     op = dv.Operator([dv.Eq(s, 0.0)] + eqns +
                      [dv.Inc(s, Pow(dv.Abs(p), order)), dv.Eq(n[0], s)],
-                     name='norm%d' % order)
+                     name=f'norm{order}')
     op.apply(**kwargs)
 
     v = np.power(n.data[0], 1/order)
@@ -63,24 +63,24 @@ def sum(f, dims=None):
     new_dims = tuple(d for d in f.dimensions if d not in dims)
     shape = tuple(f._size_domain[d] for d in new_dims)
     if f.is_TimeFunction and f.time_dim not in dims:
-        out = f._rebuild(name="%ssum" % f.name, shape=shape, dimensions=new_dims,
+        out = f._rebuild(name=f'{f.name}sum', shape=shape, dimensions=new_dims,
                          initializer=np.empty(0))
     elif f.is_SparseTimeFunction:
         if f.time_dim in dims:
             # Sum over time -> SparseFunction
             new_coords = f.coordinates._rebuild(
-                name="%ssum_coords" % f.name, initializer=f.coordinates.initializer
+                name=f'{f.name}sum_coords', initializer=f.coordinates.initializer
             )
-            out = dv.SparseFunction(name="%ssum" % f.name, grid=f.grid,
+            out = dv.SparseFunction(name=f'{f.name}sum', grid=f.grid,
                                     dimensions=new_dims, npoint=f.shape[1],
                                     coordinates=new_coords)
         else:
             # Sum over rec -> TimeFunction
-            out = dv.TimeFunction(name="%ssum" % f.name, grid=f.grid, shape=shape,
+            out = dv.TimeFunction(name=f'{f.name}sum', grid=f.grid, shape=shape,
                                   dimensions=new_dims, space_order=0,
                                   time_order=f.time_order)
     else:
-        out = dv.Function(name="%ssum" % f.name, grid=f.grid,
+        out = dv.Function(name=f'{f.name}sum', grid=f.grid,
                           space_order=f.space_order, shape=shape,
                           dimensions=new_dims)
 
@@ -217,4 +217,4 @@ def _reduce_func(f, func, mfunc):
         else:
             return v.item()
     else:
-        raise ValueError("Expected Function, got `%s`" % type(f))
+        raise ValueError(f'Expected Function, got `{type(f)}`')

devito/builtins/initializers.py

@@ -59,18 +59,18 @@ def assign(f, rhs=0, options=None, name='assign', assign_halo=False, **kwargs):
 
     eqs = []
     if options:
-        for i, j, k in zip(as_list(f), rhs, options):
+        for i, j, k in zip(as_list(f), rhs, options, strict=True):
             if k is not None:
                 eqs.append(dv.Eq(i, j, **k))
             else:
                 eqs.append(dv.Eq(i, j))
     else:
-        for i, j in zip(as_list(f), rhs):
+        for i, j in zip(as_list(f), rhs, strict=True):
             eqs.append(dv.Eq(i, j))
 
     if assign_halo:
         subs = {}
-        for d, h in zip(f.dimensions, f._size_halo):
+        for d, h in zip(f.dimensions, f._size_halo, strict=True):
             if sum(h) == 0:
                 continue
             subs[d] = dv.CustomDimension(name=d.name, parent=d,
@@ -143,15 +143,15 @@ def __init__(self, lw):
             self.lw = lw
 
         def define(self, dimensions):
-            return {d: ('middle', l, l) for d, l in zip(dimensions, self.lw)}
+            return {d: ('middle', l, l) for d, l in zip(dimensions, self.lw, strict=True)}
 
     def create_gaussian_weights(sigma, lw):
         weights = [w/w.sum() for w in (np.exp(-0.5/s**2*(np.linspace(-l, l, 2*l+1))**2)
-                   for s, l in zip(sigma, lw))]
+                   for s, l in zip(sigma, lw, strict=True))]
         return as_tuple(np.array(w) for w in weights)
 
     def fset(f, g):
-        indices = [slice(l, -l, 1) for _, l in zip(g.dimensions, lw)]
+        indices = [slice(l, -l, 1) for _, l in zip(g.dimensions, lw, strict=True)]
         slices = (slice(None, None, 1), )*g.ndim
         if isinstance(f, np.ndarray):
             f[slices] = g.data[tuple(indices)]
@@ -182,7 +182,7 @@ def fset(f, g):
 
     # Create the padded grid:
     objective_domain = ObjectiveDomain(lw)
-    shape_padded = tuple([np.array(s) + 2*l for s, l in zip(shape, lw)])
+    shape_padded = tuple([np.array(s) + 2*l for s, l in zip(shape, lw, strict=True)])
     extent_padded = tuple([s-1 for s in shape_padded])
     grid = dv.Grid(shape=shape_padded, subdomains=objective_domain,
                    extent=extent_padded)
@@ -193,7 +193,7 @@ def fset(f, g):
     weights = create_gaussian_weights(sigma, lw)
 
     mapper = {}
-    for d, l, w in zip(f_c.dimensions, lw, weights):
+    for d, l, w in zip(f_c.dimensions, lw, weights, strict=True):
         lhs = []
         rhs = []
         options = []
@@ -238,13 +238,15 @@ def _initialize_function(function, data, nbl, mapper=None, mode='constant'):
         def buff(i, j):
             return [(i + k - 2*max(max(nbl))) for k in j]
 
-        b = [min(l) for l in (w for w in (buff(i, j) for i, j in zip(local_size, halo)))]
+        b = [min(l) for l in (
+            w for w in (buff(i, j) for i, j in zip(local_size, halo, strict=True))
+        )]
         if any(np.array(b) < 0):
-            raise ValueError("Function `%s` halo is not sufficiently thick." % function)
+            raise ValueError(f'Function `{function}` halo is not sufficiently thick.')
 
-    for d, (nl, nr) in zip(function.space_dimensions, as_tuple(nbl)):
-        dim_l = dv.SubDimension.left(name='abc_%s_l' % d.name, parent=d, thickness=nl)
-        dim_r = dv.SubDimension.right(name='abc_%s_r' % d.name, parent=d, thickness=nr)
+    for d, (nl, nr) in zip(function.space_dimensions, as_tuple(nbl), strict=True):
+        dim_l = dv.SubDimension.left(name=f'abc_{d.name}_l', parent=d, thickness=nl)
+        dim_r = dv.SubDimension.right(name=f'abc_{d.name}_r', parent=d, thickness=nr)
         if mode == 'constant':
             subsl = nl
             subsr = d.symbolic_max - nr
@@ -259,7 +261,7 @@ def buff(i, j):
         rhs.append(function.subs({d: subsr}))
         options.extend([None, None])
 
-        if mapper and d in mapper.keys():
+        if mapper and d in mapper:
             exprs = mapper[d]
             lhs_extra = exprs['lhs']
             rhs_extra = exprs['rhs']
@@ -353,8 +355,9 @@ def initialize_function(function, data, nbl, mapper=None, mode='constant',
         if not isinstance(data, (list, tuple)):
             raise TypeError("Expected a list of `data`")
         elif len(function) != len(data):
-            raise ValueError("Expected %d `data` items, got %d" %
-                             (len(function), len(data)))
+            raise ValueError(
+                f'Expected {len(function)} `data` items, got {len(data)}'
+            )
 
         if mapper is not None:
             raise NotImplementedError("Unsupported `mapper` with batching")
@@ -374,14 +377,14 @@ def initialize_function(function, data, nbl, mapper=None, mode='constant',
         f._create_data()
 
     if nbl == 0:
-        for f, data in zip(functions, datas):
+        for f, data in zip(functions, datas, strict=True):
             if isinstance(data, dv.Function):
                 f.data[:] = data.data[:]
             else:
                 f.data[:] = data[:]
     else:
         lhss, rhss, optionss = [], [], []
-        for f, data in zip(functions, datas):
+        for f, data in zip(functions, datas, strict=True):
 
             lhs, rhs, options = _initialize_function(f, data, nbl, mapper, mode)
 
@@ -391,7 +394,7 @@ def initialize_function(function, data, nbl, mapper=None, mode='constant',
 
         assert len(lhss) == len(rhss) == len(optionss)
 
-        name = name or 'initialize_%s' % '_'.join(f.name for f in functions)
+        name = name or f'initialize_{"_".join(f.name for f in functions)}'
         assign(lhss, rhss, options=optionss, name=name, **kwargs)
 
     if pad_halo: