implement merging album versions

+ add "limit" parameter to the useBisection function
+

app/api/favorites.py

@@ -161,31 +161,24 @@ def get_all_favorites():
     artists = []
 
     for fav in favs:
-        if (
-                len(tracks) >= largest
-                and len(albums) >= largest
-                and len(artists) >= largest
-        ):
-            break
-
         if not len(tracks) >= largest:
             if fav[2] == FavType.track:
                 tracks.append(fav[1])
 
-        if not len(albums) >= largest:
-            if fav[2] == FavType.album:
-                albums.append(fav[1])
-
         if not len(artists) >= largest:
             if fav[2] == FavType.artist:
                 artists.append(fav[1])
 
+        if fav[2] == FavType.album:
+            albums.append(fav[1])
+
     src_tracks = sorted(TrackStore.tracks, key=lambda x: x.trackhash)
     src_albums = sorted(AlbumStore.albums, key=lambda x: x.albumhash)
     src_artists = sorted(ArtistStore.artists, key=lambda x: x.artisthash)
 
     tracks = UseBisection(src_tracks, "trackhash", tracks)()
-    albums = UseBisection(src_albums, "albumhash", albums)()
+    albums = UseBisection(src_albums, "albumhash", albums, limit=album_limit)()
+    print(albums)
     artists = UseBisection(src_artists, "artisthash", artists)()
 
     tracks = remove_none(tracks)

app/models/album.py

@@ -53,8 +53,9 @@ class Album:
                 TrackStore.append_track_artists(self.albumhash, featured, self.title)
 
         if get_flag(ParserFlags.CLEAN_ALBUM_TITLE):
-            # if FromFlags.CLEAN_ALBUM_TITLE:
-            self.title, self.versions = get_base_title_and_versions(self.title)
+            get_versions = not get_flag(ParserFlags.MERGE_ALBUM_VERSIONS)
+
+            self.title, self.versions = get_base_title_and_versions(self.title, get_versions=get_versions)
             self.base_title = self.title
 
             if "super_deluxe" in self.versions:

app/models/track.py

@@ -33,6 +33,7 @@ class Track:
     image: str = ""
     artist_hashes: str = ""
     is_favorite: bool = False
+
     og_title: str = ""
     og_album: str = ""
 
@@ -54,7 +55,7 @@ class Track:
 
             # if track is a single
             if self.og_title == self.album:
-                self.album = new_title
+                self.rename_album(new_title)
 
             if get_flag(ParserFlags.REMOVE_REMASTER_FROM_TRACK):
                 new_title = clean_title(new_title)
@@ -64,6 +65,9 @@ class Track:
             if get_flag(ParserFlags.CLEAN_ALBUM_TITLE):
                 self.album, _ = get_base_title_and_versions(self.album, get_versions=False)
 
+            if get_flag(ParserFlags.MERGE_ALBUM_VERSIONS):
+                self.recreate_albumhash()
+
             self.artist_hashes = "-".join(create_hash(a, decode=True) for a in artists)
             self.artist = [ArtistMinimal(a) for a in artists]
 
@@ -91,9 +95,21 @@ class Track:
         self.trackhash = create_hash(", ".join([a.name for a in self.artist]), self.og_album, self.title)
 
     def recreate_artists_hash(self):
+        """
+        Recreates a track's artist hashes if the artist list was altered
+        """
         self.artist_hashes = "-".join(a.artisthash for a in self.artist)
 
+    def recreate_albumhash(self):
+        """
+        Recreates an albumhash of a track to merge all versions of an album.
+        """
+        self.albumhash = create_hash(self.album, self.albumartist)
+
     def rename_album(self, new_album: str):
+        """
+        Renames an album
+        """
         self.album = new_album
 
     def add_artists(self, artists: list[str], new_album_title: str):

app/settings.py

@@ -162,7 +162,7 @@ class FromFlags:
     DO_PERIODIC_SCANS = True
     PERIODIC_SCAN_INTERVAL = 300  # seconds
 
-    # MERGE_ALBUM_VERSIONS = True
+    MERGE_ALBUM_VERSIONS = True
 
 
 class ParserFlags(Enum):
@@ -173,6 +173,7 @@ class ParserFlags(Enum):
     REMOVE_REMASTER_FROM_TRACK = 'REMOVE_REMASTER_FROM_TRACK'
     DO_PERIODIC_SCANS = 'DO_PERIODIC_SCANS'
     PERIODIC_SCAN_INTERVAL = 'PERIODIC_SCAN_INTERVAL'
+    MERGE_ALBUM_VERSIONS = 'MERGE_ALBUM_VERSIONS'
 
 
 def get_flag(flag: ParserFlags) -> bool:

app/utils/bisection.py

@@ -6,10 +6,11 @@ class UseBisection:
     items.
     """
 
-    def __init__(self, source: list, search_from: str, queries: list[str]) -> None:
+    def __init__(self, source: list, search_from: str, queries: list[str], limit=-1) -> None:
         self.source_list = source
         self.queries_list = queries
         self.attr = search_from
+        self.limit = limit
 
     def find(self, query: str):
         left = 0
@@ -30,7 +31,20 @@ class UseBisection:
         if len(self.source_list) == 0:
             return [None]
 
-        return [self.find(query) for query in self.queries_list]
+        results = []
+
+        for query in self.queries_list:
+            res = self.find(query)
+
+            if res is None:
+                continue
+
+            results.append(res)
+
+            if self.limit != -1 and len(results) >= self.limit:
+                break
+
+        return results
 
 
 def bisection_search_string(strings: list[str], target: str) -> str | None: