Use f-strings instead of string concat

Author: snejus

beets/art.py

@@ -192,7 +192,7 @@ def extract(log, outpath, item):
     if not ext:
         log.warning("Unknown image type in {0}.", displayable_path(item.path))
         return
-    outpath += bytestring_path("." + ext)
+    outpath += bytestring_path(f".{ext}")
 
     log.info(
         "Extracting album art from: {0} to: {1}",

beets/dbcore/db.py

@@ -590,7 +590,7 @@ def store(self, fields: Iterable[str] | None = None):
         for key in fields:
             if key != "id" and key in self._dirty:
                 self._dirty.remove(key)
-                assignments.append(key + "=?")
+                assignments.append(f"{key}=?")
                 value = self._type(key).to_sql(self[key])
                 subvars.append(value)
 

beets/dbcore/query.py

@@ -190,7 +190,7 @@ class MatchQuery(FieldQuery[AnySQLiteType]):
     """A query that looks for exact matches in an Model field."""
 
     def col_clause(self) -> tuple[str, Sequence[SQLiteType]]:
-        return self.field + " = ?", [self.pattern]
+        return f"{self.field} = ?", [self.pattern]
 
     @classmethod
     def value_match(cls, pattern: AnySQLiteType, value: Any) -> bool:
@@ -204,7 +204,7 @@ def __init__(self, field, fast: bool = True):
         super().__init__(field, None, fast)
 
     def col_clause(self) -> tuple[str, Sequence[SQLiteType]]:
-        return self.field + " IS NULL", ()
+        return f"{self.field} IS NULL", ()
 
     def match(self, obj: Model) -> bool:
         return obj.get(self.field_name) is None
@@ -246,7 +246,7 @@ def col_clause(self) -> tuple[str, Sequence[SQLiteType]]:
             .replace("%", "\\%")
             .replace("_", "\\_")
         )
-        clause = self.field + " like ? escape '\\'"
+        clause = f"{self.field} like ? escape '\\'"
         subvals = [search]
         return clause, subvals
 
@@ -264,8 +264,8 @@ def col_clause(self) -> tuple[str, Sequence[SQLiteType]]:
             .replace("%", "\\%")
             .replace("_", "\\_")
         )
-        search = "%" + pattern + "%"
-        clause = self.field + " like ? escape '\\'"
+        search = f"%{pattern}%"
+        clause = f"{self.field} like ? escape '\\'"
         subvals = [search]
         return clause, subvals
 
@@ -471,7 +471,7 @@ def match(self, obj: Model) -> bool:
 
     def col_clause(self) -> tuple[str, Sequence[SQLiteType]]:
         if self.point is not None:
-            return self.field + "=?", (self.point,)
+            return f"{self.field}=?", (self.point,)
         else:
             if self.rangemin is not None and self.rangemax is not None:
                 return (
@@ -549,9 +549,9 @@ def clause_with_joiner(
             if not subq_clause:
                 # Fall back to slow query.
                 return None, ()
-            clause_parts.append("(" + subq_clause + ")")
+            clause_parts.append(f"({subq_clause})")
             subvals += subq_subvals
-        clause = (" " + joiner + " ").join(clause_parts)
+        clause = f" {joiner} ".join(clause_parts)
         return clause, subvals
 
     def __repr__(self) -> str:

beets/library/exceptions.py

@@ -28,11 +28,11 @@ class ReadError(FileOperationError):
     """An error while reading a file (i.e. in `Item.read`)."""
 
     def __str__(self):
-        return "error reading " + str(super())
+        return f"error reading {super()}"
 
 
 class WriteError(FileOperationError):
     """An error while writing a file (i.e. in `Item.write`)."""
 
     def __str__(self):
-        return "error writing " + str(super())
+        return f"error writing {super()}"

beets/plugins.py

@@ -291,7 +291,7 @@ def load_plugins(names: Sequence[str] = ()) -> None:
                 namespace = __import__(modname, None, None)
             except ImportError as exc:
                 # Again, this is hacky:
-                if exc.args[0].endswith(" " + name):
+                if exc.args[0].endswith(f" {name}"):
                     log.warning("** plugin {0} not found", name)
                 else:
                     raise

beets/test/_common.py

@@ -153,7 +153,7 @@ def __init__(self, out=None):
         self.out = out
 
     def add(self, s):
-        self.buf.append(s + "\n")
+        self.buf.append(f"{s}\n")
 
     def close(self):
         pass

beets/test/helper.py

@@ -278,7 +278,7 @@ def create_item(self, **values):
         values_["db"] = self.lib
         item = Item(**values_)
         if "path" not in values:
-            item["path"] = "audio." + item["format"].lower()
+            item["path"] = f"audio.{item['format'].lower()}"
         # mtime needs to be set last since other assignments reset it.
         item.mtime = 12345
         return item
@@ -310,7 +310,7 @@ def add_item_fixture(self, **values):
         item = self.create_item(**values)
         extension = item["format"].lower()
         item["path"] = os.path.join(
-            _common.RSRC, util.bytestring_path("min." + extension)
+            _common.RSRC, util.bytestring_path(f"min.{extension}")
         )
         item.add(self.lib)
         item.move(operation=MoveOperation.COPY)
@@ -325,7 +325,7 @@ def add_item_fixtures(self, ext="mp3", count=1):
         """Add a number of items with files to the database."""
         # TODO base this on `add_item()`
         items = []
-        path = os.path.join(_common.RSRC, util.bytestring_path("full." + ext))
+        path = os.path.join(_common.RSRC, util.bytestring_path(f"full.{ext}"))
         for i in range(count):
             item = Item.from_path(path)
             item.album = f"\u00e4lbum {i}"  # Check unicode paths
@@ -372,7 +372,7 @@ def create_mediafile_fixture(self, ext="mp3", images=[]):
         specified extension a cover art image is added to the media
         file.
         """
-        src = os.path.join(_common.RSRC, util.bytestring_path("full." + ext))
+        src = os.path.join(_common.RSRC, util.bytestring_path(f"full.{ext}"))
         handle, path = mkstemp(dir=self.temp_dir)
         path = bytestring_path(path)
         os.close(handle)
@@ -568,7 +568,7 @@ def prepare_track_for_import(
         medium = MediaFile(track_path)
         medium.update(
             {
-                "album": "Tag Album" + (f" {album_id}" if album_id else ""),
+                "album": f"Tag Album{f' {album_id}' if album_id else ''}",
                 "albumartist": None,
                 "mb_albumid": None,
                 "comp": None,
@@ -854,8 +854,8 @@ def _make_album_match(self, artist, album, tracks, distance=0, missing=0):
             album=album,
             tracks=track_infos,
             va=False,
-            album_id="albumid" + id,
-            artist_id="artistid" + id,
+            album_id=f"albumid{id}",
+            artist_id=f"artistid{id}",
             albumtype="soundtrack",
             data_source="match_source",
             bandcamp_album_id="bc_url",
@@ -881,7 +881,7 @@ def run(self, *args, **kwargs):
         super().run(*args, **kwargs)
 
     IMAGEHEADER: dict[str, bytes] = {
-        "image/jpeg": b"\xff\xd8\xff" + b"\x00" * 3 + b"JFIF",
+        "image/jpeg": b"\xff\xd8\xff\x00\x00\x00JFIF",
         "image/png": b"\211PNG\r\n\032\n",
         "image/gif": b"GIF89a",
         # dummy type that is definitely not a valid image content type

beets/ui/__init__.py

@@ -325,7 +325,7 @@ def input_options(
 
             if line_length != 0:
                 # Not the beginning of the line; need a space.
-                part = " " + part
+                part = f" {part}"
                 length += 1
 
             prompt += part
@@ -337,7 +337,7 @@ def input_options(
         fallback_prompt = "Enter one of "
         if numrange:
             fallback_prompt += "{}-{}, ".format(*numrange)
-        fallback_prompt += ", ".join(display_letters) + ":"
+        fallback_prompt += f"{', '.join(display_letters)}:"
 
     resp = input_(prompt)
     while True:
@@ -481,7 +481,7 @@ def input_select_objects(prompt, objs, rep, prompt_all=None):
     "bg_cyan": 46,
     "bg_white": 47,
 }
-RESET_COLOR = COLOR_ESCAPE + "39;49;00m"
+RESET_COLOR = f"{COLOR_ESCAPE}39;49;00m"
 
 # These abstract COLOR_NAMES are lazily mapped on to the actual color in COLORS
 # as they are defined in the configuration files, see function: colorize
@@ -521,7 +521,7 @@ def _colorize(color, text):
     # over all "ANSI codes" in `color`.
     escape = ""
     for code in color:
-        escape = escape + COLOR_ESCAPE + f"{ANSI_CODES[code]}m"
+        escape = f"{escape}{COLOR_ESCAPE}{ANSI_CODES[code]}m"
     return escape + text + RESET_COLOR
 
 
@@ -1492,7 +1492,7 @@ def format_help(self, formatter=None):
 
         # Concatenate the original help message with the subcommand
         # list.
-        return out + "".join(result)
+        return f"{out}{''.join(result)}"
 
     def _subcommand_for_name(self, name):
         """Return the subcommand in self.subcommands matching the

beets/ui/commands.py

@@ -18,6 +18,7 @@
 
 import os
 import re
+import textwrap
 from collections import Counter
 from collections.abc import Sequence
 from itertools import chain
@@ -136,7 +137,7 @@ def _print_keys(query):
 def fields_func(lib, opts, args):
     def _print_rows(names):
         names.sort()
-        print_(f"  {'\n  '.join(names)}")
+        print_(textwrap.indent("\n".join(names), "  "))
 
     print_("Item fields:")
     _print_rows(library.Item.all_keys())
@@ -358,18 +359,18 @@ def show_match_header(self):
 
         # 'Match' line and similarity.
         print_(
-            self.indent_header + f"Match ({dist_string(self.match.distance)}):"
+            f"{self.indent_header}Match ({dist_string(self.match.distance)}):"
         )
 
         if isinstance(self.match.info, autotag.hooks.AlbumInfo):
             # Matching an album - print that
             artist_album_str = (
-                f"{self.match.info.artist}" + f" - {self.match.info.album}"
+                f"{self.match.info.artist} - {self.match.info.album}"
             )
         else:
             # Matching a single track
             artist_album_str = (
-                f"{self.match.info.artist}" + f" - {self.match.info.title}"
+                f"{self.match.info.artist} - {self.match.info.title}"
             )
         print_(
             self.indent_header
@@ -395,6 +396,7 @@ def show_match_details(self):
         """Print out the details of the match, including changes in album name
         and artist name.
         """
+        changed_prefix = ui.colorize("changed", "\u2260")
         # Artist.
         artist_l, artist_r = self.cur_artist or "", self.match.info.artist
         if artist_r == VARIOUS_ARTISTS:
@@ -404,15 +406,15 @@ def show_match_details(self):
             artist_l, artist_r = ui.colordiff(artist_l, artist_r)
             # Prefix with U+2260: Not Equal To
             left = {
-                "prefix": ui.colorize("changed", "\u2260") + " Artist: ",
+                "prefix": f"{changed_prefix} Artist: ",
                 "contents": artist_l,
                 "suffix": "",
             }
             right = {"prefix": "", "contents": artist_r, "suffix": ""}
             self.print_layout(self.indent_detail, left, right)
 
         else:
-            print_(self.indent_detail + "*", "Artist:", artist_r)
+            print_(f"{self.indent_detail}*", "Artist:", artist_r)
 
         if self.cur_album:
             # Album
@@ -424,29 +426,29 @@ def show_match_details(self):
                 album_l, album_r = ui.colordiff(album_l, album_r)
                 # Prefix with U+2260: Not Equal To
                 left = {
-                    "prefix": ui.colorize("changed", "\u2260") + " Album: ",
+                    "prefix": f"{changed_prefix} Album: ",
                     "contents": album_l,
                     "suffix": "",
                 }
                 right = {"prefix": "", "contents": album_r, "suffix": ""}
                 self.print_layout(self.indent_detail, left, right)
             else:
-                print_(self.indent_detail + "*", "Album:", album_r)
+                print_(f"{self.indent_detail}*", "Album:", album_r)
         elif self.cur_title:
             # Title - for singletons
             title_l, title_r = self.cur_title or "", self.match.info.title
             if self.cur_title != self.match.info.title:
                 title_l, title_r = ui.colordiff(title_l, title_r)
                 # Prefix with U+2260: Not Equal To
                 left = {
-                    "prefix": ui.colorize("changed", "\u2260") + " Title: ",
+                    "prefix": f"{changed_prefix} Title: ",
                     "contents": title_l,
                     "suffix": "",
                 }
                 right = {"prefix": "", "contents": title_r, "suffix": ""}
                 self.print_layout(self.indent_detail, left, right)
             else:
-                print_(self.indent_detail + "*", "Title:", title_r)
+                print_(f"{self.indent_detail}*", "Title:", title_r)
 
     def make_medium_info_line(self, track_info):
         """Construct a line with the current medium's info."""
@@ -570,9 +572,9 @@ def make_line(self, item, track_info):
 
         prefix = ui.colorize("changed", "\u2260 ") if changed else "* "
         lhs = {
-            "prefix": prefix + lhs_track + " ",
+            "prefix": f"{prefix}{lhs_track} ",
             "contents": lhs_title,
-            "suffix": " " + lhs_length,
+            "suffix": f" {lhs_length}",
         }
         rhs = {"prefix": "", "contents": "", "suffix": ""}
         if not changed:
@@ -581,9 +583,9 @@ def make_line(self, item, track_info):
         else:
             # Construct a dictionary for the "changed to" side
             rhs = {
-                "prefix": rhs_track + " ",
+                "prefix": f"{rhs_track} ",
                 "contents": rhs_title,
-                "suffix": " " + rhs_length,
+                "suffix": f" {rhs_length}",
             }
             return (lhs, rhs)
 
@@ -909,7 +911,7 @@ def choose_candidate(
                 f' {item.title if singleton else cur_album}".'
             )
 
-            print_(ui.indent(2) + "Candidates:")
+            print_("  Candidates:")
             for i, match in enumerate(candidates):
                 # Index, metadata, and distance.
                 index0 = f"{i + 1}."
@@ -925,17 +927,17 @@ def choose_candidate(
                 else:
                     metadata = ui.colorize("text_highlight_minor", metadata)
                 line1 = [index, distance, metadata]
-                print_(ui.indent(2) + " ".join(line1))
+                print_(f"  {' '.join(line1)}")
 
                 # Penalties.
                 penalties = penalty_string(match.distance, 3)
                 if penalties:
-                    print_(ui.indent(13) + penalties)
+                    print_(f"{' ' * 13}{penalties}")
 
                 # Disambiguation
                 disambig = disambig_string(match.info)
                 if disambig:
-                    print_(ui.indent(13) + disambig)
+                    print_(f"{' ' * 13}{disambig}")
 
             # Ask the user for a choice.
             sel = ui.input_options(choice_opts, numrange=(1, len(candidates)))
@@ -1894,7 +1896,7 @@ def show_stats(lib, query, exact):
         if item.album_id:
             albums.add(item.album_id)
 
-    size_str = "" + human_bytes(total_size)
+    size_str = human_bytes(total_size)
     if exact:
         size_str += f" ({total_size} bytes)"