Replace % formatting with f-strings

Author: Armavica

doc/generate_dtype_tensor_table.py

@@ -31,7 +31,7 @@
         if len(shape[1]) < 6 or len(set(shape[1])) > 1:
             broadcastable_str = str(shape[1])
         else:
-            broadcastable_str = '(%s,) * %d' % (str(shape[1][0]), len(shape[1]))
+            broadcastable_str = f'({shape[1][0]},) * {len(shape[1])}'
         print('%s%-10s  %-10s  %-4s %-15s  %-20s' %(
                 letter[0], shape[0], letter[1], len(shape[1]), s, broadcastable_str
                 ))

pytensor/compile/monitormode.py

@@ -110,6 +110,6 @@ def detect_nan(fgraph, i, node, fn):
         ):
             print("*** NaN detected ***")
             debugprint(node)
-            print("Inputs : %s" % [input[0] for input in fn.inputs])
-            print("Outputs: %s" % [output[0] for output in fn.outputs])
+            print(f"Inputs : {[input[0] for input in fn.inputs]}")
+            print(f"Outputs: {[output[0] for output in fn.outputs]}")
             break

pytensor/compile/profiling.py

@@ -753,14 +753,11 @@ def summary_nodes(self, file=sys.stderr, N=None):
                 )
             # Same as before, this I've sacrificed some information making
             # the output more readable
+        percent = sum(f for f, t, a, nd_id, nb_call in atimes[N:])
+        duration = sum(t for f, t, a, nd_id, nb_call in atimes[N:])
         print(
-            "   ... (remaining %i Apply instances account for "
-            "%.2f%%(%.2fs) of the runtime)"
-            % (
-                max(0, len(atimes) - N),
-                sum(f for f, t, a, nd_id, nb_call in atimes[N:]),
-                sum(t for f, t, a, nd_id, nb_call in atimes[N:]),
-            ),
+            f"   ... (remaining {max(0, len(atimes) - N)} Apply instances account for "
+            f"{percent:.2f}%%({duration:.2f}s) of the runtime)",
             file=file,
         )
         print("", file=file)

pytensor/link/c/basic.py

@@ -87,9 +87,8 @@ def __init__(self, declare, behavior, cleanup, sub):
         # for that...)
         # we need the label even if cleanup is empty because the
         # behavior block jumps there on failure
-        self.cleanup = (
-            "__label_%(id)i:\n" % sub + cleanup + "\ndouble __DUMMY_%(id)i;\n" % sub
-        )  # % sub
+        id = sub["id"]
+        self.cleanup = f"__label_{id}:\n{cleanup}\ndouble __DUMMY_{id};\n"
 
 
 def failure_code(sub, use_goto=True):
@@ -114,14 +113,16 @@ def failure_code(sub, use_goto=True):
         goto_statement = "goto __label_%(id)i;" % sub
     else:
         goto_statement = ""
-    return """{
-        %(failure_var)s = %(id)i;
-        if (!PyErr_Occurred()) {
+    id = sub["id"]
+    failure_var = sub["failure_var"]
+    return f"""{{
+        {failure_var} = {id};
+        if (!PyErr_Occurred()) {{
             PyErr_SetString(PyExc_RuntimeError,
                 "Unexpected error in an Op's C code. "
                 "No Python exception was set.");
-        }
-        %(goto_statement)s}""" % dict(sub, goto_statement=goto_statement)
+        }}
+        {goto_statement}}}"""
 
 
 def failure_code_init(sub):
@@ -135,17 +136,15 @@ def failure_code_init(sub):
       * failure_var -> must contain a variable name to use for
       the failure code.
     """
-    return (
-        """{
-        if (!PyErr_Occurred()) {
+    id = sub["id"]
+    return f"""{{
+        if (!PyErr_Occurred()) {{
             PyErr_SetString(PyExc_RuntimeError,
                 "Unexpected error in an Op's C code. "
                 "No Python exception was set.");
-            }
-        return %(id)d;
-}"""
-        % sub
-    )
+            }}
+        return {id};
+}}"""
 
 
 def code_gen(blocks):
@@ -1657,10 +1656,9 @@ def instantiate_code(self, n_args):
             file=code,
         )
         print("  assert(PyTuple_Check(argtuple));", file=code)
-        print("  if (%(n_args)i != PyTuple_Size(argtuple)){ " % locals(), file=code)
+        print(f"  if ({n_args} != PyTuple_Size(argtuple)){{ ", file=code)
         print(
-            '     PyErr_Format(PyExc_TypeError, "Wrong number of arguments, expected %(n_args)i, got %%i", (int)PyTuple_Size(argtuple));'
-            % locals(),
+            f'     PyErr_Format(PyExc_TypeError, "Wrong number of arguments, expected {n_args}, got %%i", (int)PyTuple_Size(argtuple));',
             file=code,
         )
         print("     return NULL;", file=code)

pytensor/link/c/op.py

@@ -513,8 +513,6 @@ def get_c_macros(
         self, node: Apply, name: str, check_input: bool | None = None
     ) -> tuple[str, str]:
         "Construct a pair of C ``#define`` and ``#undef`` code strings."
-        define_template = "#define %s %s"
-        undef_template = "#undef %s"
         define_macros = []
         undef_macros = []
 
@@ -535,28 +533,23 @@ def get_c_macros(
 
                 vname = variable_names[i]
 
-                macro_items = (f"DTYPE_{vname}", f"npy_{v.type.dtype}")
-                define_macros.append(define_template % macro_items)
-                undef_macros.append(undef_template % macro_items[0])
+                define_macros.append(f"#define DTYPE_{vname} npy_{v.type.dtype}")
+                undef_macros.append(f"#undef DTYPE_{vname}")
 
                 d = np.dtype(v.type.dtype)
 
-                macro_items_2 = (f"TYPENUM_{vname}", d.num)
-                define_macros.append(define_template % macro_items_2)
-                undef_macros.append(undef_template % macro_items_2[0])
+                define_macros.append(f"#define TYPENUM_{vname} {d.num}")
+                undef_macros.append(f"#undef TYPENUM_{vname}")
 
-                macro_items_3 = (f"ITEMSIZE_{vname}", d.itemsize)
-                define_macros.append(define_template % macro_items_3)
-                undef_macros.append(undef_template % macro_items_3[0])
+                define_macros.append(f"#define ITEMSIZE_{vname} {d.itemsize}")
+                undef_macros.append(f"#undef ITEMSIZE_{vname}")
 
         # Generate a macro to mark code as being apply-specific
-        define_macros.append(define_template % ("APPLY_SPECIFIC(str)", f"str##_{name}"))
-        undef_macros.append(undef_template % "APPLY_SPECIFIC")
+        define_macros.append(f"#define APPLY_SPECIFIC(str) str##_{name}")
+        undef_macros.append("#undef APPLY_SPECIFIC")
 
-        define_macros.extend(
-            define_template % (n, v) for n, v in self.__get_op_params()
-        )
-        undef_macros.extend(undef_template % (n,) for n, _ in self.__get_op_params())
+        define_macros.extend(f"#define {n} {v}" for n, v in self.__get_op_params())
+        undef_macros.extend(f"#undef {n}" for n, _ in self.__get_op_params())
 
         return "\n".join(define_macros), "\n".join(undef_macros)
 

pytensor/link/c/type.py

@@ -208,29 +208,29 @@ def c_sync(self, name, sub):
         freefunc = self.freefunc
         if freefunc is None:
             freefunc = "NULL"
-        s = """
-Py_XDECREF(py_%(name)s);
-if (%(name)s == NULL) {
-  py_%(name)s = Py_None;
-  Py_INCREF(py_%(name)s);
-} else {
-  py_%(name)s = PyCapsule_New((void *)%(name)s, NULL,
+        s = f"""
+Py_XDECREF(py_{name});
+if ({name} == NULL) {{
+  py_{name} = Py_None;
+  Py_INCREF(py_{name});
+}} else {{
+  py_{name} = PyCapsule_New((void *){name}, NULL,
                               _capsule_destructor);
-  if (py_%(name)s != NULL) {
-    if (PyCapsule_SetContext(py_%(name)s, (void *)%(freefunc)s) != 0) {
+  if (py_{name} != NULL) {{
+    if (PyCapsule_SetContext(py_{name}, (void *){freefunc}) != 0) {{
       /* This won't trigger a call to freefunc since it could not be
          set. The error case below will do it. */
-      Py_DECREF(py_%(name)s);
+      Py_DECREF(py_{name});
       /* Signal the error */
-      py_%(name)s = NULL;
-    }
-  }
-}"""
+      py_{name} = NULL;
+    }}
+  }}
+}}"""
         if self.freefunc is not None:
-            s += """
-if (py_%(name)s == NULL) { %(freefunc)s(%(name)s); }
+            s += f"""
+if (py_{name} == NULL) {{ {freefunc}({name}); }}
 """
-        return s % dict(name=name, freefunc=freefunc)
+        return s
 
     def c_cleanup(self, name, sub):
         # No need to do anything here since the CObject/Capsule will

pytensor/misc/check_duplicate_key.py

@@ -36,7 +36,7 @@
 if DISPLAY_DUPLICATE_KEYS:
     for k, v in keys.items():
         if v > 1:
-            print("Duplicate key (%i copies): %s" % (v, pickle.loads(k)))
+            print(f"Duplicate key ({v} copies): {pickle.loads(k)}")
 
 # nb seen -> how many keys
 nbs_keys = Counter(val for val in keys.values())

pytensor/printing.py

@@ -1120,7 +1120,7 @@ def process_graph(self, inputs, outputs, updates=None, display_inputs=False):
                     i += 1
                 if output.name is not None or output in outputs:
                     if output.name is None:
-                        name = "out[%i]" % outputs.index(output)
+                        name = f"out[{outputs.index(output)}]"
                     else:
                         name = output.name
                     # backport

pytensor/tensor/blas.py

@@ -1827,7 +1827,7 @@ def contiguous(var, ndim):
         ]
 
         z_shape_correct = " && ".join(
-            "PyArray_DIMS(%s)[%i] == %s" % (_z, i, dim) for i, dim in enumerate(z_dims)
+            f"PyArray_DIMS({_z})[{i}] == {dim}" for i, dim in enumerate(z_dims)
         )
         z_shape = ", ".join(z_dims)
         z_contiguous = contiguous(_z, z_ndim)

pytensor/tensor/math.py

@@ -223,32 +223,31 @@ def c_code(self, node, name, inp, out, sub):
                 {fail}
             }}
             """
-        ret = """
+        return f"""
         int axis;
 
-        Py_CLEAR(%(argmax)s);//todo pass them as out parameter.
-        %(axis_code)s
-
-        %(argmax)s = (PyArrayObject*)PyArray_ArgMax(%(x)s, axis, NULL);
-        if(%(argmax)s == NULL){
-            %(fail)s;
-        }
-        if(!PyArray_CheckExact(%(argmax)s)){
-            %(argmax)s = (PyArrayObject*)PyArray_FromAny((PyObject*)%(argmax)s, NULL, 0, 0, NPY_ARRAY_ENSUREARRAY, NULL);
-            if(%(argmax)s == NULL){
-                %(fail)s;
-            }
-        }
-        if(PyArray_TYPE(%(argmax)s) != NPY_INT64){
-            PyObject * tmp = PyArray_Cast(%(argmax)s, NPY_INT64);
-            if (NULL == tmp){
-                %(fail)s;
-            }
-            Py_DECREF(%(argmax)s);
-            %(argmax)s = (PyArrayObject*)tmp;
-        }
+        Py_CLEAR({argmax});//todo pass them as out parameter.
+        {axis_code}
+
+        {argmax} = (PyArrayObject*)PyArray_ArgMax({x}, axis, NULL);
+        if({argmax} == NULL){{
+            {fail};
+        }}
+        if(!PyArray_CheckExact({argmax})){{
+            {argmax} = (PyArrayObject*)PyArray_FromAny((PyObject*){argmax}, NULL, 0, 0, NPY_ARRAY_ENSUREARRAY, NULL);
+            if({argmax} == NULL){{
+                {fail};
+            }}
+        }}
+        if(PyArray_TYPE({argmax}) != NPY_INT64){{
+            PyObject * tmp = PyArray_Cast({argmax}, NPY_INT64);
+            if (NULL == tmp){{
+                {fail};
+            }}
+            Py_DECREF({argmax});
+            {argmax} = (PyArrayObject*)tmp;
+        }}
         """
-        return ret % locals()
 
     def c_code_cache_version(self):
         return (2,)
@@ -2602,10 +2601,7 @@ def impl(self, x, y):
     def c_code(self, node, name, inp, out, sub):
         x, y = inp
         (z,) = out
-        return (
-            "%(z)s = ((%(x)s == 0) ? (%(y)s) : "
-            + "((%(y)s == 0) ? (%(x)s) : ((%(y)s)*(%(x)s))) );"
-        ) % locals()
+        return f"{z} = (({x} == 0) ? ({y}) : (({y} == 0) ? ({x}) : (({y})*({x}))) );"
 
     def c_code_cache_version(self):
         return (1,)