Add missing fields to distance

Author: snejus

.mypy.ini

@@ -3,3 +3,4 @@ allow_any_generics = false
 # FIXME: Would be better to actually type the libraries (if under our control),
 # or write our own stubs. For now, silence errors
 ignore_missing_imports = true
+strict = true

beets/autotag/hooks.py

@@ -19,7 +19,7 @@
 import re
 from copy import deepcopy
 from dataclasses import dataclass
-from functools import total_ordering
+from functools import cached_property, total_ordering
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -37,6 +37,7 @@
 )
 
 from jellyfish import levenshtein_distance
+from rich_tables.utils import make_console
 from typing_extensions import Self
 from unidecode import unidecode
 
@@ -52,6 +53,8 @@
 
 log = logging.getLogger(__name__)
 
+console = make_console()
+
 
 # Classes used to represent candidate options.
 class AttrDict(dict):
@@ -420,21 +423,21 @@ def string_dist(str1: Optional[str], str2: Optional[str]) -> float:
     return base_dist + penalty
 
 
-class LazyClassProperty:
+class cached_classproperty:
     """A decorator implementing a read-only property that is *lazy* in
     the sense that the getter is only invoked once. Subsequent accesses
     through *any* instance use the cached result.
     """
 
     def __init__(self, getter):
         self.getter = getter
-        self.computed = False
+        self.cache = {}
+
+    def __get__(self, instance, owner):
+        if owner not in self.cache:
+            self.cache[owner] = self.getter(owner)
 
-    def __get__(self, obj, owner):
-        if not self.computed:
-            self.value = self.getter(owner)
-            self.computed = True
-        return self.value
+        return self.cache[owner]
 
 
 @total_ordering
@@ -448,7 +451,7 @@ def __init__(self):
         self._penalties = {}
         self.tracks: Dict[TrackInfo, Distance] = {}
 
-    @LazyClassProperty
+    @cached_classproperty
     def _weights(cls) -> Dict[str, float]:  # noqa: N805
         """A dictionary from keys to floating-point weights."""
         weights_view = config["match"]["distance_weights"]
@@ -492,6 +495,7 @@ def raw_distance(self) -> float:
             dist_raw += sum(penalty) * self._weights[key]
         return dist_raw
 
+    @property
     def items(self) -> List[Tuple[str, float]]:
         """Return a list of (key, dist) pairs, with `dist` being the
         weighted distance, sorted from highest to lowest. Does not
@@ -543,13 +547,13 @@ def __getitem__(self, key) -> float:
         return 0.0
 
     def __iter__(self) -> Iterator[Tuple[str, float]]:
-        return iter(self.items())
+        return iter(self.items)
 
     def __len__(self) -> int:
-        return len(self.items())
+        return len(self.items)
 
     def keys(self) -> List[str]:
-        return [key for key, _ in self.items()]
+        return [key for key, _ in self.items]
 
     def update(self, dist: "Distance"):
         """Adds all the distance penalties from `dist`."""
@@ -679,6 +683,13 @@ class Match:
     distance: Distance
     info: AttrDict
 
+    @cached_classproperty
+    def disambig_fields(cls) -> Iterable[str]:
+        fields: List[str] = config["match"][
+            cls.disambig_fields_key
+        ].as_str_seq()
+        return fields
+
     @property
     def dist(self) -> str:
         if self.distance <= config["match"]["strong_rec_thresh"].as_number():
@@ -693,22 +704,23 @@ def dist(self) -> str:
     def name(self) -> str:
         return self.info.name
 
-    @property
+    @cached_property
     def penalty(self, limit: int = 0) -> Optional[str]:
         """Returns a colorized string that indicates all the penalties
         applied to a distance object.
         """
+        field_count = len(self.disambig_fields)
+        missing_field_count = sum(
+            1 for f in self.disambig_fields if not self.info.get(f)
+        )
+        self.distance.add("missing_fields", missing_field_count / field_count)
         penalties = self.distance.penalties
         if penalties:
             if limit and len(penalties) > limit:
                 penalties = penalties[:limit] + ["..."]
             return colorize("text_warning", f"({', '.join(penalties)})")
         return None
 
-    @property
-    def disambig_fields(self) -> Iterable[str]:
-        return config["match"][self.disambig_fields_key].as_str_seq()
-
     @property
     def dist_data(self) -> JSONDict:
         return {

beets/autotag/mb.py

@@ -622,6 +622,7 @@ def album_info(release: Dict) -> beets.autotag.hooks.AlbumInfo:
     if any(
         config["musicbrainz"]["external_ids"].get().values()
     ) and release.get("url-relation-list"):
+        log.error("{}", release.get("url-relation-list"))
         discogs_url, bandcamp_url, spotify_url = None, None, None
         deezer_url, beatport_url, tidal_url = None, None, None
         fetch_discogs, fetch_bandcamp, fetch_spotify = False, False, False