lint: First pass with ruff --fix

Author: JDBetteridge

benchmarks/user/advisor/roofline.py

@@ -128,7 +128,7 @@ def roofline(name, project, scale, precision, mode, th):
                 # y = bandwidth * x
                 x1, x2 = 0, min(width, max_compute_bandwidth / bandwidth)
                 y1, y2 = 0, x2*bandwidth
-                label = '{} {:.0f} GB/s'.format(roof.name, bandwidth)
+                label = f'{roof.name} {bandwidth:.0f} GB/s'
                 ax.plot([x1, x2], [y1, y2], '-', label=label)
                 memory_roofs.append(((x1, x2), (y1, y2)))
 
@@ -138,7 +138,7 @@ def roofline(name, project, scale, precision, mode, th):
                 bandwidth /= scale  # scale down as requested by the user
                 x1, x2 = max(bandwidth / max_memory_bandwidth, 0), width
                 y1, y2 = bandwidth, bandwidth
-                label = '{} {:.0f} GFLOPS'.format(roof.name, bandwidth)
+                label = f'{roof.name} {bandwidth:.0f} GFLOPS'
                 ax.plot([x1, x2], [y1, y2], '-', label=label)
                 compute_roofs.append(((x1, x2), (y1, y2)))
 

benchmarks/user/benchmark.py

@@ -274,7 +274,7 @@ def run(problem, **kwargs):
     # Note: the following piece of code is horribly *hacky*, but it works for now
     for i, block_shape in enumerate(block_shapes):
         for n, level in enumerate(block_shape):
-            for d, s in zip(['x', 'y', 'z'], level):
+            for d, s in zip(['x', 'y', 'z'], level, strict=False):
                 options['%s%d_blk%d_size' % (d, i, n)] = s
 
     solver = setup(space_order=space_order, time_order=time_order, **kwargs)

devito/arch/archinfo.py

@@ -48,7 +48,7 @@ def get_cpu_info():
 
     # Obtain textual cpu info
     try:
-        with open('/proc/cpuinfo', 'r') as f:
+        with open('/proc/cpuinfo') as f:
             lines = f.readlines()
     except FileNotFoundError:
         lines = []
@@ -696,9 +696,7 @@ def get_platform():
         elif 'intel' in brand:
             # Most likely a desktop i3/i5/i7
             return platform_registry['intel64']
-        elif 'power8' in brand:
-            return platform_registry['power8']
-        elif 'power9' in brand:
+        elif 'power8' in brand or 'power9' in brand:
             return platform_registry['power8']
         elif 'arm' in brand:
             return platform_registry['arm']

devito/arch/compiler.py

@@ -23,7 +23,7 @@
     as_list, change_directory, filter_ordered, make_tempdir, memoized_func
 )
 
-__all__ = ['sniff_mpi_distro', 'compiler_registry']
+__all__ = ['compiler_registry', 'sniff_mpi_distro']
 
 
 @memoized_func
@@ -51,11 +51,7 @@ def sniff_compiler_version(cc, allow_fail=False):
     ver = ver.strip()
     if ver.startswith("gcc"):
         compiler = "gcc"
-    elif ver.startswith("clang"):
-        compiler = "clang"
-    elif ver.startswith("Apple LLVM"):
-        compiler = "clang"
-    elif 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"
@@ -388,7 +384,7 @@ def jit_compile(self, soname, code):
             # Warning: dropping `code` on the floor in favor to whatever is written
             # within `src_file`
             try:
-                with open(src_file, 'r') as f:
+                with open(src_file) as f:
                     code = f.read()
                     code = f'{code}/* Backdoor edit at {time.ctime()}*/ \n'
                 # Bypass the devito JIT cache

devito/builtins/arithmetic.py

@@ -3,7 +3,7 @@
 import devito as dv
 from devito.builtins.utils import check_builtins_args, make_retval
 
-__all__ = ['norm', 'sumall', 'sum', 'inner', 'mmin', 'mmax']
+__all__ = ['inner', 'mmax', 'mmin', 'norm', 'sum', 'sumall']
 
 
 @dv.switchconfig(log_level='ERROR')

devito/builtins/initializers.py

@@ -4,7 +4,7 @@
 from devito.builtins.utils import check_builtins_args, nbl_to_padsize, pad_outhalo
 from devito.tools import as_list, as_tuple
 
-__all__ = ['assign', 'smooth', 'gaussian_smooth', 'initialize_function']
+__all__ = ['assign', 'gaussian_smooth', 'initialize_function', 'smooth']
 
 
 @dv.switchconfig(log_level='ERROR')
@@ -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=False):
             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=False):
             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=False):
             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=False)}
 
     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=False))]
         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=False)]
         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=False)])
     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=False):
         lhs = []
         rhs = []
         options = []
@@ -238,11 +238,11 @@ 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=False)))]
         if any(np.array(b) < 0):
             raise ValueError("Function `%s` halo is not sufficiently thick." % function)
 
-    for d, (nl, nr) in zip(function.space_dimensions, as_tuple(nbl)):
+    for d, (nl, nr) in zip(function.space_dimensions, as_tuple(nbl), strict=False):
         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)
         if mode == 'constant':
@@ -373,14 +373,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=False):
             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=False):
 
             lhs, rhs, options = _initialize_function(f, data, nbl, mapper, mode)
 

devito/builtins/utils.py

@@ -7,8 +7,13 @@
 from devito.symbolics import uxreplace
 from devito.tools import as_tuple
 
-__all__ = ['make_retval', 'nbl_to_padsize', 'pad_outhalo', 'abstract_args',
-           'check_builtins_args']
+__all__ = [
+    'abstract_args',
+    'check_builtins_args',
+    'make_retval',
+    'nbl_to_padsize',
+    'pad_outhalo',
+]
 
 
 accumulator_mapper = {

devito/core/arm.py

@@ -1,8 +1,12 @@
 from devito.core.cpu import Cpu64AdvCOperator, Cpu64AdvCXXOperator, Cpu64AdvOperator
 from devito.passes.iet import CXXOmpTarget, OmpTarget
 
-__all__ = ['ArmAdvCOperator', 'ArmAdvOmpOperator', 'ArmAdvCXXOperator',
-           'ArmAdvCXXOmpOperator']
+__all__ = [
+    'ArmAdvCOperator',
+    'ArmAdvCXXOmpOperator',
+    'ArmAdvCXXOperator',
+    'ArmAdvOmpOperator',
+]
 
 
 ArmAdvOperator = Cpu64AdvOperator

devito/core/autotuning.py

@@ -271,9 +271,9 @@ def calculate_nblocks(tree, blockable):
     collapsed = tree[index:index + (ncollapsed or index+1)]
     blocked = [i.dim for i in collapsed if i.dim in blockable]
     remainders = [(d.root.symbolic_max-d.root.symbolic_min+1) % d.step for d in blocked]
-    niters = [d.root.symbolic_max - i for d, i in zip(blocked, remainders)]
+    niters = [d.root.symbolic_max - i for d, i in zip(blocked, remainders, strict=False)]
     nblocks = prod((i - d.root.symbolic_min + 1) / d.step
-                   for d, i in zip(blocked, niters))
+                   for d, i in zip(blocked, niters, strict=False))
     return nblocks
 
 
@@ -324,7 +324,7 @@ def generate_block_shapes(blockable, args, level):
     level_1 = [d for d, v in mapper.items() if v == 1]
     if level_1:
         assert len(level_1) == len(level_0)
-        assert all(d1.parent is d0 for d0, d1 in zip(level_0, level_1))
+        assert all(d1.parent is d0 for d0, d1 in zip(level_0, level_1, strict=False))
         for bs in list(ret):
             handle = []
             for v in options['blocksize-l1']:

devito/core/cpu.py

@@ -15,10 +15,20 @@
 )
 from devito.tools import timed_pass
 
-__all__ = ['Cpu64NoopCOperator', 'Cpu64NoopOmpOperator', 'Cpu64AdvCOperator',
-           'Cpu64AdvOmpOperator', 'Cpu64FsgCOperator', 'Cpu64FsgOmpOperator',
-           'Cpu64CustomOperator', 'Cpu64CustomCXXOperator', 'Cpu64AdvCXXOperator',
-           'Cpu64AdvCXXOmpOperator', 'Cpu64FsgCXXOperator', 'Cpu64FsgCXXOmpOperator']
+__all__ = [
+    'Cpu64AdvCOperator',
+    'Cpu64AdvCXXOmpOperator',
+    'Cpu64AdvCXXOperator',
+    'Cpu64AdvOmpOperator',
+    'Cpu64CustomCXXOperator',
+    'Cpu64CustomOperator',
+    'Cpu64FsgCOperator',
+    'Cpu64FsgCXXOmpOperator',
+    'Cpu64FsgCXXOperator',
+    'Cpu64FsgOmpOperator',
+    'Cpu64NoopCOperator',
+    'Cpu64NoopOmpOperator',
+]
 
 
 class Cpu64OperatorMixin: