hooks: make AlbumMatch.mapping a tuple

Author: snejus

beets/autotag/__init__.py

@@ -30,7 +30,7 @@
 from .match import Proposal, Recommendation, tag_album, tag_item
 
 if TYPE_CHECKING:
-    from collections.abc import Mapping, Sequence
+    from collections.abc import Sequence
 
     from beets.library import Album, Item, LibModel
 
@@ -210,11 +210,11 @@ def apply_album_metadata(album_info: AlbumInfo, album: Album):
     correct_list_fields(album)
 
 
-def apply_metadata(album_info: AlbumInfo, mapping: Mapping[Item, TrackInfo]):
-    """Set the items' metadata to match an AlbumInfo object using a
-    mapping from Items to TrackInfo objects.
-    """
-    for item, track_info in mapping.items():
+def apply_metadata(
+    album_info: AlbumInfo, item_info_pairs: list[tuple[Item, TrackInfo]]
+):
+    """Set items metadata to match corresponding tagged info."""
+    for item, track_info in item_info_pairs:
         # Artist or artist credit.
         if config["artist_credit"]:
             item.artist = (

beets/autotag/distance.py

@@ -422,7 +422,7 @@ def track_distance(
 def distance(
     items: Sequence[Item],
     album_info: AlbumInfo,
-    mapping: dict[Item, TrackInfo],
+    item_info_pairs: list[tuple[Item, TrackInfo]],
 ) -> Distance:
     """Determines how "significant" an album metadata change would be.
     Returns a Distance object. `album_info` is an AlbumInfo object
@@ -518,16 +518,16 @@ def distance(
 
     # Tracks.
     dist.tracks = {}
-    for item, track in mapping.items():
+    for item, track in item_info_pairs:
         dist.tracks[track] = track_distance(item, track, album_info.va)
         dist.add("tracks", dist.tracks[track].distance)
 
     # Missing tracks.
-    for _ in range(len(album_info.tracks) - len(mapping)):
+    for _ in range(len(album_info.tracks) - len(item_info_pairs)):
         dist.add("missing_tracks", 1.0)
 
     # Unmatched tracks.
-    for _ in range(len(items) - len(mapping)):
+    for _ in range(len(items) - len(item_info_pairs)):
         dist.add("unmatched_tracks", 1.0)
 
     dist.add_data_source(likelies["data_source"], album_info.data_source)

beets/autotag/hooks.py

@@ -223,6 +223,14 @@ class AlbumMatch(NamedTuple):
     extra_items: list[Item]
     extra_tracks: list[TrackInfo]
 
+    @property
+    def item_info_pairs(self) -> list[tuple[Item, TrackInfo]]:
+        return list(self.mapping.items())
+
+    @property
+    def items(self) -> list[Item]:
+        return [i for i, _ in self.item_info_pairs]
+
 
 class TrackMatch(NamedTuple):
     distance: Distance

beets/autotag/match.py

@@ -69,7 +69,7 @@ class Proposal(NamedTuple):
 def assign_items(
     items: Sequence[Item],
     tracks: Sequence[TrackInfo],
-) -> tuple[dict[Item, TrackInfo], list[Item], list[TrackInfo]]:
+) -> tuple[list[tuple[Item, TrackInfo]], list[Item], list[TrackInfo]]:
     """Given a list of Items and a list of TrackInfo objects, find the
     best mapping between them. Returns a mapping from Items to TrackInfo
     objects, a set of extra Items, and a set of extra TrackInfo
@@ -86,16 +86,17 @@ def assign_items(
     # Each item in `assigned_item_idxs` list corresponds to a track in the
     # `tracks` list. Each value is either an index into the assigned item in
     # `items` list, or -1 if that track has no match.
-    mapping = {
-        items[iidx]: t
+    item_info_pairs = [
+        (items[iidx], t)
         for iidx, t in zip(assigned_item_idxs, tracks)
         if iidx != -1
-    }
-    extra_items = list(set(items) - mapping.keys())
+    ]
+    item_info_pairs.sort(key=lambda it: (it[0].disc, it[0].track, it[0].title))
+    extra_items = list(set(items) - {i for i, _ in item_info_pairs})
     extra_items.sort(key=lambda i: (i.disc, i.track, i.title))
-    extra_tracks = list(set(tracks) - set(mapping.values()))
+    extra_tracks = list(set(tracks) - {t for _, t in item_info_pairs})
     extra_tracks.sort(key=lambda t: (t.index, t.title))
-    return mapping, extra_items, extra_tracks
+    return item_info_pairs, extra_items, extra_tracks
 
 
 def match_by_id(items: Iterable[Item]) -> AlbumInfo | None:
@@ -217,10 +218,12 @@ def _add_candidate(
             return
 
     # Find mapping between the items and the track info.
-    mapping, extra_items, extra_tracks = assign_items(items, info.tracks)
+    item_info_pairs, extra_items, extra_tracks = assign_items(
+        items, info.tracks
+    )
 
     # Get the change distance.
-    dist = distance(items, info, mapping)
+    dist = distance(items, info, item_info_pairs)
 
     # Skip matches with ignored penalties.
     penalties = [key for key, _ in dist]
@@ -232,7 +235,7 @@ def _add_candidate(
 
     log.debug("Success. Distance: {}", dist)
     results[info.album_id] = hooks.AlbumMatch(
-        dist, info, mapping, extra_items, extra_tracks
+        dist, info, dict(item_info_pairs), extra_items, extra_tracks
     )
 
 

beets/importer/tasks.py

@@ -245,21 +245,21 @@ def imported_items(self):
         matched items.
         """
         if self.choice_flag in (Action.ASIS, Action.RETAG):
-            return list(self.items)
+            return self.items
         elif self.choice_flag == Action.APPLY and isinstance(
             self.match, autotag.AlbumMatch
         ):
-            return list(self.match.mapping.keys())
+            return self.match.items
         else:
             assert False
 
     def apply_metadata(self):
         """Copy metadata from match info to the items."""
         if config["import"]["from_scratch"]:
-            for item in self.match.mapping:
+            for item in self.match.items:
                 item.clear()
 
-        autotag.apply_metadata(self.match.info, self.match.mapping)
+        autotag.apply_metadata(self.match.info, self.match.item_info_pairs)
 
     def duplicate_items(self, lib: library.Library):
         duplicate_items = []

beets/ui/commands/import_/display.py

@@ -373,8 +373,9 @@ def show_match_tracks(self):
         # Tracks.
         # match is an AlbumMatch NamedTuple, mapping is a dict
         # Sort the pairs by the track_info index (at index 1 of the NamedTuple)
-        pairs = list(self.match.mapping.items())
-        pairs.sort(key=lambda item_and_track_info: item_and_track_info[1].index)
+        pairs = sorted(
+            self.match.item_info_pairs, key=lambda pair: pair[1].index
+        )
         # Build up LHS and RHS for track difference display. The `lines` list
         # contains `(left, right)` tuples.
         lines = []

beetsplug/bpsync.py

@@ -149,14 +149,14 @@ def albums(self, lib, query, move, pretend, write):
             library_trackid_to_item = {
                 int(item.mb_trackid): item for item in items
             }
-            item_to_trackinfo = {
-                item: beatport_trackid_to_trackinfo[track_id]
+            item_info_pairs = [
+                (item, beatport_trackid_to_trackinfo[track_id])
                 for track_id, item in library_trackid_to_item.items()
-            }
+            ]
 
             self._log.info("applying changes to {}", album)
             with lib.transaction():
-                autotag.apply_metadata(albuminfo, item_to_trackinfo)
+                autotag.apply_metadata(albuminfo, item_info_pairs)
                 changed = False
                 # Find any changed item to apply Beatport changes to album.
                 any_changed_item = items[0]

beetsplug/mbpseudo.py

@@ -278,11 +278,8 @@ def _adjust_final_album_match(self, match: AlbumMatch):
                 album_info.album_id,
             )
             album_info.use_pseudo_as_ref()
-            mapping = match.mapping
-            new_mappings, _, _ = assign_items(
-                list(mapping.keys()), album_info.tracks
-            )
-            mapping.update(new_mappings)
+            new_pairs, *_ = assign_items(match.items, album_info.tracks)
+            album_info.mapping = dict(new_pairs)
 
         if album_info.data_source == self.data_source:
             album_info.data_source = "MusicBrainz"

beetsplug/mbsync.py

@@ -121,18 +121,20 @@ def albums(self, lib, query, move, pretend, write):
             # Construct a track mapping according to MBIDs (release track MBIDs
             # first, if available, and recording MBIDs otherwise). This should
             # work for albums that have missing or extra tracks.
-            mapping = {}
+            item_info_pairs = []
             items = list(album.items())
             for item in items:
                 if (
                     item.mb_releasetrackid
                     and item.mb_releasetrackid in releasetrack_index
                 ):
-                    mapping[item] = releasetrack_index[item.mb_releasetrackid]
+                    item_info_pairs.append(
+                        (item, releasetrack_index[item.mb_releasetrackid])
+                    )
                 else:
                     candidates = track_index[item.mb_trackid]
                     if len(candidates) == 1:
-                        mapping[item] = candidates[0]
+                        item_info_pairs.append((item, candidates[0]))
                     else:
                         # If there are multiple copies of a recording, they are
                         # disambiguated using their disc and track number.
@@ -141,13 +143,13 @@ def albums(self, lib, query, move, pretend, write):
                                 c.medium_index == item.track
                                 and c.medium == item.disc
                             ):
-                                mapping[item] = c
+                                item_info_pairs.append((item, c))
                                 break
 
             # Apply.
             self._log.debug("applying changes to {}", album)
             with lib.transaction():
-                autotag.apply_metadata(album_info, mapping)
+                autotag.apply_metadata(album_info, item_info_pairs)
                 changed = False
                 # Find any changed item to apply changes to album.
                 any_changed_item = items[0]

test/autotag/test_distance.py

@@ -182,7 +182,7 @@ def items(self):
     @pytest.fixture
     def get_dist(self, items):
         def inner(info: AlbumInfo):
-            return distance(items, info, dict(zip(items, info.tracks)))
+            return distance(items, info, list(zip(items, info.tracks)))
 
         return inner