misc: Fix flake8 violations in f-string conversion

Address line length (E501), indentation (E127), and syntax (E999)
issues introduced during the % to f-string conversion. Fixed f-string
syntax errors by extracting backslash expressions to variables.
All modified files now pass flake8 checks.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: mloubout

devito/arch/compiler.py

@@ -681,8 +681,9 @@ def __init_finalize__(self, **kwargs):
                     proc_link_flags.extend(['-Xcompiler', '-pthread'])
                 elif i.startswith('-Wl'):
                     # E.g., `-Wl,-rpath` -> `-Xcompiler "-Wl\,-rpath"`
+                    escaped_i = i.replace(",", r"\\,")
                     proc_link_flags.extend([
-                        '-Xcompiler', f'"{i.replace(",", r"\\,")}"'
+                        '-Xcompiler', f'"{escaped_i}"'
                     ])
                 else:
                     proc_link_flags.append(i)

devito/data/allocators.py

@@ -375,9 +375,11 @@ def __init__(self, numpy_array):
 
     def alloc(self, shape, dtype, padding=0):
         assert shape == self.numpy_array.shape, \
-            f"Provided array has shape {str(self.numpy_array.shape)}. Expected {str(shape)}"
+            (f"Provided array has shape {str(self.numpy_array.shape)}. "
+             f"Expected {str(shape)}")
         assert dtype == self.numpy_array.dtype, \
-            f"Provided array has dtype {str(self.numpy_array.dtype)}. Expected {str(dtype)}"
+            (f"Provided array has dtype {str(self.numpy_array.dtype)}. "
+             f"Expected {str(dtype)}")
 
         return (self.numpy_array, None)
 

devito/finite_differences/differentiable.py

@@ -353,7 +353,7 @@ def div(self, shift=None, order=None, method='FD', **kwargs):
         shift_x0 = make_shift_x0(shift, (len(space_dims),))
         order = order or self.space_order
         return Add(*[getattr(self, f'd{d.name}')(x0=shift_x0(shift, d, None, i),
-                                                   fd_order=order, method=method, w=w)
+                                                 fd_order=order, method=method, w=w)
                      for i, d in enumerate(space_dims)])
 
     def grad(self, shift=None, order=None, method='FD', **kwargs):
@@ -381,7 +381,7 @@ def grad(self, shift=None, order=None, method='FD', **kwargs):
         order = order or self.space_order
         w = kwargs.get('weights', kwargs.get('w'))
         comps = [getattr(self, f'd{d.name}')(x0=shift_x0(shift, d, None, i),
-                                               fd_order=order, method=method, w=w)
+                                             fd_order=order, method=method, w=w)
                  for i, d in enumerate(space_dims)]
         vec_func = VectorTimeFunction if self.is_TimeDependent else VectorFunction
         return vec_func(name=f'grad_{self.name}', time_order=self.time_order,

devito/ir/support/basic.py

@@ -1051,7 +1051,8 @@ def __repr__(self):
                 continue
             first = f"{tuple.__repr__(r[0])}"
             shifted = "\n".join(f"{pad}{tuple.__repr__(j)}" for j in r[1:])
-            shifted = f"{'\n' if shifted else ''}{shifted}"
+            newline_prefix = '\n' if shifted else ''
+            shifted = f"{newline_prefix}{shifted}"
             reads[i] = first + shifted
         writes = [self.getwrites(i) for i in tracked]
         for i, w in enumerate(list(writes)):
@@ -1060,7 +1061,7 @@ def __repr__(self):
                 continue
             first = f"{tuple.__repr__(w[0])}"
             shifted = "\n".join(f"{pad}{tuple.__repr__(j)}" for j in w[1:])
-            shifted = f"{'\n' if shifted else ''}{shifted}"
+            shifted = f"{chr(10) if shifted else ''}{shifted}"
             writes[i] = f'\033[1;37;31m{first + shifted}\033[0m'
         return "\n".join([out.format(i.name, w, '', r)
                           for i, r, w in zip(tracked, reads, writes)])

devito/operations/interpolators.py

@@ -122,7 +122,8 @@ def operation(self, **kwargs):
                                               implicit_dims=self.implicit_dims)
 
     def __repr__(self):
-        return f"Interpolation({repr(self.expr)} into {repr(self.interpolator.sfunction)})"
+        return (f"Interpolation({repr(self.expr)} into "
+                f"{repr(self.interpolator.sfunction)})")
 
 
 class Injection(UnevaluatedSparseOperation):

devito/parameters.py

@@ -56,7 +56,8 @@ def wrapper(self, key, value):
     def _check_key_deprecation(func):
         def wrapper(self, key, value=None):
             if key in self._deprecated:
-                warning(f"Trying to access deprecated config `{key}`. Using `{self._deprecated[key]}` instead")
+                warning(f"Trying to access deprecated config `{key}`. "
+                        f"Using `{self._deprecated[key]}` instead")
                 key = self._deprecated[key]
             return func(self, key, value)
         return wrapper

devito/types/dense.py

@@ -122,7 +122,8 @@ def wrapper(self):
                     # Aliasing Functions must not allocate data
                     return
 
-                debug(f"Allocating host memory for {self.name}{self.shape_allocated} [{humanbytes(self.nbytes)}]")
+                debug(f"Allocating host memory for {self.name}{self.shape_allocated} "
+                      f"[{humanbytes(self.nbytes)}]")
 
                 # Clear up both SymPy and Devito caches to drop unreachable data
                 CacheManager.clear(force=False)
@@ -869,11 +870,11 @@ def _arg_check(self, args, intervals, **kwargs):
         data = args[self.name]
 
         if len(data.shape) != self.ndim:
-            raise InvalidArgument(f"Shape {data.shape} of runtime value `{self.name}` does not match "
-                                  f"dimensions {self.dimensions}")
+            raise InvalidArgument(f"Shape {data.shape} of runtime value `{self.name}` "
+                                  f"does not match dimensions {self.dimensions}")
         if data.dtype != self.dtype:
-            warning(f"Data type {data.dtype} of runtime value `{self.name}` does not match the "
-                    f"Function data type {self.dtype}")
+            warning(f"Data type {data.dtype} of runtime value `{self.name}` "
+                    f"does not match the Function data type {self.dtype}")
 
         # Check each Dimension for potential OOB accesses
         for i, s in zip(self.dimensions, data.shape):
@@ -883,8 +884,8 @@ def _arg_check(self, args, intervals, **kwargs):
            args.options['linearize'] and \
            self.is_regular and \
            data.size - 1 >= np.iinfo(np.int32).max:
-            raise InvalidArgument(f"`{self.name}`, with its {data.size} elements, is too big for "
-                                  "int32 pointer arithmetic. Consider using the "
+            raise InvalidArgument(f"`{self.name}`, with its {data.size} elements, is too "
+                                  "big for int32 pointer arithmetic. Consider using the "
                                   "'index-mode=int64' option, the save=Buffer(..) "
                                   "API (TimeFunction only), or domain "
                                   "decomposition via MPI")
@@ -1700,7 +1701,8 @@ def make(self, shape=None, initializer=None, allocator=None, **kwargs):
                 shape.append(int(v))
             shape = tuple(shape)
         elif len(shape) != self.ndim:
-            raise ValueError(f"`shape` must contain {self.ndim} integers, not {len(shape)}")
+            raise ValueError(f"`shape` must contain {self.ndim} integers, "
+                             f"not {len(shape)}")
         elif not all(is_integer(i) for i in shape):
             raise ValueError(f"`shape` must contain integers (got `{str(shape)}`)")
 

devito/types/dimension.py

@@ -335,7 +335,8 @@ def _arg_check(self, args, size, interval):
         if self.min_name not in args:
             raise InvalidArgument(f"No runtime value for {self.min_name}")
         if interval.is_Defined and args[self.min_name] + interval.lower < 0:
-            raise InvalidArgument(f"OOB detected due to {self.min_name}={args[self.min_name]}")
+            raise InvalidArgument(f"OOB detected due to "
+                                  f"{self.min_name}={args[self.min_name]}")
 
         if self.max_name not in args:
             raise InvalidArgument(f"No runtime value for {self.max_name}")
@@ -347,7 +348,8 @@ def _arg_check(self, args, size, interval):
                 from devito.symbolics import normalize_args
                 upper = interval.upper.subs(normalize_args(args))
             if args[self.max_name] + upper >= size:
-                raise InvalidArgument(f"OOB detected due to {self.max_name}={args[self.max_name]}")
+                raise InvalidArgument(f"OOB detected due to "
+                                      f"{self.max_name}={args[self.max_name]}")
 
         # Allow the specific case of max=min-1, which disables the loop
         if args[self.max_name] < args[self.min_name]-1: