Replace remaining format calls

Author: snejus

beets/dbcore/db.py

@@ -392,9 +392,9 @@ def _awaken(
         return obj
 
     def __repr__(self) -> str:
-        return "{}({})".format(
-            type(self).__name__,
-            ", ".join(f"{k}={v!r}" for k, v in dict(self).items()),
+        return (
+            f"{type(self).__name__}"
+            f"({', '.join(f'{k}={v!r}' for k, v in dict(self).items())})"
         )
 
     def clear_dirty(self):
@@ -597,9 +597,7 @@ def store(self, fields: Iterable[str] | None = None):
         with db.transaction() as tx:
             # Main table update.
             if assignments:
-                query = "UPDATE {} SET {} WHERE id=?".format(
-                    self._table, ",".join(assignments)
-                )
+                query = f"UPDATE {self._table} SET {','.join(assignments)} WHERE id=?"
                 subvars.append(self.id)
                 tx.mutate(query, subvars)
 
@@ -1174,9 +1172,7 @@ def _make_table(self, table: str, fields: Mapping[str, types.Type]):
             columns = []
             for name, typ in fields.items():
                 columns.append(f"{name} {typ.sql}")
-            setup_sql = "CREATE TABLE {} ({});\n".format(
-                table, ", ".join(columns)
-            )
+            setup_sql = f"CREATE TABLE {table} ({', '.join(columns)});\n"
 
         else:
             # Table exists does not match the field set.
@@ -1196,8 +1192,7 @@ def _make_attribute_table(self, flex_table: str):
         for the given entity (if they don't exist).
         """
         with self.transaction() as tx:
-            tx.script(
-                f"""
+            tx.script(f"""
                 CREATE TABLE IF NOT EXISTS {flex_table} (
                     id INTEGER PRIMARY KEY,
                     entity_id INTEGER,
@@ -1206,8 +1201,7 @@ def _make_attribute_table(self, flex_table: str):
                     UNIQUE(entity_id, key) ON CONFLICT REPLACE);
                 CREATE INDEX IF NOT EXISTS {flex_table}_by_entity
                     ON {flex_table} (entity_id);
-                """
-            )
+                """)
 
     # Querying.
 

beets/library/models.py

@@ -844,9 +844,9 @@ def __repr__(self):
         # This must not use `with_album=True`, because that might access
         # the database. When debugging, that is not guaranteed to succeed, and
         # can even deadlock due to the database lock.
-        return "{}({})".format(
-            type(self).__name__,
-            ", ".join(f"{k}={self[k]!r}" for k in self.keys(with_album=False)),
+        return (
+            f"{type(self).__name__}"
+            f"({', '.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

@@ -517,8 +517,8 @@ def feat_tokens(for_artist: bool = True) -> str:
     feat_words = ["ft", "featuring", "feat", "feat.", "ft."]
     if for_artist:
         feat_words += ["with", "vs", "and", "con", "&"]
-    return r"(?<=[\s(\[])(?:{})(?=\s)".format(
-        "|".join(re.escape(x) for x in feat_words)
+    return (
+        rf"(?<=[\s(\[])(?:{'|'.join(re.escape(x) for x in feat_words)})(?=\s)"
     )
 
 

beets/ui/__init__.py

@@ -1150,7 +1150,7 @@ def show_model_changes(new, old=None, fields=None, always=False):
             continue
 
         changes.append(
-            "  {}: {}".format(field, colorize("text_highlight", new_fmt[field]))
+            f"  {field}: {colorize('text_highlight', new_fmt[field])}"
         )
 
     # Print changes.
@@ -1196,17 +1196,11 @@ def show_path_changes(path_changes):
         # Print every change on a single line, and add a header
         title_pad = max_width - len("Source ") + len(" -> ")
 
-        print_("Source {0} Destination".format(" " * title_pad))
+        print_(f"Source {' ' * title_pad} Destination")
         for source, dest in zip(sources, destinations):
             pad = max_width - len(source)
             color_source, color_dest = colordiff(source, dest)
-            print_(
-                "{0} {1} -> {2}".format(
-                    color_source,
-                    " " * pad,
-                    color_dest,
-                )
-            )
+            print_(f"{color_source} {' ' * pad} -> {color_dest}")
 
 
 # Helper functions for option parsing.
@@ -1665,8 +1659,8 @@ def _ensure_db_directory_exists(path):
     newpath = os.path.dirname(path)
     if not os.path.isdir(newpath):
         if input_yn(
-            f"The database directory {util.displayable_path(newpath)} does not \
-                       exist. Create it (Y/n)?"
+            f"The database directory {util.displayable_path(newpath)} does not"
+            " exist. Create it (Y/n)?"
         ):
             os.makedirs(newpath)
 
@@ -1686,7 +1680,8 @@ def _open_library(config):
     except (sqlite3.OperationalError, sqlite3.DatabaseError) as db_error:
         log.debug("{}", traceback.format_exc())
         raise UserError(
-            f"database file {util.displayable_path(dbpath)} cannot not be opened: {db_error}"
+            f"database file {util.displayable_path(dbpath)} cannot not be"
+            f" opened: {db_error}"
         )
     log.debug(
         "library database: {0}\nlibrary directory: {1}",

beets/ui/commands.py

@@ -112,11 +112,13 @@ def _parse_logfiles(logfiles):
             yield from _paths_from_logfile(syspath(normpath(logfile)))
         except ValueError as err:
             raise ui.UserError(
-                f"malformed logfile {util.displayable_path(logfile)}: {str(err)}"
+                f"malformed logfile {util.displayable_path(logfile)}:"
+                f" {str(err)}"
             ) from err
         except OSError as err:
             raise ui.UserError(
-                f"unreadable logfile {util.displayable_path(logfile)}: {str(err)}"
+                f"unreadable logfile {util.displayable_path(logfile)}:"
+                f" {str(err)}"
             ) from err
 
 
@@ -291,7 +293,7 @@ def penalty_string(distance, limit=None):
         if limit and len(penalties) > limit:
             penalties = penalties[:limit] + ["..."]
         # Prefix penalty string with U+2260: Not Equal To
-        penalty_string = "\u2260 {}".format(", ".join(penalties))
+        penalty_string = f"\u2260 {', '.join(penalties)}"
         return ui.colorize("changed", penalty_string)
 
 
@@ -693,7 +695,9 @@ def show_match_tracks(self):
         # Missing and unmatched tracks.
         if self.match.extra_tracks:
             print_(
-                f"Missing tracks ({len(self.match.extra_tracks)}/{len(self.match.info.tracks)} - {len(self.match.extra_tracks) / len(self.match.info.tracks):.1%}):"
+                "Missing tracks"
+                f" ({len(self.match.extra_tracks)}/{len(self.match.info.tracks)} -"
+                f" {len(self.match.extra_tracks) / len(self.match.info.tracks):.1%}):"
             )
         for track_info in self.match.extra_tracks:
             line = f" ! {track_info.title} (#{self.format_index(track_info)})"
@@ -783,7 +787,10 @@ def summarize_items(items, singleton):
         total_filesize = sum([item.filesize for item in items])
         summary_parts.append(f"{int(average_bitrate / 1000)}kbps")
         if items[0].format == "FLAC":
-            sample_bits = f"{round(int(items[0].samplerate) / 1000, 1)}kHz/{items[0].bitdepth} bit"
+            sample_bits = (
+                f"{round(int(items[0].samplerate) / 1000, 1)}kHz"
+                f"/{items[0].bitdepth} bit"
+            )
             summary_parts.append(sample_bits)
         summary_parts.append(human_seconds_short(total_duration))
         summary_parts.append(human_bytes(total_filesize))
@@ -900,11 +907,9 @@ def choose_candidate(
             # Display list of candidates.
             print_("")
             print_(
-                'Finding tags for {} "{} - {}".'.format(
-                    "track" if singleton else "album",
-                    item.artist if singleton else cur_artist,
-                    item.title if singleton else cur_album,
-                )
+                f"Finding tags for {'track' if singleton else 'album'}"
+                f'"{item.artist if singleton else cur_artist} -'
+                f' {item.title if singleton else cur_album}".'
             )
 
             print_(ui.indent(2) + "Candidates:")
@@ -914,7 +919,10 @@ def choose_candidate(
                 index = dist_colorize(index0, match.distance)
                 dist = f"({(1 - match.distance) * 100:.1f}%)"
                 distance = dist_colorize(dist, match.distance)
-                metadata = f"{match.info.artist} - {match.info.title if singleton else match.info.album}"
+                metadata = (
+                    f"{match.info.artist} -"
+                    f" {match.info.title if singleton else match.info.album}"
+                )
                 if i == 0:
                     metadata = dist_colorize(metadata, match.distance)
                 else:
@@ -1002,7 +1010,7 @@ def manual_id(session, task):
 
     Input an ID, either for an album ("release") or a track ("recording").
     """
-    prompt = "Enter {} ID:".format("release" if task.is_album else "recording")
+    prompt = f"Enter {'release' if task.is_album else 'recording'} ID:"
     search_id = input_(prompt).strip()
 
     if task.is_album:
@@ -1304,7 +1312,8 @@ def import_files(lib, paths: list[bytes], query):
             loghandler = logging.FileHandler(logpath, encoding="utf-8")
         except OSError:
             raise ui.UserError(
-                f"Could not open log file for writing: {displayable_path(logpath)}"
+                "Could not open log file for writing:"
+                f" {displayable_path(logpath)}"
             )
     else:
         loghandler = None
@@ -1791,22 +1800,25 @@ def remove_items(lib, query, album, delete, force):
     if not force:
         # Prepare confirmation with user.
         album_str = (
-            " in {} album{}".format(len(albums), "s" if len(albums) > 1 else "")
+            f" in {len(albums)} album{'s' if len(albums) > 1 else ''}"
             if album
             else ""
         )
 
         if delete:
             fmt = "$path - $title"
             prompt = "Really DELETE"
-            prompt_all = "Really DELETE {} file{}{}".format(
-                len(items), "s" if len(items) > 1 else "", album_str
+            prompt_all = (
+                "Really DELETE"
+                f" {len(items)} file{'s' if len(items) > 1 else ''}{album_str}"
             )
         else:
             fmt = ""
             prompt = "Really remove from the library?"
-            prompt_all = "Really remove {} item{}{} from the library?".format(
-                len(items), "s" if len(items) > 1 else "", album_str
+            prompt_all = (
+                "Really remove"
+                f" {len(items)} item{'s' if len(items) > 1 else ''}{album_str}"
+                " from the library?"
             )
 
         # Helpers for printing affected items
@@ -1889,23 +1901,13 @@ def show_stats(lib, query, exact):
     if exact:
         size_str += f" ({total_size} bytes)"
 
-    print_(
-        """Tracks: {}
-Total time: {}{}
-{}: {}
-Artists: {}
-Albums: {}
-Album artists: {}""".format(
-            total_items,
-            human_seconds(total_time),
-            f" ({total_time:.2f} seconds)" if exact else "",
-            "Total size" if exact else "Approximate total size",
-            size_str,
-            len(artists),
-            len(albums),
-            len(album_artists),
-        ),
-    )
+    print_(f"""Tracks: {total_items}
+Total time: {human_seconds(total_time)}
+{f" ({total_time:.2f} seconds)" if exact else ""}
+{"Total size" if exact else "Approximate total size"}: {size_str}
+Artists: {len(artists)}
+Albums: {len(albums)}
+Album artists: {len(album_artists)}""")
 
 
 def stats_func(lib, opts, args):
@@ -1960,7 +1962,7 @@ def modify_items(lib, mods, dels, query, write, move, album, confirm, inherit):
 
     # Apply changes *temporarily*, preview them, and collect modified
     # objects.
-    print_("Modifying {} {}s.".format(len(objs), "album" if album else "item"))
+    print_(f"Modifying {len(objs)} {'album' if album else 'item'}s.")
     changed = []
     templates = {
         key: functemplate.template(value) for key, value in mods.items()
@@ -2467,7 +2469,7 @@ def completion_script(commands):
     # Command aliases
     yield "  local aliases='%s'\n" % " ".join(aliases.keys())
     for alias, cmd in aliases.items():
-        yield "  local alias__{}={}\n".format(alias.replace("-", "_"), cmd)
+        yield f"  local alias__{alias.replace('-', '_')}={cmd}\n"
     yield "\n"
 
     # Fields
@@ -2483,8 +2485,9 @@ def completion_script(commands):
         for option_type, option_list in opts.items():
             if option_list:
                 option_list = " ".join(option_list)
-                yield "  local {}__{}='{}'\n".format(
-                    option_type, cmd.replace("-", "_"), option_list
+                yield (
+                    "  local"
+                    f" {option_type}__{cmd.replace('-', '_')}='{option_list}'\n"
                 )
 
     yield "  _beet_dispatch\n"

beets/util/__init__.py

@@ -141,12 +141,16 @@ def __init__(self, reason, verb, paths, tb=None):
     def get_message(self):
         # Use a nicer English phrasing for some specific verbs.
         if self.verb in ("move", "copy", "rename"):
-            clause = f"while {self._gerund()} {displayable_path(self.paths[0])} to {displayable_path(self.paths[1])}"
+            clause = (
+                f"while {self._gerund()} {displayable_path(self.paths[0])} to"
+                f" {displayable_path(self.paths[1])}"
+            )
         elif self.verb in ("delete", "write", "create", "read"):
             clause = f"while {self._gerund()} {displayable_path(self.paths[0])}"
         else:
-            clause = "during {} of paths {}".format(
-                self.verb, ", ".join(displayable_path(p) for p in self.paths)
+            clause = (
+                f"during {self.verb} of paths"
+                f" {', '.join(displayable_path(p) for p in self.paths)}"
             )
 
         return f"{self._reasonstr()} {clause}"
@@ -219,7 +223,8 @@ def sorted_walk(
     except OSError as exc:
         if logger:
             logger.warning(
-                f"could not list directory {displayable_path(bytes_path)}: {exc.strerror}"
+                f"could not list directory {displayable_path(bytes_path)}:"
+                f" {exc.strerror}"
             )
         return
     dirs = []

beetsplug/aura.py

@@ -780,20 +780,17 @@ def audio_file(track_id):
         return AURADocument.error(
             "404 Not Found",
             "No audio file for the requested track.",
-            (
-                f"There is no audio file for track {track_id} at the expected location"
-            ),
+            f"There is no audio file for track {track_id} at the expected"
+            " location",
         )
 
     file_mimetype = guess_type(path)[0]
     if not file_mimetype:
         return AURADocument.error(
             "500 Internal Server Error",
             "Requested audio file has an unknown mimetype.",
-            (
-                "The audio file for track {} has an unknown mimetype. "
-                "Its file extension is {}."
-            ).format(track_id, path.split(".")[-1]),
+            f"The audio file for track {track_id} has an unknown mimetype. "
+            f"Its file extension is {path.split('.')[-1]}.",
         )
 
     # Check that the Accept header contains the file's mimetype
@@ -805,10 +802,8 @@ def audio_file(track_id):
         return AURADocument.error(
             "406 Not Acceptable",
             "Unsupported MIME type or bitrate parameter in Accept header.",
-            (
-                f"The audio file for track {track_id} is only available as {file_mimetype} and "
-                "bitrate parameters are not supported."
-            ),
+            f"The audio file for track {track_id} is only available as"
+            f" {file_mimetype} and bitrate parameters are not supported.",
         )
 
     return send_file(