Replace format calls with f-strings

Author: snejus

beets/__init__.py

@@ -35,7 +35,7 @@ def read(self, user=True, defaults=True):
         except confuse.NotFoundError:
             pass
         except confuse.ConfigReadError as err:
-            stderr.write("configuration `import` failed: {}".format(err.reason))
+            stderr.write(f"configuration `import` failed: {err.reason}")
 
 
 config = IncludeLazyConfig("beets", __name__)

beets/autotag/distance.py

@@ -79,9 +79,9 @@ def string_dist(str1: str | None, str2: str | None) -> float:
     # "something, the".
     for word in SD_END_WORDS:
         if str1.endswith(", %s" % word):
-            str1 = "{} {}".format(word, str1[: -len(word) - 2])
+            str1 = f"{word} {str1[: -len(word) - 2]}"
         if str2.endswith(", %s" % word):
-            str2 = "{} {}".format(word, str2[: -len(word) - 2])
+            str2 = f"{word} {str2[: -len(word) - 2]}"
 
     # Perform a couple of basic normalizing substitutions.
     for pat, repl in SD_REPLACE:
@@ -230,7 +230,7 @@ def update(self, dist: Distance):
         """Adds all the distance penalties from `dist`."""
         if not isinstance(dist, Distance):
             raise ValueError(
-                "`dist` must be a Distance object, not {}".format(type(dist))
+                f"`dist` must be a Distance object, not {type(dist)}"
             )
         for key, penalties in dist._penalties.items():
             self._penalties.setdefault(key, []).extend(penalties)

beets/dbcore/db.py

@@ -411,9 +411,9 @@ def _check_db(self, need_id: bool = True) -> D:
         exception is raised otherwise.
         """
         if not self._db:
-            raise ValueError("{} has no database".format(type(self).__name__))
+            raise ValueError(f"{type(self).__name__} has no database")
         if need_id and not self.id:
-            raise ValueError("{} has no id".format(type(self).__name__))
+            raise ValueError(f"{type(self).__name__} has no id")
 
         return self._db
 
@@ -608,9 +608,9 @@ def store(self, fields: Iterable[str] | None = None):
                 if key in self._dirty:
                     self._dirty.remove(key)
                     tx.mutate(
-                        "INSERT INTO {} "
+                        f"INSERT INTO {self._flex_table} "
                         "(entity_id, key, value) "
-                        "VALUES (?, ?, ?);".format(self._flex_table),
+                        "VALUES (?, ?, ?);",
                         (self.id, key, value),
                     )
 
@@ -1184,8 +1184,8 @@ def _make_table(self, table: str, fields: Mapping[str, types.Type]):
             for name, typ in fields.items():
                 if name in current_fields:
                     continue
-                setup_sql += "ALTER TABLE {} ADD COLUMN {} {};\n".format(
-                    table, name, typ.sql
+                setup_sql += (
+                    f"ALTER TABLE {table} ADD COLUMN {name} {typ.sql};\n"
                 )
 
         with self.transaction() as tx:
@@ -1197,16 +1197,16 @@ def _make_attribute_table(self, flex_table: str):
         """
         with self.transaction() as tx:
             tx.script(
-                """
-                CREATE TABLE IF NOT EXISTS {0} (
+                f"""
+                CREATE TABLE IF NOT EXISTS {flex_table} (
                     id INTEGER PRIMARY KEY,
                     entity_id INTEGER,
                     key TEXT,
                     value TEXT,
                     UNIQUE(entity_id, key) ON CONFLICT REPLACE);
-                CREATE INDEX IF NOT EXISTS {0}_by_entity
-                    ON {0} (entity_id);
-                """.format(flex_table)
+                CREATE INDEX IF NOT EXISTS {flex_table}_by_entity
+                    ON {flex_table} (entity_id);
+                """
             )
 
     # Querying.

beets/dbcore/query.py

@@ -475,7 +475,7 @@ def col_clause(self) -> tuple[str, Sequence[SQLiteType]]:
         else:
             if self.rangemin is not None and self.rangemax is not None:
                 return (
-                    "{0} >= ? AND {0} <= ?".format(self.field),
+                    f"{self.field} >= ? AND {self.field} <= ?",
                     (self.rangemin, self.rangemax),
                 )
             elif self.rangemin is not None:
@@ -800,9 +800,7 @@ class DateInterval:
 
     def __init__(self, start: datetime | None, end: datetime | None):
         if start is not None and end is not None and not start < end:
-            raise ValueError(
-                "start date {} is not before end date {}".format(start, end)
-            )
+            raise ValueError(f"start date {start} is not before end date {end}")
         self.start = start
         self.end = end
 
@@ -1074,9 +1072,9 @@ def order_clause(self) -> str:
         if self.case_insensitive:
             field = (
                 "(CASE "
-                "WHEN TYPEOF({0})='text' THEN LOWER({0}) "
-                "WHEN TYPEOF({0})='blob' THEN LOWER({0}) "
-                "ELSE {0} END)".format(self.field)
+                f"WHEN TYPEOF({self.field})='text' THEN LOWER({self.field}) "
+                f"WHEN TYPEOF({self.field})='blob' THEN LOWER({self.field}) "
+                f"ELSE {self.field} END)"
             )
         else:
             field = self.field

beets/dbcore/types.py

@@ -219,7 +219,7 @@ def __init__(self, unit: int, suffix: str = ""):
         self.suffix = suffix
 
     def format(self, value: int) -> str:
-        return "{}{}".format((value or 0) // self.unit, self.suffix)
+        return f"{(value or 0) // self.unit}{self.suffix}"
 
 
 class Id(NullInteger):

beets/importer/stages.py

@@ -341,9 +341,7 @@ def _resolve_duplicates(session: ImportSession, task: ImportTask):
     if task.choice_flag in (Action.ASIS, Action.APPLY, Action.RETAG):
         found_duplicates = task.find_duplicates(session.lib)
         if found_duplicates:
-            log.debug(
-                "found duplicates: {}".format([o.id for o in found_duplicates])
-            )
+            log.debug(f"found duplicates: {[o.id for o in found_duplicates]}")
 
             # Get the default action to follow from config.
             duplicate_action = config["import"]["duplicate_action"].as_choice(

beets/library/models.py

@@ -846,10 +846,7 @@ def __repr__(self):
         # can even deadlock due to the database lock.
         return "{}({})".format(
             type(self).__name__,
-            ", ".join(
-                "{}={!r}".format(k, self[k])
-                for k in self.keys(with_album=False)
-            ),
+            ", ".join(f"{k}={self[k]!r}" for k in self.keys(with_album=False)),
         )
 
     def keys(self, computed=False, with_album=True):

beets/plugins.py

@@ -370,9 +370,9 @@ def types(model_cls: type[AnyModel]) -> dict[str, Type]:
         for field in plugin_types:
             if field in types and plugin_types[field] != types[field]:
                 raise PluginConflictError(
-                    "Plugin {} defines flexible field {} "
+                    f"Plugin {plugin.name} defines flexible field {field} "
                     "which has already been defined with "
-                    "another type.".format(plugin.name, field)
+                    "another type."
                 )
         types.update(plugin_types)
     return types

beets/ui/__init__.py

@@ -713,7 +713,7 @@ def get_replacements():
             replacements.append((re.compile(pattern), repl))
         except re.error:
             raise UserError(
-                "malformed regular expression in replace: {}".format(pattern)
+                f"malformed regular expression in replace: {pattern}"
             )
     return replacements
 
@@ -1191,7 +1191,7 @@ def show_path_changes(path_changes):
         # Print every change over two lines
         for source, dest in zip(sources, destinations):
             color_source, color_dest = colordiff(source, dest)
-            print_("{0} \n  -> {1}".format(color_source, color_dest))
+            print_(f"{color_source} \n  -> {color_dest}")
     else:
         # Print every change on a single line, and add a header
         title_pad = max_width - len("Source ") + len(" -> ")
@@ -1232,9 +1232,7 @@ def _store_dict(option, opt_str, value, parser):
             raise ValueError
     except ValueError:
         raise UserError(
-            "supplied argument `{}' is not of the form `key=value'".format(
-                value
-            )
+            f"supplied argument `{value}' is not of the form `key=value'"
         )
 
     option_values[key] = value
@@ -1413,8 +1411,8 @@ def root_parser(self):
     @root_parser.setter
     def root_parser(self, root_parser):
         self._root_parser = root_parser
-        self.parser.prog = "{} {}".format(
-            as_string(root_parser.get_prog_name()), self.name
+        self.parser.prog = (
+            f"{as_string(root_parser.get_prog_name())} {self.name}"
         )
 
 
@@ -1667,10 +1665,8 @@ def _ensure_db_directory_exists(path):
     newpath = os.path.dirname(path)
     if not os.path.isdir(newpath):
         if input_yn(
-            "The database directory {} does not \
-                       exist. Create it (Y/n)?".format(
-                util.displayable_path(newpath)
-            )
+            f"The database directory {util.displayable_path(newpath)} does not \
+                       exist. Create it (Y/n)?"
         ):
             os.makedirs(newpath)
 
@@ -1690,9 +1686,7 @@ def _open_library(config):
     except (sqlite3.OperationalError, sqlite3.DatabaseError) as db_error:
         log.debug("{}", traceback.format_exc())
         raise UserError(
-            "database file {} cannot not be opened: {}".format(
-                util.displayable_path(dbpath), db_error
-            )
+            f"database file {util.displayable_path(dbpath)} cannot not be opened: {db_error}"
         )
     log.debug(
         "library database: {0}\nlibrary directory: {1}",