Replace str.format with f-strings

Author: Armavica

pytensor/compile/builders.py

@@ -434,7 +434,7 @@ def __hash__(self):
     def __str__(self):
         name = self.__class__.__name__ if self.name is None else self.name
         is_inline = self.is_inline
-        return "{name}{{inline={is_inline}}}".format(**locals())
+        return f"{name}{{inline={is_inline}}}"
 
     def _combine_list_overrides(self, default_outs, custom_outs, callable_args):
         """Combines default and custom overrides into a single list of outputs."""

pytensor/compile/function/types.py

@@ -1890,11 +1890,7 @@ def get_plural(n):
                 )
     else:
         if n_unnamed_inputs == 0:
-            msg = "The function has {} named input{} ({}).".format(
-                n_named_inputs,
-                get_plural(n_named_inputs),
-                ", ".join(named_inputs),
-            )
+            msg = f"The function has {n_named_inputs} named input{get_plural(n_named_inputs)} ({', '.join(named_inputs)})."
         else:
             msg = (
                 f"The function has {n_named_inputs} named input{get_plural(n_named_inputs)} ({', '.join(named_inputs)}), and {n_unnamed_inputs} unnamed "

pytensor/graph/rewriting/basic.py

@@ -1664,15 +1664,12 @@ def __str__(self):
 
         def pattern_to_str(pattern):
             if isinstance(pattern, list | tuple):
-                return "{}({})".format(
-                    str(pattern[0]),
-                    ", ".join(pattern_to_str(p) for p in pattern[1:]),
-                )
+                args = ", ".join(pattern_to_str(p) for p in pattern[1:])
+                return f"{pattern[0]!s}({args})"
             elif isinstance(pattern, dict):
-                return "{} subject to {}".format(
-                    pattern_to_str(pattern["pattern"]),
-                    str(pattern.get("constraint", "no conditions")),
-                )
+                a = pattern_to_str(pattern["pattern"])
+                b = pattern.get("constraint", "no conditions")
+                return f"{a} subject to {b}"
             else:
                 return str(pattern)
 

pytensor/graph/utils.py

@@ -245,10 +245,9 @@ def __str__(self):
                 else:
 
                     def __str__(self):
-                        return "{}{{{}}}".format(
-                            self.__class__.__name__,
-                            ", ".join(f"{p}={getattr(self, p)!r}" for p in props),
-                        )
+                        classname = self.__class__.__name__
+                        args = ", ".join(f"{p}={getattr(self, p)!r}" for p in props)
+                        return f"{classname}{{{args}}}"
 
                 dct["__str__"] = __str__
 

pytensor/link/c/basic.py

@@ -219,7 +219,6 @@ def struct_gen(args, struct_builders, blocks, sub):
     """
     struct_decl = ""
     struct_init_head = ""
-    struct_init_tail = ""
     struct_cleanup = ""
 
     for block in struct_builders:
@@ -243,15 +242,15 @@ def struct_gen(args, struct_builders, blocks, sub):
     # decrements the storage's refcount in the destructor
     storage_decref = "\n".join(f"Py_XDECREF(this->{arg});" for arg in args)
 
-    args_names = ", ".join(args)
     args_decl = ", ".join(f"PyObject* {arg}" for arg in args)
 
     # The following code stores the exception data in __ERROR, which
     # is a special field of the struct. __ERROR is a list of length 3
     # that holds the type, the value and the traceback. After storing
     # the error, we return the failure code so we know which code
     # block failed.
-    do_return = """
+    failure_var = sub["failure_var"]
+    do_return = f"""
         if ({failure_var}) {{
             // When there is a failure, this code puts the exception
             // in __ERROR.
@@ -274,15 +273,13 @@ def struct_gen(args, struct_builders, blocks, sub):
         }}
         // The failure code is returned to index what code block failed.
         return {failure_var};
-        """.format(**sub)
-
-    sub = dict(sub)
-    sub.update(locals())
+        """
 
     # TODO: add some error checking to make sure storage_<x> are
     # 1-element lists and __ERROR is a 3-elements list.
 
-    struct_code = """
+    name = sub["name"]
+    struct_code = f"""
     namespace {{
     struct {name} {{
         PyObject* __ERROR;
@@ -326,7 +323,7 @@ def struct_gen(args, struct_builders, blocks, sub):
         }}
     }};
     }}
-    """.format(**sub)
+    """
 
     return struct_code
 
@@ -370,13 +367,10 @@ def get_c_init(fgraph, r, name, sub):
     Wrapper around c_init that initializes py_name to Py_None.
 
     """
-    pre = (
-        ""
-        """
+    pre = f"""
     py_{name} = Py_None;
     {{Py_XINCREF(py_{name});}}
-    """.format(**locals())
-    )
+    """
     return pre + r.type.c_init(name, sub)
 
 
@@ -410,10 +404,10 @@ def get_c_extract(fgraph, r, name, sub):
     else:
         c_extract = r.type.c_extract(name, sub, False)
 
-    pre = """
+    pre = f"""
     py_{name} = PyList_GET_ITEM(storage_{name}, 0);
     {{Py_XINCREF(py_{name});}}
-    """.format(**locals())
+    """
     return pre + c_extract
 
 
@@ -439,10 +433,10 @@ def get_c_extract_out(fgraph, r, name, sub):
     else:
         c_extract = r.type.c_extract_out(name, sub, check_input, check_broadcast=False)
 
-    pre = """
+    pre = f"""
     py_{name} = PyList_GET_ITEM(storage_{name}, 0);
     {{Py_XINCREF(py_{name});}}
-    """.format(**locals())
+    """
     return pre + c_extract
 
 
@@ -451,9 +445,9 @@ def get_c_cleanup(fgraph, r, name, sub):
     Wrapper around c_cleanup that decrefs py_name.
 
     """
-    post = """
+    post = f"""
     {{Py_XDECREF(py_{name});}}
-    """.format(**locals())
+    """
     return r.type.c_cleanup(name, sub) + post
 
 
@@ -462,15 +456,17 @@ def get_c_sync(fgraph, r, name, sub):
     Wrapper around c_sync that syncs py_name with storage.
 
     """
-    return """
+    failure_var = sub["failure_var"]
+    sync = r.type.c_sync(name, sub)
+    return f"""
     if (!{failure_var}) {{
       {sync}
       PyObject* old = PyList_GET_ITEM(storage_{name}, 0);
       {{Py_XINCREF(py_{name});}}
       PyList_SET_ITEM(storage_{name}, 0, py_{name});
       {{Py_XDECREF(old);}}
     }}
-    """.format(**dict(sync=r.type.c_sync(name, sub), name=name, **sub))
+    """
 
 
 def apply_policy(fgraph, policy, r, name, sub):

pytensor/link/c/cmodule.py

@@ -1966,14 +1966,14 @@ def _try_flags(
             return False
 
         code = (
-            """
+            f"""
         {preamble}
         int main(int argc, char** argv)
         {{
             {body}
             return 0;
         }}
-        """.format(**locals())
+        """
         ).encode()
         return cls._try_compile_tmp(
             code,

pytensor/link/c/interface.py

@@ -558,7 +558,9 @@ def c_extract_out(
         uninitialized.
 
         """
-        return """
+        c_init_code = self.c_init(name, sub)
+        c_extract_code = self.c_extract(name, sub, check_input)
+        return f"""
         if (py_{name} == Py_None)
         {{
             {c_init_code}
@@ -567,13 +569,7 @@ def c_extract_out(
         {{
             {c_extract_code}
         }}
-        """.format(
-            **dict(
-                name=name,
-                c_init_code=self.c_init(name, sub),
-                c_extract_code=self.c_extract(name, sub, check_input),
-            )
-        )
+        """
 
     def c_cleanup(self, name: str, sub: dict[str, str]) -> str:
         """Return C code to clean up after :meth:`CLinkerType.c_extract`.

pytensor/link/c/op.py

@@ -587,24 +587,15 @@ def c_code(self, node, name, inp, out, sub):
                 params = f", {sub['params']}"
 
             # Generate the C code
-            return """
+            return f"""
                 {define_macros}
                 {{
-                  if ({func_name}({func_args}{params}) != 0) {{
-                    {fail}
+                  if ({self.func_name}({self.format_c_function_args(inp, out)}{params}) != 0) {{
+                    {sub['fail']}
                   }}
                 }}
                 {undef_macros}
-                """.format(
-                **dict(
-                    func_name=self.func_name,
-                    fail=sub["fail"],
-                    params=params,
-                    func_args=self.format_c_function_args(inp, out),
-                    define_macros=define_macros,
-                    undef_macros=undef_macros,
-                )
-            )
+                """
         else:
             if "code" in self.code_sections:
                 op_code = self.code_sections["code"]

pytensor/link/c/params_type.py

@@ -262,9 +262,10 @@ def __init__(self, params_type, **kwargs):
         self.__dict__.update(__params_type__=params_type, __signatures__=None)
 
     def __repr__(self):
-        return "Params({})".format(
-            ", ".join((f"{k}:{type(self[k]).__name__}:{self[k]}") for k in sorted(self))
+        args = ", ".join(
+            (f"{k}:{type(self[k]).__name__}:{self[k]}") for k in sorted(self)
         )
+        return f"Params({args})"
 
     def __getattr__(self, key):
         if key not in self:
@@ -422,9 +423,10 @@ def __getattr__(self, key):
         return super().__getattr__(self, key)
 
     def __repr__(self):
-        return "ParamsType<{}>".format(
-            ", ".join((f"{self.fields[i]}:{self.types[i]}") for i in range(self.length))
+        args = ", ".join(
+            f"{self.fields[i]}:{self.types[i]}" for i in range(self.length)
         )
+        return f"ParamsType<{args}>"
 
     def __eq__(self, other):
         return (
@@ -730,25 +732,24 @@ def c_support_code(self, **kwargs):
         struct_init = "\n".join(c_init_list)
         struct_cleanup = "\n".join(c_cleanup_list)
         struct_extract = "\n\n".join(c_extract_list)
-        struct_extract_method = """
+        args = "\n".join(
+            f"case {i}: extract_{self.fields[i]}(object); break;"
+            for i in range(self.length)
+        )
+        struct_extract_method = f"""
         void extract(PyObject* object, int field_pos) {{
             switch(field_pos) {{
                 // Extraction cases.
-                {}
+                {args}
                 // Default case.
                 default:
                     PyErr_Format(PyExc_TypeError, "ParamsType: no extraction defined for a field %d.", field_pos);
                     this->setErrorOccurred();
                     break;
             }}
         }}
-        """.format(
-            "\n".join(
-                ("case %d: extract_%s(object); break;" % (i, self.fields[i]))
-                for i in range(self.length)
-            )
-        )
-        final_struct_code = """
+        """
+        final_struct_code = f"""
         /** ParamsType {struct_name} **/
         #ifndef {struct_name_defined}
         #define {struct_name_defined}
@@ -790,17 +791,7 @@ def c_support_code(self, **kwargs):
         }};
         #endif
         /** End ParamsType {struct_name} **/
-        """.format(
-            **dict(
-                struct_name_defined=struct_name_defined,
-                struct_name=struct_name,
-                struct_declare=struct_declare,
-                struct_init=struct_init,
-                struct_cleanup=struct_cleanup,
-                struct_extract=struct_extract,
-                struct_extract_method=struct_extract_method,
-            )
-        )
+        """
 
         return [*sorted(c_support_code_set), final_struct_code]
 
@@ -813,9 +804,9 @@ def c_code_cache_version(self):
     # pointers.
 
     def c_declare(self, name, sub, check_input=True):
-        return """
-        {struct_name}* {name};
-        """.format(**dict(struct_name=self.name, name=name))
+        return f"""
+        {self.name}* {name};
+        """
 
     def c_init(self, name, sub):
         # NB: It seems c_init() is not called for an op param.
@@ -831,40 +822,33 @@ def c_cleanup(self, name, sub):
         """
 
     def c_extract(self, name, sub, check_input=True, **kwargs):
-        return """
+        fields_list = ", ".join(f'"{x}"' for x in self.fields)
+        return f"""
         /* Seems c_init() is not called for a op param. So I call `new` here. */
-        {name} = new {struct_name};
+        {name} = new {self.name};
 
         {{ // This need a separate namespace for Clinker
         const char* fields[] = {{{fields_list}}};
         if (py_{name} == Py_None) {{
             PyErr_SetString(PyExc_ValueError, "ParamsType: expected an object, not None.");
-            {fail}
+            {sub['fail']}
         }}
-        for (int i = 0; i < {length}; ++i) {{
+        for (int i = 0; i < {self.length}; ++i) {{
             PyObject* o = PyDict_GetItemString(py_{name}, fields[i]);
             if (o == NULL) {{
                 PyErr_Format(PyExc_TypeError, "ParamsType: missing expected attribute \\"%s\\" in object.", fields[i]);
-                {fail}
+                {sub['fail']}
             }}
             {name}->extract(o, i);
             if ({name}->errorOccurred()) {{
                 /* The extract code from attribute type should have already raised a Python exception,
                  * so we just print the attribute name in stderr. */
                 fprintf(stderr, "\\nParamsType: error when extracting value for attribute \\"%s\\".\\n", fields[i]);
-                {fail}
+                {sub['fail']}
             }}
         }}
         }}
-        """.format(
-            **dict(
-                name=name,
-                struct_name=self.name,
-                length=self.length,
-                fail=sub["fail"],
-                fields_list='"{}"'.format('", "'.join(self.fields)),
-            )
-        )
+        """
 
     def c_sync(self, name, sub):
         # FIXME: Looks like we need to decrement a reference count our two.