support in_quotes search query

app/api/playlist.py

@@ -20,16 +20,6 @@ api = Blueprint("playlist", __name__, url_prefix="/")
 
 PL = SQLitePlaylistMethods
 
-insert_one_playlist = PL.insert_one_playlist
-get_playlist_by_name = PL.get_playlist_by_name
-count_playlist_by_name = PL.count_playlist_by_name
-get_all_playlists = PL.get_all_playlists
-get_playlist_by_id = PL.get_playlist_by_id
-tracks_to_playlist = PL.add_tracks_to_playlist
-update_playlist = PL.update_playlist
-delete_playlist = PL.delete_playlist
-remove_image = PL.remove_banner
-
 
 def duplicate_images(images: list):
     if len(images) == 1:
@@ -80,7 +70,7 @@ def send_all_playlists():
     # get the no_images query param
     no_images = request.args.get("no_images", False)
 
-    playlists = get_all_playlists()
+    playlists = PL.get_all_playlists()
     playlists = list(playlists)
 
     for playlist in playlists:
@@ -109,7 +99,7 @@ def insert_playlist(name: str):
         ),
     }
 
-    return insert_one_playlist(playlist)
+    return PL.insert_one_playlist(playlist)
 
 
 @api.route("/playlist/new", methods=["POST"])
@@ -122,7 +112,7 @@ def create_playlist():
     if data is None:
         return {"error": "Playlist name not provided"}, 400
 
-    existing_playlist_count = count_playlist_by_name(data["name"])
+    existing_playlist_count = PL.count_playlist_by_name(data["name"])
 
     if existing_playlist_count > 0:
         return {"error": "Playlist already exists"}, 409
@@ -161,7 +151,7 @@ def get_artist_trackhashes(artisthash: str):
 
 
 @api.route("/playlist/<playlist_id>/add", methods=["POST"])
-def add_track_to_playlist(playlist_id: str):
+def add_item_to_playlist(playlist_id: str):
     """
     Takes a playlist ID and a track hash, and adds the track to the playlist
     """
@@ -191,10 +181,10 @@ def add_track_to_playlist(playlist_id: str):
     else:
         trackhashes = []
 
-    insert_count = tracks_to_playlist(int(playlist_id), trackhashes)
+    insert_count = PL.add_tracks_to_playlist(int(playlist_id), trackhashes)
 
     if insert_count == 0:
-        return {"error": "Track already exists in playlist"}, 409
+        return {"error": "Item already exists in playlist"}, 409
 
     PL.update_last_updated(int(playlist_id))
 
@@ -209,7 +199,7 @@ def get_playlist(playlistid: str):
     no_tracks = request.args.get("no_tracks", False)
     no_tracks = no_tracks == "true"
 
-    playlist = get_playlist_by_id(int(playlistid))
+    playlist = PL.get_playlist_by_id(int(playlistid))
 
     if playlist is None:
         return {"msg": "Playlist not found"}, 404
@@ -243,7 +233,7 @@ def update_playlist_info(playlistid: str):
     if playlistid is None:
         return {"error": "Playlist ID not provided"}, 400
 
-    db_playlist = get_playlist_by_id(int(playlistid))
+    db_playlist = PL.get_playlist_by_id(int(playlistid))
 
     if db_playlist is None:
         return {"error": "Playlist not found"}, 404
@@ -279,7 +269,7 @@ def update_playlist_info(playlistid: str):
 
     p_tuple = (*playlist.values(),)
 
-    update_playlist(int(playlistid), playlist)
+    PL.update_playlist(int(playlistid), playlist)
 
     playlist = models.Playlist(*p_tuple)
     playlist.last_updated = date_string_to_time_passed(playlist.last_updated)
@@ -295,12 +285,12 @@ def remove_playlist_image(playlistid: str):
     Removes the playlist image.
     """
     pid = int(playlistid)
-    playlist = get_playlist_by_id(pid)
+    playlist = PL.get_playlist_by_id(pid)
 
     if playlist is None:
         return {"error": "Playlist not found"}, 404
 
-    remove_image(pid)
+    PL.remove_image(pid)
 
     playlist.image = None
     playlist.thumb = None
@@ -330,7 +320,7 @@ def remove_playlist():
     except KeyError:
         return message, 400
 
-    delete_playlist(pid)
+    PL.delete_playlist(pid)
 
     return {"msg": "Done"}, 200
 
@@ -373,7 +363,7 @@ def remove_tracks_from_playlist(pid: int):
 
 
 def playlist_exists(name: str) -> bool:
-    return count_playlist_by_name(name) > 0
+    return PL.count_playlist_by_name(name) > 0
 
 
 @api.route("/playlist/save-item", methods=["POST"])
@@ -402,7 +392,12 @@ def save_item_as_playlist():
     except KeyError:
         itemhash = None
 
-    if itemtype == "folder":
+    if itemtype is None or playlist_name is None or itemhash is None:
+        return msg
+
+    if itemtype == "track":
+        trackhashes = [itemhash]
+    elif itemtype == "folder":
         trackhashes = get_path_trackhashes(itemhash)
     elif itemtype == "album":
         trackhashes = get_album_trackhashes(itemhash)
@@ -419,7 +414,7 @@ def save_item_as_playlist():
     if playlist is None:
         return {"error": "Playlist could not be created"}, 500
 
-    tracks_to_playlist(playlist.id, trackhashes)
+    PL.add_tracks_to_playlist(playlist.id, trackhashes)
     PL.update_last_updated(playlist.id)
 
-    return {"playlist_id": playlist.id}, 201
+    return {"playlist": playlist}, 201

app/api/search.py

@@ -2,13 +2,11 @@
 Contains all the search routes.
 """
 
-from unidecode import unidecode
 from flask import Blueprint, request
+from unidecode import unidecode
 
 from app import models
 from app.lib import searchlib
-
-
 from app.store.tracks import TrackStore
 
 api = Blueprint("search", __name__, url_prefix="/")
@@ -17,68 +15,45 @@ SEARCH_COUNT = 12
 """The max amount of items to return per request"""
 
 
-class SearchResults:
+def query_in_quotes(query: str) -> bool:
     """
-    Holds all the search results.
+    Returns True if the query is in quotes
     """
-
-    query: str = ""
-    tracks: list[models.Track] = []
-    albums: list[models.Album] = []
-    playlists: list[models.Playlist] = []
-    artists: list[models.Artist] = []
+    return query.startswith('"') and query.endswith('"')
 
 
 class Search:
     def __init__(self, query: str) -> None:
         self.tracks: list[models.Track] = []
         self.query = unidecode(query)
-        SearchResults.query = self.query
 
-    def search_tracks(self):
+    def search_tracks(self, in_quotes=False):
         """
         Calls :class:`SearchTracks` which returns the tracks that fuzzily match
         the search terms. Then adds them to the `SearchResults` store.
         """
         self.tracks = TrackStore.tracks
-        tracks = searchlib.SearchTracks(self.query)()
-
-        SearchResults.tracks = tracks
-        return tracks
+        return searchlib.TopResults().search(
+            self.query, tracks_only=True, in_quotes=in_quotes
+        )
 
     def search_artists(self):
         """Calls :class:`SearchArtists` which returns the artists that fuzzily match
         the search term. Then adds them to the `SearchResults` store.
         """
-        artists = searchlib.SearchArtists(self.query)()
-        SearchResults.artists = artists
-        return artists
+        return searchlib.SearchArtists(self.query)()
 
-    def search_albums(self):
+    def search_albums(self, in_quotes=False):
         """Calls :class:`SearchAlbums` which returns the albums that fuzzily match
         the search term. Then adds them to the `SearchResults` store.
         """
-        albums = searchlib.SearchAlbums(self.query)()
-        SearchResults.albums = albums
-
-        return albums
-
-    # def search_playlists(self):
-    #     """Calls :class:`SearchPlaylists` which returns the playlists that fuzzily match
-    #     the search term. Then adds them to the `SearchResults` store.
-    #     """
-    #     playlists = utils.Get.get_all_playlists()
-    #     playlists = [serializer.Playlist(playlist) for playlist in playlists]
-
-    #     playlists = searchlib.SearchPlaylists(playlists, self.query)()
-    #     SearchResults.playlists = playlists
-
-    #     return playlists
-
-    def get_top_results(self):
-        finder = searchlib.SearchAll()
-        return finder.search(self.query)
+        return searchlib.TopResults().search(
+            self.query, albums_only=True, in_quotes=in_quotes
+        )
 
+    def get_top_results(self, in_quotes=False):
+        finder = searchlib.TopResults()
+        return finder.search(self.query, in_quotes=in_quotes)
 
 
 @api.route("/search/tracks", methods=["GET"])
@@ -88,10 +63,12 @@ def search_tracks():
     """
 
     query = request.args.get("q")
+    in_quotes = query_in_quotes(query)
+
     if not query:
         return {"error": "No query provided"}, 400
 
-    tracks = Search(query).search_tracks()
+    tracks = Search(query).search_tracks(in_quotes)
 
     return {
         "tracks": tracks[:SEARCH_COUNT],
@@ -106,14 +83,16 @@ def search_albums():
     """
 
     query = request.args.get("q")
+    in_quotes = query_in_quotes(query)
+
     if not query:
         return {"error": "No query provided"}, 400
 
-    tracks = Search(query).search_albums()
+    albums = Search(query).search_albums(in_quotes)
 
     return {
-        "albums": tracks[:SEARCH_COUNT],
-        "more": len(tracks) > SEARCH_COUNT,
+        "albums": albums[:SEARCH_COUNT],
+        "more": len(albums) > SEARCH_COUNT,
     }
 
 
@@ -124,6 +103,7 @@ def search_artists():
     """
 
     query = request.args.get("q")
+
     if not query:
         return {"error": "No query provided"}, 400
 
@@ -135,24 +115,6 @@ def search_artists():
     }
 
 
-# @searchbp.route("/search/playlists", methods=["GET"])
-# def search_playlists():
-#     """
-#     Searches for playlists.
-#     """
-
-#     query = request.args.get("q")
-#     if not query:
-#         return {"error": "No query provided"}, 400
-
-#     playlists = DoSearch(query).search_playlists()
-
-#     return {
-#         "playlists": playlists[:SEARCH_COUNT],
-#         "more": len(playlists) > SEARCH_COUNT,
-#     }
-
-
 @api.route("/search/top", methods=["GET"])
 def get_top_results():
     """
@@ -160,21 +122,12 @@ def get_top_results():
     """
 
     query = request.args.get("q")
+    in_quotes = query_in_quotes(query)
+
     if not query:
         return {"error": "No query provided"}, 400
 
-    results = Search(query).get_top_results()
-
-    # max_results = 2
-    # return {
-    #     "tracks": SearchResults.tracks[:max_results],
-    #     "albums": SearchResults.albums[:max_results],
-    #     "artists": SearchResults.artists[:max_results],
-    #     "playlists": SearchResults.playlists[:max_results],
-    # }
-    return {
-        "results": results
-    }
+    return Search(query).get_top_results(in_quotes=in_quotes)
 
 
 @api.route("/search/loadmore")
@@ -182,28 +135,32 @@ def search_load_more():
     """
     Returns more songs, albums or artists from a search query.
     """
+    query = request.args.get("q")
+    in_quotes = query_in_quotes(query)
+
     s_type = request.args.get("type")
     index = int(request.args.get("index") or 0)
 
     if s_type == "tracks":
-        t = SearchResults.tracks
+        t = Search(query).search_tracks(in_quotes)
         return {
-            "tracks": t[index: index + SEARCH_COUNT],
+            "tracks": t[index : index + SEARCH_COUNT],
             "more": len(t) > index + SEARCH_COUNT,
         }
 
     elif s_type == "albums":
-        a = SearchResults.albums
+        a = Search(query).search_albums(in_quotes)
         return {
-            "albums": a[index: index + SEARCH_COUNT],
+            "albums": a[index : index + SEARCH_COUNT],
             "more": len(a) > index + SEARCH_COUNT,
         }
 
     elif s_type == "artists":
-        a = SearchResults.artists
+        a = Search(query).search_artists()
         return {
-            "artists": a[index: index + SEARCH_COUNT],
+            "artists": a[index : index + SEARCH_COUNT],
             "more": len(a) > index + SEARCH_COUNT,
         }
 
-# TODO: Rewrite this file using generators where possible
+
+# TODO: Rewrite this file using generators where possible