new: allow searching for local albums

src/server/db/table/albums.py

@@ -557,13 +557,15 @@ async def byArtist(self, artistName: str) -> List[AlbumModel]:
         return await self.select(append=f"WHERE {where}")
 
     async def search(self, query: str) -> List[AlbumModel]:
-        """get songs by (non-sql) query (for the search function)"""
+        """get albums by (non-sql) query (for the search function)"""
 
         filters = query.replace("'", "''").split(";")
         filter_ = ""
 
         def createLike(word: str) -> str:
-            return f"(name LIKE '%{word}%')"
+            return (
+                f"(name LIKE '%{word}%' OR anyArtist LIKE '%{word}%' OR allArtists LIKE '%{word}%')"
+            )
 
         ands: List[str] = []
         for x in filters:

src/server/meta/confidence.py

@@ -8,6 +8,7 @@
 from Levenshtein import distance as lev
 from dataModel.track import ISimpleTrack
 from db.table.playlists import PlaylistModel
+from db.table.albums import AlbumModel
 
 
 class Confidence:
@@ -62,6 +63,11 @@ def forPlaylist(cls, playlist: PlaylistModel, query: str, boost: float = 0) -> f
         """get relevance of playlist"""
         return cls._forStrings([playlist.name], query, boost)
 
+    @classmethod
+    def forAlbum(cls, album: AlbumModel, query: str, boost: float = 0) -> float:
+        """get relevance of playlist"""
+        return cls._forStrings([album.name, *album.allArtists, *album.anyArtist], query, boost)
+
     @classmethod
     def forArtist(cls, name: str, query: str, boost: float = 0) -> float:
         """get relevance of artist"""

src/server/meta/search.py

@@ -9,6 +9,7 @@
 
 from db.database import Database
 from db.table.artists import ArtistModel
+from db.table.albums import AlbumModel
 from dataModel.track import YoutubeTrack, ITrack
 from dataModel.song import Song
 from meta.spotify import Spotify, SpotifyArtist, SpotifyTrack
@@ -37,7 +38,7 @@ class SearchResult:
 
     def __init__(
         self,
-        item: ITrack | Song | ClassicPlayerPlaylist | SpotifyArtist | ArtistModel,
+        item: ITrack | Song | ClassicPlayerPlaylist | SpotifyArtist | ArtistModel | AlbumModel,
         confidence: float,
         scope: SearchScopes,
         type_: SearchScopes,
@@ -234,6 +235,21 @@ async def _getLocalPlaylists(self) -> List[SearchResult]:
             for playlist in playlists
         ]
 
+    async def _getLocalAlbums(self) -> List[SearchResult]:
+        """get local playlists"""
+        if not self._scope.album:
+            return []
+        albums = await Database().albums.search(self._query)
+        return [
+            SearchResult(
+                album,
+                Confidence.forAlbum(album, self._query, boost=0.5),
+                SearchScopes.Local,
+                SearchScopes.Album,
+            )
+            for album in albums
+        ]
+
     async def _getSpotifyArtists(self) -> List[SearchResult]:
         """get spotify artists"""
         if not self._scope.artist:
@@ -274,6 +290,7 @@ async def execute(self) -> None:
             self._items.extend(await self._getLocalTracks())
             self._items.extend(await self._getLocalPlaylists())
             self._items.extend(await self._getLocalArtists())
+            self._items.extend(await self._getLocalAlbums())
 
         if self._scope.youtube:
             self._items.extend(await self._getYoutubeTracks())