Merge pull request #2706 from devitocodes/modernize-string-formatting

misc: switch to f-string throughout

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', '"%s"' % i.replace(',', r'\,')
+                        '-Xcompiler', f'"{escaped_i}"'
                     ])
                 else:
                     proc_link_flags.append(i)

devito/data/allocators.py

@@ -103,7 +103,7 @@ def alloc(self, shape, dtype, padding=0):
 
         padleft_pointer, memfree_args = self._alloc_C_libcall(size, ctype)
         if padleft_pointer is None:
-            raise RuntimeError("Unable to allocate %d elements in memory" % size)
+            raise RuntimeError(f"Unable to allocate {size} elements in memory")
 
         # Compute the pointer to the user data
         padleft_bytes = padleft * ctypes.sizeof(ctype)
@@ -375,11 +375,11 @@ def __init__(self, numpy_array):
 
     def alloc(self, shape, dtype, padding=0):
         assert shape == self.numpy_array.shape, \
-            "Provided array has shape %s. Expected %s" %\
-            (str(self.numpy_array.shape), str(shape))
+            (f"Provided array has shape {str(self.numpy_array.shape)}. "
+             f"Expected {str(shape)}")
         assert dtype == self.numpy_array.dtype, \
-            "Provided array has dtype %s. Expected %s" %\
-            (str(self.numpy_array.dtype), str(dtype))
+            (f"Provided array has dtype {str(self.numpy_array.dtype)}. "
+             f"Expected {str(dtype)}")
 
         return (self.numpy_array, None)
 
@@ -405,11 +405,11 @@ def register_allocator(name, allocator):
     Register a custom MemoryAllocator.
     """
     if not isinstance(name, str):
-        raise TypeError("name must be a str, not `%s`" % type(name))
+        raise TypeError(f"name must be a str, not `{type(name)}`)")
     if name in custom_allocators:
-        raise ValueError("A MemoryAllocator for `%s` already exists" % name)
+        raise ValueError(f"A MemoryAllocator for `{name}` already exists")
     if not isinstance(allocator, AbstractMemoryAllocator):
-        raise TypeError("Expected a MemoryAllocator, not `%s`" % type(allocator))
+        raise TypeError(f"Expected a MemoryAllocator, not `{type(allocator)}`")
 
     custom_allocators[name] = allocator
 

devito/data/data.py

@@ -157,7 +157,7 @@ def _global(self, glb_idx, decomposition):
         if self._is_decomposed:
             raise ValueError("Cannot derive a decomposed view from a decomposed Data")
         if len(decomposition) != self.ndim:
-            raise ValueError("`decomposition` should have ndim=%d entries" % self.ndim)
+            raise ValueError(f"`decomposition` should have ndim={self.ndim} entries")
         ret = self[glb_idx]
         ret._decomposition = decomposition
         ret._is_distributed = any(i is not None for i in decomposition)
@@ -407,7 +407,7 @@ def __setitem__(self, glb_idx, val, comm_type):
                                           "other data ")
             super().__setitem__(glb_idx, val)
         else:
-            raise ValueError("Cannot insert obj of type `%s` into a Data" % type(val))
+            raise ValueError(f"Cannot insert obj of type `{type(val)}` into a Data")
 
     def _normalize_index(self, idx):
         if isinstance(idx, np.ndarray):

devito/finite_differences/differentiable.py

@@ -189,7 +189,7 @@ def __getattr__(self, name):
         """
         if name in self._fd:
             return self._fd[name][0](self)
-        raise AttributeError("%r object has no attribute %r" % (self.__class__, name))
+        raise AttributeError(f"{self.__class__!r} object has no attribute {name!r}")
 
     # Override SymPy arithmetic operators
     @call_highest_priority('__radd__')
@@ -324,7 +324,7 @@ def laplacian(self, shift=None, order=None, method='FD', **kwargs):
         order = order or self.space_order
         space_dims = self.root_dimensions
         shift_x0 = make_shift_x0(shift, (len(space_dims),))
-        derivs = tuple('d%s2' % d.name for d in space_dims)
+        derivs = tuple(f'd{d.name}2' for d in space_dims)
         return Add(*[getattr(self, d)(x0=shift_x0(shift, space_dims[i], None, i),
                                       method=method, fd_order=order, w=w)
                      for i, d in enumerate(derivs)])
@@ -352,8 +352,8 @@ def div(self, shift=None, order=None, method='FD', **kwargs):
         space_dims = self.root_dimensions
         shift_x0 = make_shift_x0(shift, (len(space_dims),))
         order = order or self.space_order
-        return Add(*[getattr(self, 'd%s' % d.name)(x0=shift_x0(shift, d, None, i),
-                                                   fd_order=order, method=method, w=w)
+        return Add(*[getattr(self, f'd{d.name}')(x0=shift_x0(shift, d, None, i),
+                                                 fd_order=order, method=method, w=w)
                      for i, d in enumerate(space_dims)])
 
     def grad(self, shift=None, order=None, method='FD', **kwargs):
@@ -380,11 +380,11 @@ def grad(self, shift=None, order=None, method='FD', **kwargs):
         shift_x0 = make_shift_x0(shift, (len(space_dims),))
         order = order or self.space_order
         w = kwargs.get('weights', kwargs.get('w'))
-        comps = [getattr(self, 'd%s' % d.name)(x0=shift_x0(shift, d, None, i),
-                                               fd_order=order, method=method, w=w)
+        comps = [getattr(self, f'd{d.name}')(x0=shift_x0(shift, d, None, i),
+                                             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='grad_%s' % self.name, time_order=self.time_order,
+        return vec_func(name=f'grad_{self.name}', time_order=self.time_order,
                         space_order=self.space_order, components=comps, grid=self.grid)
 
     def biharmonic(self, weight=1):
@@ -393,7 +393,7 @@ def biharmonic(self, weight=1):
         all spatial Dimensions Laplace(weight * Laplace (self))
         """
         space_dims = self.root_dimensions
-        derivs = tuple('d%s2' % d.name for d in space_dims)
+        derivs = tuple(f'd{d.name}2' for d in space_dims)
         return Add(*[getattr(self.laplace * weight, d) for d in derivs])
 
     def diff(self, *symbols, **assumptions):

devito/ir/support/basic.py

@@ -232,7 +232,7 @@ def __init__(self, access, mode, timestamp, ispace=null_ispace):
 
     def __repr__(self):
         mode = '\033[1;37;31mW\033[0m' if self.is_write else '\033[1;37;32mR\033[0m'
-        return "%s<%s,[%s]>" % (mode, self.name, ', '.join(str(i) for i in self))
+        return f"{mode}<{self.name},[{', '.join(str(i) for i in self)}]>"
 
     def __eq__(self, other):
         if not isinstance(other, TimedAccess):
@@ -295,7 +295,7 @@ def is_regular(self):
 
     def __lt__(self, other):
         if not isinstance(other, TimedAccess):
-            raise TypeError("Cannot compare with object of type %s" % type(other))
+            raise TypeError(f"Cannot compare with object of type {type(other)}")
         if self.directions != other.directions:
             raise TypeError("Cannot compare due to mismatching `direction`")
         if self.intervals != other.intervals:
@@ -529,7 +529,7 @@ def __init__(self, source, sink):
         self.sink = sink
 
     def __repr__(self):
-        return "%s -- %s" % (self.source, self.sink)
+        return f"{self.source} -- {self.sink}"
 
     def __eq__(self, other):
         # If the timestamps are equal in `self` (ie, an inplace dependence) then
@@ -639,7 +639,7 @@ class Dependence(Relation, CacheInstances):
     """
 
     def __repr__(self):
-        return "%s -> %s" % (self.source, self.sink)
+        return f"{self.source} -> {self.sink}"
 
     @cached_property
     def cause(self):
@@ -1042,26 +1042,27 @@ def __repr__(self):
         tracked = filter_sorted(set(self.reads) | set(self.writes),
                                 key=lambda i: i.name)
         maxlen = max(1, max([len(i.name) for i in tracked]))
-        out = "{:>%d} =>  W : {}\n{:>%d}     R : {}" % (maxlen, maxlen)
+        out = f"{{:>{maxlen}}} =>  W : {{}}\n{{:>{maxlen}}}     R : {{}}"
         pad = " "*(maxlen + 9)
         reads = [self.getreads(i) for i in tracked]
         for i, r in enumerate(list(reads)):
             if not r:
                 reads[i] = ''
                 continue
-            first = "%s" % tuple.__repr__(r[0])
-            shifted = "\n".join("%s%s" % (pad, tuple.__repr__(j)) for j in r[1:])
-            shifted = "%s%s" % ("\n" if shifted else "", shifted)
+            first = f"{tuple.__repr__(r[0])}"
+            shifted = "\n".join(f"{pad}{tuple.__repr__(j)}" for j in r[1:])
+            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)):
             if not w:
                 writes[i] = ''
                 continue
-            first = "%s" % tuple.__repr__(w[0])
-            shifted = "\n".join("%s%s" % (pad, tuple.__repr__(j)) for j in w[1:])
-            shifted = "%s%s" % ("\n" if shifted else "", shifted)
-            writes[i] = '\033[1;37;31m%s\033[0m' % (first + shifted)
+            first = f"{tuple.__repr__(w[0])}"
+            shifted = "\n".join(f"{pad}{tuple.__repr__(j)}" for j in w[1:])
+            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)])
 
@@ -1264,7 +1265,7 @@ def __init__(self, expr, indexeds=None, bases=None, offsets=None):
         self.offsets = offsets
 
     def __repr__(self):
-        return "ExprGeometry(expr=%s)" % self.expr
+        return f"ExprGeometry(expr={self.expr})"
 
     def translated(self, other, dims=None):
         """

devito/logger.py

@@ -56,7 +56,7 @@ def _set_log_level(level):
     Set the level of the Devito logger.
     """
     if level not in logger_registry:
-        raise ValueError("Illegal logging level %s" % level)
+        raise ValueError(f"Illegal logging level {level}")
 
     logger.setLevel(level)
 
@@ -150,7 +150,7 @@ def perf(msg, *args, **kwargs):
 
 
 def hint(msg, *args, **kwargs):
-    log("Hint: %s" % msg, PERF, *args, **kwargs)
+    log(f"Hint: {msg}", PERF, *args, **kwargs)
 
 
 def warning(msg, *args, **kwargs):

devito/operations/interpolators.py

@@ -28,7 +28,7 @@ def wrapper(interp, *args, **kwargs):
         funcs = set().union(*[retrieve_functions(a) for a in args])
         so = min({f.space_order for f in funcs if not f.is_SparseFunction} or {r})
         if so < r:
-            raise ValueError("Space order %d too small for interpolation r %d" % (so, r))
+            raise ValueError(f"Space order {so} too small for interpolation r {r}")
         return func(interp, *args, **kwargs)
     return wrapper
 
@@ -122,8 +122,8 @@ def operation(self, **kwargs):
                                               implicit_dims=self.implicit_dims)
 
     def __repr__(self):
-        return "Interpolation(%s into %s)" % (repr(self.expr),
-                                              repr(self.interpolator.sfunction))
+        return (f"Interpolation({repr(self.expr)} into "
+                f"{repr(self.interpolator.sfunction)})")
 
 
 class Injection(UnevaluatedSparseOperation):
@@ -150,7 +150,7 @@ def operation(self, **kwargs):
                                          implicit_dims=self.implicit_dims)
 
     def __repr__(self):
-        return "Injection(%s into %s)" % (repr(self.expr), repr(self.field))
+        return f"Injection({repr(self.expr)} into {repr(self.field)})"
 
 
 class GenericInterpolator(ABC):
@@ -210,7 +210,7 @@ def _gdims(self):
     def _cdim(self):
         """Base CustomDimensions used to construct _rdim"""
         parent = self.sfunction._sparse_dim
-        dims = [CustomDimension("r%s%s" % (self.sfunction.name, d.name),
+        dims = [CustomDimension(f"r{self.sfunction.name}{d.name}",
                                 -self.r+1, self.r, 2*self.r, parent)
                 for d in self._gdims]
         return dims
@@ -552,7 +552,7 @@ def interpolation_coeffs(self):
         shape = (self.sfunction.npoint, 2 * self.r)
         for r in self._cdim:
             dimensions = (self.sfunction._sparse_dim, r)
-            sf = SubFunction(name="wsinc%s" % r.name, dtype=self.sfunction.dtype,
+            sf = SubFunction(name=f"wsinc{r.name}", dtype=self.sfunction.dtype,
                              shape=shape, dimensions=dimensions,
                              space_order=0, alias=self.sfunction.alias,
                              parent=None)

devito/operator/profiling.py

@@ -393,9 +393,9 @@ def instrument(self, iet, timer):
             if i.dim.is_Time:
                 # The calls to Advisor's Collection Control API are only for Operators
                 # with a time loop
-                mapper[i] = List(header=c.Statement('%s()' % self._api_resume),
+                mapper[i] = List(header=c.Statement(f'{self._api_resume}()'),
                                  body=i,
-                                 footer=c.Statement('%s()' % self._api_pause))
+                                 footer=c.Statement(f'{self._api_pause}()'))
                 return Transformer(mapper).visit(iet)
 
         # Return the IET intact if no time loop is found

devito/parameters.py

@@ -48,16 +48,16 @@ def wrapper(self, key, value):
             if accepted is not None:
                 tocheck = list(value) if isinstance(value, dict) else [value]
                 if any(i not in accepted for i in tocheck):
-                    raise ValueError("Illegal configuration parameter (%s, %s). "
-                                     "Accepted: %s" % (key, value, str(accepted)))
+                    raise ValueError(f"Illegal configuration parameter ({key}, {value}). "
+                                     f"Accepted: {str(accepted)}")
             return func(self, key, value)
         return wrapper
 
     def _check_key_deprecation(func):
         def wrapper(self, key, value=None):
             if key in self._deprecated:
-                warning("Trying to access deprecated config `%s`. Using `%s` instead"
-                        % (key, self._deprecated[key]))
+                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
@@ -182,11 +182,11 @@ def init_configuration(configuration=configuration, env_vars_mapper=env_vars_map
         mapper = dict(queue)
         for k, (v, msg) in env_vars_deprecated.items():
             if environ.get(k):
-                warning("`%s` is deprecated. %s" % (k, msg))
+                warning(f"`{k}` is deprecated. {msg}")
                 if environ.get(v):
-                    warning("Both `%s` and `%s` set. Ignoring `%s`" % (k, v, k))
+                    warning(f"Both `{k}` and `{v}` set. Ignoring `{k}`")
                 else:
-                    warning("Setting `%s=%s`" % (v, environ[k]))
+                    warning(f"Setting `{v}={environ[k]}`")
                     unprocessed[mapper[v]] = environ[k]
     else:
         # Attempt reading from the specified configuration file
@@ -264,11 +264,10 @@ def print_defaults():
     """Print the environment variables accepted by Devito, their default value,
     as well as all of the accepted values."""
     for k, v in env_vars_mapper.items():
-        info('%s: %s. Default: %s' % (k, configuration._accepted[v],
-                                      configuration._defaults[v]))
+        info(f'{k}: {configuration._accepted[v]}. Default: {configuration._defaults[v]}')
 
 
 def print_state():
     """Print the current configuration state."""
     for k, v in configuration.items():
-        info('%s: %s' % (k, v))
+        info(f'{k}: {v}')

devito/types/basic.py

@@ -777,7 +777,7 @@ def __init__(self, *args, **kwargs):
         pass
 
     def __str__(self):
-        return "%s(%s)" % (self.name, ', '.join(str(i) for i in self.indices))
+        return f"{self.name}({', '.join(str(i) for i in self.indices)})"
 
     __repr__ = __str__
 
@@ -1107,7 +1107,7 @@ def dmap(self):
         return None.
         """
         if self._mem_mapped:
-            return DeviceMap('d_%s' % self.name, shape=self._shape,
+            return DeviceMap(f'd_{self.name}', shape=self._shape,
                              function=self.function)
         elif self._mem_local:
             return self.indexed
@@ -1175,7 +1175,7 @@ def space(self):
 
     @property
     def _C_name(self):
-        return "%s_vec" % self.name
+        return f"{self.name}_vec"
 
     @cached_property
     def _C_symbol(self):