combine userdata and swing db into one

+ port populate to new db interface
+ add genrehashes and hash info to tracks
+ properly structure new db table files
+ move helpers to dedicated utils file
+ move settings from db to config file
+ move artists, albums, auth and favorites endpoint to new db interface
+ use folder store to index filepaths
+ paginate favorite pages
+ 56 moretiny changes 😅

app/api/album.py

@@ -12,15 +12,14 @@ from flask_openapi3 import APIBlueprint
 from app.api.apischemas import AlbumHashSchema, AlbumLimitSchema, ArtistHashSchema
 
 from app.config import UserConfig
-from app.db import AlbumTable as AlbumDb, TrackTable as TrackDb
+from app.db.libdata import ArtistTable
+from app.db.libdata import AlbumTable as AlbumDb, TrackTable as TrackDb
+from app.db.userdata import SimilarArtistTable
 from app.settings import Defaults
-from app.models import FavType, Track
-from app.store.albums import AlbumStore
-from app.store.tracks import TrackStore
 from app.utils.hashing import create_hash
 from app.lib.albumslib import sort_by_track_no
 from app.serializers.album import serialize_for_card, serialize_for_card_many
-from app.serializers.track import serialize_track
+from app.serializers.track import serialize_track, serialize_tracks
 from app.db.sqlite.albumcolors import SQLiteAlbumMethods as adb
 from app.db.sqlite.favorite import SQLiteFavoriteMethods as favdb
 from app.db.sqlite.lastfm.similar_artists import SQLiteLastFMSimilarArtists as lastfmdb
@@ -52,9 +51,22 @@ def get_album_tracks_and_info(body: AlbumHashSchema):
     album.type = album.check_type(
         tracks=tracks, singleTrackAsSingle=UserConfig().showAlbumsAsSingles
     )
-    album.populate_versions()
 
-    return {"info": album, "tracks": tracks}
+    track_total = sum({int(t.extra.get("track_total", 1) or 1) for t in tracks})
+
+    return {
+        "info": album,
+        "extra": {
+            # INFO: track_total is the sum of a set of track_total values from each track
+            # ASSUMPTIONS
+            # 1. All the tracks have the correct track totals
+            # 2. Tracks with the same track total are from the same disc
+            "track_total": track_total,
+            "avg_bitrate": sum(t.bitrate for t in tracks) // len(tracks),
+        },
+        "copyright": tracks[0].copyright,
+        "tracks": serialize_tracks(tracks, remove_disc=False),
+    }
 
 
 @api.get("/<albumhash>/tracks")
@@ -68,7 +80,7 @@ def get_album_tracks(path: AlbumHashSchema):
     tracks = TrackDb.get_tracks_by_albumhash(path.albumhash)
     tracks = sort_by_track_no(tracks)
 
-    return tracks
+    return serialize_tracks(tracks)
 
 
 class GetMoreFromArtistsBody(AlbumLimitSchema):
@@ -138,30 +150,14 @@ def get_album_versions(body: GetAlbumVersionsBody):
     artisthash = body.artisthash
 
     albums = AlbumDb.get_albums_by_base_title(base_title)
-    print(albums)
     albums = [
         a
         for a in albums
         if a.og_title != og_album_title
         and artisthash in {a["artisthash"] for a in a.albumartists}
     ]
-
     print(albums)
-
-    # albums = AlbumStore.get_albums_by_artisthash(artisthash)
-
-    # albums = [
-    #     a
-    #     for a in albums
-    #     if create_hash(a.base_title) == create_hash(base_title)
-    #     and create_hash(og_album_title) != create_hash(a.og_title)
-    # ]
-
-    # for a in albums:
-    #     tracks = TrackStore.get_tracks_by_albumhash(a.albumhash)
-    #     a.get_date_from_tracks(tracks)
-
-    return albums
+    return serialize_for_card_many(albums)
 
 
 class GetSimilarAlbumsQuery(ArtistHashSchema, AlbumLimitSchema):
@@ -178,24 +174,15 @@ def get_similar_albums(query: GetSimilarAlbumsQuery):
     artisthash = query.artisthash
     limit = query.limit
 
-    similar_artists = lastfmdb.get_similar_artists_for(artisthash)
+    similar_artists = SimilarArtistTable.get_by_hash(artisthash)
 
     if similar_artists is None:
-        return {"albums": []}
+        return []
 
     artisthashes = similar_artists.get_artist_hash_set()
+    artists = ArtistTable.get_artists_by_artisthashes(artisthashes)
 
-    if len(artisthashes) == 0:
-        return {"albums": []}
+    albums = AlbumDb.get_albums_by_artisthashes([a.artisthash for a in artists])
+    sample = random.sample(albums, min(len(albums), limit))
 
-    albums = [AlbumStore.get_albums_by_artisthash(a) for a in artisthashes]
-
-    albums = [a for sublist in albums for a in sublist]
-    albums = list({a.albumhash: a for a in albums}.values())
-
-    try:
-        albums = random.sample(albums, min(len(albums), limit))
-    except ValueError:
-        pass
-
-    return [serialize_for_card(a) for a in albums[:limit]]
+    return serialize_for_card_many(sample[:limit])