Merge remote-tracking branch 'upstream/master' into trunc_artist

Author: arsaboo

.pre-commit-config.yaml

@@ -3,12 +3,12 @@
 
 repos:
   - repo: https://github.com/psf/black
-    rev: 23.11.0
+    rev: 24.2.0
     hooks:
       - id: black
 
   - repo: https://github.com/pycqa/isort
-    rev: 5.12.0
+    rev: 5.13.2
     hooks:
       - id: isort
         name: isort (python)

beets/dbcore/query.py

@@ -122,8 +122,7 @@ class NamedQuery(Query):
     """
 
     @abstractmethod
-    def __init__(self, pattern):
-        ...
+    def __init__(self, pattern): ...
 
 
 P = TypeVar("P")

beets/dbcore/types.py

@@ -35,8 +35,7 @@ class ModelType(typing.Protocol):
         given type.
         """
 
-        def __init__(self, value: Any = None):
-            ...
+        def __init__(self, value: Any = None): ...
 
 else:
     # No structural subtyping in Python < 3.8...

beets/ui/commands.py

@@ -216,12 +216,14 @@ def get_singleton_disambig_fields(info: hooks.TrackInfo) -> Sequence[str]:
     calculated_values = {
         "index": "Index {}".format(str(info.index)),
         "track_alt": "Track {}".format(info.track_alt),
-        "album": "[{}]".format(info.album)
-        if (
-            config["import"]["singleton_album_disambig"].get()
-            and info.get("album")
-        )
-        else "",
+        "album": (
+            "[{}]".format(info.album)
+            if (
+                config["import"]["singleton_album_disambig"].get()
+                and info.get("album")
+            )
+            else ""
+        ),
     }
 
     for field in chosen_fields:
@@ -240,9 +242,11 @@ def get_album_disambig_fields(info: hooks.AlbumInfo) -> Sequence[str]:
     out = []
     chosen_fields = config["match"]["album_disambig_fields"].as_str_seq()
     calculated_values = {
-        "media": "{}x{}".format(info.mediums, info.media)
-        if (info.mediums and info.mediums > 1)
-        else info.media,
+        "media": (
+            "{}x{}".format(info.mediums, info.media)
+            if (info.mediums and info.mediums > 1)
+            else info.media
+        ),
     }
 
     for field in chosen_fields:
@@ -1160,9 +1164,11 @@ def resolve_duplicate(self, task, found_duplicates):
                 print_(
                     "Old: "
                     + summarize_items(
-                        list(duplicate.items())
-                        if task.is_album
-                        else [duplicate],
+                        (
+                            list(duplicate.items())
+                            if task.is_album
+                            else [duplicate]
+                        ),
                         not task.is_album,
                     )
                 )

beets/util/functemplate.py

@@ -58,11 +58,6 @@ def __init__(self, values, functions):
 # Code generation helpers.
 
 
-def ex_lvalue(name):
-    """A variable load expression."""
-    return ast.Name(name, ast.Store())
-
-
 def ex_rvalue(name):
     """A variable store expression."""
     return ast.Name(name, ast.Load())
@@ -75,15 +70,6 @@ def ex_literal(val):
     return ast.Constant(val)
 
 
-def ex_varassign(name, expr):
-    """Assign an expression into a single variable. The expression may
-    either be an `ast.expr` object or a value to be used as a literal.
-    """
-    if not isinstance(expr, ast.expr):
-        expr = ex_literal(expr)
-    return ast.Assign([ex_lvalue(name)], expr)
-
-
 def ex_call(func, args):
     """A function-call expression with only positional parameters. The
     function may be an expression or the name of a function. Each

beetsplug/advancedrewrite.py

@@ -27,37 +27,22 @@
 from beets.ui import UserError
 
 
-def simple_rewriter(field, rules):
+def rewriter(field, simple_rules, advanced_rules):
     """Template field function factory.
 
     Create a template field function that rewrites the given field
     with the given rewriting rules.
-    ``rules`` must be a list of (pattern, replacement) pairs.
+    ``simple_rules`` must be a list of (pattern, replacement) pairs.
+    ``advanced_rules`` must be a list of (query, replacement) pairs.
     """
 
     def fieldfunc(item):
         value = item._values_fixed[field]
-        for pattern, replacement in rules:
+        for pattern, replacement in simple_rules:
             if pattern.match(value.lower()):
                 # Rewrite activated.
                 return replacement
-        # Not activated; return original value.
-        return value
-
-    return fieldfunc
-
-
-def advanced_rewriter(field, rules):
-    """Template field function factory.
-
-    Create a template field function that rewrites the given field
-    with the given rewriting rules.
-    ``rules`` must be a list of (query, replacement) pairs.
-    """
-
-    def fieldfunc(item):
-        value = item._values_fixed[field]
-        for query, replacement in rules:
+        for query, replacement in advanced_rules:
             if query.match(item):
                 # Rewrite activated.
                 return replacement
@@ -97,8 +82,12 @@ def __init__(self):
         }
 
         # Gather all the rewrite rules for each field.
-        simple_rules = defaultdict(list)
-        advanced_rules = defaultdict(list)
+        class RulesContainer:
+            def __init__(self):
+                self.simple = []
+                self.advanced = []
+
+        rules = defaultdict(RulesContainer)
         for rule in self.config.get(template):
             if "match" not in rule:
                 # Simple syntax
@@ -124,12 +113,12 @@ def __init__(self):
                     f"for field {fieldname}"
                 )
                 pattern = re.compile(pattern.lower())
-                simple_rules[fieldname].append((pattern, value))
+                rules[fieldname].simple.append((pattern, value))
 
                 # Apply the same rewrite to the corresponding album field.
                 if fieldname in corresponding_album_fields:
                     album_fieldname = corresponding_album_fields[fieldname]
-                    simple_rules[album_fieldname].append((pattern, value))
+                    rules[album_fieldname].simple.append((pattern, value))
             else:
                 # Advanced syntax
                 match = rule["match"]
@@ -168,24 +157,18 @@ def __init__(self):
                             f"for field {fieldname}"
                         )
 
-                    advanced_rules[fieldname].append((query, replacement))
+                    rules[fieldname].advanced.append((query, replacement))
 
                     # Apply the same rewrite to the corresponding album field.
                     if fieldname in corresponding_album_fields:
                         album_fieldname = corresponding_album_fields[fieldname]
-                        advanced_rules[album_fieldname].append(
+                        rules[album_fieldname].advanced.append(
                             (query, replacement)
                         )
 
         # Replace each template field with the new rewriter function.
-        for fieldname, fieldrules in simple_rules.items():
-            getter = simple_rewriter(fieldname, fieldrules)
-            self.template_fields[fieldname] = getter
-            if fieldname in Album._fields:
-                self.album_template_fields[fieldname] = getter
-
-        for fieldname, fieldrules in advanced_rules.items():
-            getter = advanced_rewriter(fieldname, fieldrules)
+        for fieldname, fieldrules in rules.items():
+            getter = rewriter(fieldname, fieldrules.simple, fieldrules.advanced)
             self.template_fields[fieldname] = getter
             if fieldname in Album._fields:
                 self.album_template_fields[fieldname] = getter

beetsplug/export.py

@@ -74,7 +74,7 @@ def __init__(self):
                 "xml": {
                     # XML module formatting options.
                     "formatting": {}
-                }
+                },
                 # TODO: Use something like the edit plugin
                 # 'item_fields': []
             }

beetsplug/lastimport.py

@@ -204,12 +204,20 @@ def process_tracks(lib, tracks, log):
 
     for num in range(0, total):
         song = None
-        trackid = tracks[num]["mbid"].strip()
-        artist = tracks[num]["artist"].get("name", "").strip()
-        title = tracks[num]["name"].strip()
+        trackid = tracks[num]["mbid"].strip() if tracks[num]["mbid"] else None
+        artist = (
+            tracks[num]["artist"].get("name", "").strip()
+            if tracks[num]["artist"].get("name", "")
+            else None
+        )
+        title = tracks[num]["name"].strip() if tracks[num]["name"] else None
         album = ""
         if "album" in tracks[num]:
-            album = tracks[num]["album"].get("name", "").strip()
+            album = (
+                tracks[num]["album"].get("name", "").strip()
+                if tracks[num]["album"]
+                else None
+            )
 
         log.debug("query: {0} - {1} ({2})", artist, title, album)
 
@@ -219,6 +227,19 @@ def process_tracks(lib, tracks, log):
                 dbcore.query.MatchQuery("mb_trackid", trackid)
             ).get()
 
+        # If not, try just album/title
+        if song is None:
+            log.debug(
+                "no album match, trying by album/title: {0} - {1}", album, title
+            )
+            query = dbcore.AndQuery(
+                [
+                    dbcore.query.SubstringQuery("album", album),
+                    dbcore.query.SubstringQuery("title", title),
+                ]
+            )
+            song = lib.items(query).get()
+
         # If not, try just artist/title
         if song is None:
             log.debug("no album match, trying by artist/title")
@@ -244,7 +265,7 @@ def process_tracks(lib, tracks, log):
 
         if song is not None:
             count = int(song.get("play_count", 0))
-            new_count = int(tracks[num]["playcount"])
+            new_count = int(tracks[num].get("playcount", 1))
             log.debug(
                 "match: {0} - {1} ({2}) " "updating: play_count {3} => {4}",
                 song.artist,