load settings from db, use api to change settings

+ add route to get all settings
+ add route to set any setting
+ add untested migration to add settings into settings db
+ compress json in api responses using FlaskCompress
+ serve gziped assets if browser accepts encoded files
+ misc

app/store/albums.py

@@ -9,6 +9,8 @@ from app.models import Album, Track
 from ..utils.hashing import create_hash
 from .tracks import TrackStore
 
+ALBUM_LOAD_KEY = ""
+
 
 class AlbumStore:
     albums: list[Album] = []
@@ -25,16 +27,21 @@ class AlbumStore:
         )
 
     @classmethod
-    def load_albums(cls):
+    def load_albums(cls, instance_key: str):
         """
         Loads all albums from the database into the store.
         """
+        global ALBUM_LOAD_KEY
+        ALBUM_LOAD_KEY = instance_key
 
         cls.albums = []
 
         albumhashes = set(t.albumhash for t in TrackStore.tracks)
 
-        for albumhash in tqdm(albumhashes, desc="Loading albums"):
+        for albumhash in tqdm(albumhashes, desc=f"Loading {instance_key}"):
+            if instance_key != ALBUM_LOAD_KEY:
+                return
+
             for track in TrackStore.tracks:
                 if track.albumhash == albumhash:
                     cls.albums.append(cls.create_album(track))
@@ -67,15 +74,21 @@ class AlbumStore:
 
     @classmethod
     def get_albums_by_albumartist(
-            cls, artisthash: str, limit: int, exclude: str
+        cls, artisthash: str, limit: int, exclude: str
     ) -> list[Album]:
         """
         Returns N albums by the given albumartist, excluding the specified album.
         """
 
-        albums = [album for album in cls.albums if artisthash in album.albumartists_hashes]
+        albums = [
+            album for album in cls.albums if artisthash in album.albumartists_hashes
+        ]
 
-        albums = [album for album in albums if create_hash(album.base_title) != create_hash(exclude)]
+        albums = [
+            album
+            for album in albums
+            if create_hash(album.base_title) != create_hash(exclude)
+        ]
 
         if len(albums) > limit:
             random.shuffle(albums)
@@ -110,7 +123,9 @@ class AlbumStore:
         """
         Returns all albums by the given artist.
         """
-        return [album for album in cls.albums if artisthash in album.albumartists_hashes]
+        return [
+            album for album in cls.albums if artisthash in album.albumartists_hashes
+        ]
 
     @classmethod
     def count_albums_by_artisthash(cls, artisthash: str):

app/store/artists.py

@@ -10,20 +10,28 @@ from app.utils.bisection import UseBisection
 from .albums import AlbumStore
 from .tracks import TrackStore
 
+ARTIST_LOAD_KEY = ""
+
 
 class ArtistStore:
     artists: list[Artist] = []
 
     @classmethod
-    def load_artists(cls):
+    def load_artists(cls, instance_key: str):
         """
         Loads all artists from the database into the store.
         """
+        global ARTIST_LOAD_KEY
+        ARTIST_LOAD_KEY = instance_key
+
         cls.artists = get_all_artists(TrackStore.tracks, AlbumStore.albums)
 
         # db_artists: list[tuple] = list(ardb.get_all_artists())
 
         for artist in tqdm(ardb.get_all_artists(), desc="Loading artists"):
+            if instance_key != ARTIST_LOAD_KEY:
+                return
+
             cls.map_artist_color(artist)
 
     @classmethod

app/store/tracks.py

@@ -6,15 +6,19 @@ from app.models import Track
 from app.utils.bisection import UseBisection
 from app.utils.remove_duplicates import remove_duplicates
 
+TRACKS_LOAD_KEY = ""
+
 
 class TrackStore:
     tracks: list[Track] = []
 
     @classmethod
-    def load_all_tracks(cls):
+    def load_all_tracks(cls, instance_key: str):
         """
         Loads all tracks from the database into the store.
         """
+        global TRACKS_LOAD_KEY
+        TRACKS_LOAD_KEY = instance_key
 
         cls.tracks = list(tdb.get_all_tracks())
 
@@ -22,6 +26,9 @@ class TrackStore:
         fav_hashes = " ".join([t[1] for t in fav_hashes])
 
         for track in tqdm(cls.tracks, desc="Loading tracks"):
+            if instance_key != TRACKS_LOAD_KEY:
+                return
+
             if track.trackhash in fav_hashes:
                 track.is_favorite = True
 
@@ -153,12 +160,14 @@ class TrackStore:
         return remove_duplicates(tracks)
 
     @classmethod
-    def get_tracks_by_artisthash(cls, artisthash: str) -> list[Track]:
+    def get_tracks_by_artisthash(cls, artisthash: str):
         """
         Returns all tracks matching the given artist. Duplicate tracks are removed.
         """
         tracks = [t for t in cls.tracks if artisthash in t.artist_hashes]
-        return remove_duplicates(tracks)
+        tracks = remove_duplicates(tracks)
+        tracks.sort(key=lambda x: x.last_mod)
+        return tracks
 
     @classmethod
     def get_tracks_in_path(cls, path: str):