Simplify playlist population scripts

Author: CalPinSW

backend/src/controllers/database.py

@@ -8,20 +8,10 @@
     update_album,
 )
 from src.database.crud.genre import create_genre
-from src.database.crud.track import (
-    all_tracks_have_artists,
-    create_track_or_none,
-    get_album_tracks,
-    get_user_albums_with_no_tracks,
-)
 from src.database.crud.playlist import (
-    add_playlist_album_index,
     create_playlist,
-    get_playlist_albums,
+    delete_playlist,
     get_playlist_by_id_or_none,
-    get_user_playlists,
-    playlist_has_null_album_indexes,
-    update_playlist_with_albums,
 )
 from src.database.crud.user import get_or_create_user
 from src.musicbrainz import MusicbrainzClient
@@ -38,60 +28,28 @@ def database_controller(spotify: SpotifyClient, musicbrainz: MusicbrainzClient):
     def populate_user():
         access_token = request.cookies.get("spotify_access_token")
         user = spotify.get_current_user(access_token)
+        (db_user, _) = get_or_create_user(user)
         simplified_playlists = spotify.get_all_playlists(
             user_id=user.id, access_token=access_token
         )
-        (db_user,) = get_or_create_user(user)
 
         for simplified_playlist in simplified_playlists:
-            if "Albums" in simplified_playlist.name:
+            if (
+                "Albums" in simplified_playlist.name
+                and "New Albums 06/09/24" in simplified_playlist.name
+            ):
+                delete_playlist("0ubqg4akSDebHReJIG8sbd")
                 db_playlist = get_playlist_by_id_or_none(simplified_playlist.id)
-
-                if db_playlist is None:
-                    [playlist, albums] = [
-                        spotify.get_playlist(
-                            access_token=access_token, id=simplified_playlist.id
-                        ),
-                        spotify.get_playlist_album_info(
-                            access_token=access_token, id=simplified_playlist.id
-                        ),
-                    ]
-                    create_playlist(playlist, albums, db_user)
-                else:
-                    if db_playlist.snapshot_id != simplified_playlist.snapshot_id:
-                        [playlist, albums] = [
-                            spotify.get_playlist(
-                                access_token=access_token, id=simplified_playlist.id
-                            ),
-                            spotify.get_playlist_album_info(
-                                access_token=access_token, id=simplified_playlist.id
-                            ),
-                        ]
-                        update_playlist_with_albums(playlist, albums)
-
-        return make_response("Playlist data populated", 201)
-
-    @database_controller.route(
-        "populate_additional_album_details_from_playlist", methods=["GET"]
-    )
-    def populate_additional_album_details_from_playlist():
-        access_token = request.cookies.get("spotify_access_token")
-        user = spotify.get_current_user(access_token)
-        playlists = get_user_playlists(user.id)
-
-        for playlist in playlists:
-            albums = get_playlist_albums(playlist.id)
-            if albums == []:
-                continue
-            batch_albums = split_list(albums, 20)
-            for album_chunk in batch_albums:
-                sleep(0.5)
-                albums = spotify.get_multiple_albums(
-                    access_token=access_token, ids=[album.id for album in album_chunk]
-                )
-                for db_album in albums:
-                    album = spotify.get_album(access_token=access_token, id=db_album.id)
-                    update_album(album)
+                if (
+                    db_playlist is None
+                    or db_playlist.snapshot_id != simplified_playlist.snapshot_id
+                ):
+                    if db_playlist is not None:
+                        delete_playlist(db_playlist.id)
+                    playlist = spotify.get_playlist(
+                        access_token=access_token, id=simplified_playlist.id
+                    )
+                    create_playlist(playlist, db_user)
 
         return make_response("Playlist data populated", 201)
 
@@ -100,12 +58,8 @@ def populate_additional_album_details():
         access_token = request.cookies.get("spotify_access_token")
         user = spotify.get_current_user(access_token)
         albums = get_user_albums(user.id)
-        albums_without_label = [album for album in albums]  # if album.label is None]
-        if albums_without_label == []:
-            return make_response("No Albums to process", 204)
-        batch_albums = split_list(albums_without_label, 20)
+        batch_albums = split_list(albums, 20)
         for album_chunk in batch_albums:
-            sleep(0.5)
             albums = spotify.get_multiple_albums(
                 access_token=access_token, ids=[album.id for album in album_chunk]
             )
@@ -130,74 +84,6 @@ def populate_user_album_genres():
         populate_album_genres_by_user_id(user.id, musicbrainz)
         return make_response("User album genres populated", 201)
 
-    @database_controller.route("populate_album_tracks", methods=["GET"])
-    def populate_album_tracks():
-        access_token = request.cookies.get("spotify_access_token")
-        user = spotify.get_current_user(access_token)
-        albums = get_user_albums_with_no_tracks(user.id)
-        for album in albums:
-            existing_album_tracks = get_album_tracks(album)
-            if existing_album_tracks != []:
-                continue
-            sleep(0.5)
-
-            album_tracks = spotify.get_album(
-                access_token=access_token, id=album.id
-            ).tracks.items
-            for track in album_tracks:
-                create_track_or_none(track, album)
-
-        return make_response("User album genres populated", 201)
-
-    @database_controller.route("populate_playlist_album_indexes", methods=["GET"])
-    def populate_playlist_album_indexes():
-        access_token = request.cookies.get("spotify_access_token")
-        user = spotify.get_current_user(access_token)
-        simplified_playlists = spotify.get_all_playlists(
-            user_id=user.id, access_token=access_token
-        )
-
-        for simplified_playlist in simplified_playlists:
-            if "Albums" in simplified_playlist.name:
-                if not playlist_has_null_album_indexes(simplified_playlist.id):
-                    continue
-                sleep(1)
-
-                [playlist, albums] = [
-                    spotify.get_playlist(
-                        access_token=access_token, id=simplified_playlist.id
-                    ),
-                    spotify.get_playlist_album_info(
-                        access_token=access_token, id=simplified_playlist.id
-                    ),
-                ]
-
-                for index, album in enumerate(albums):
-                    add_playlist_album_index(
-                        playlist_id=playlist.id, album_id=album.id, index=index
-                    )
-
-        return make_response("Playlist album indexes populated", 201)
-
-    @database_controller.route("populate_track_artists", methods=["GET"])
-    def populate_track_artists():
-        access_token = request.cookies.get("spotify_access_token")
-        user = spotify.get_current_user(access_token)
-        albums = get_user_albums(user.id)
-        offset = 1800
-        for index, album in enumerate(albums[offset:]):
-            if all_tracks_have_artists(album.id):
-                continue
-            sleep(0.5)
-            print(index + offset)
-            album_tracks = spotify.get_album(
-                access_token=access_token, id=album.id
-            ).tracks.items
-            for track in album_tracks:
-                create_track_or_none(track, album)
-
-        return make_response("User album genres populated", 201)
-
     return database_controller
 
 

backend/src/controllers/music_data.py

@@ -125,7 +125,7 @@ def find_associated_playlists():
             associated_playlist.model_dump()
             for associated_playlist in associated_playlists
         ]
-    
+
     @music_controller.route("playback", methods=["GET"])
     def get_playback_info():
         access_token = request.cookies.get("spotify_access_token")
@@ -134,16 +134,21 @@ def get_playback_info():
             return ("", 204)
         if playback_info.playlist_id is not None:
             playlist_duration = get_playlist_duration(playback_info.playlist_id)
-            playlist_progress = get_playlist_duration_up_to_track(playback_info.playlist_id, playback_info.track_id) + playback_info.track_progress
+            playlist_progress = (
+                get_playlist_duration_up_to_track(
+                    playback_info.playlist_id, playback_info.track_id
+                )
+                + playback_info.track_progress
+            )
         return PlaylistProgression.model_validate(
             {
                 "playlist_id": playback_info.playlist_id,
-                "playlist_title": playback_info.name,
+                "playlist_title": "test",
                 "playlist_progress": playlist_progress,
                 "playlist_duration": playlist_duration,
             }
         )
-        
+
         return playback_info.model_dump_json()
 
     return music_controller

backend/src/controllers/spotify.py

@@ -1,10 +1,7 @@
-from logging import Logger
 from flask import Blueprint, make_response, request
 from src.dataclasses.playback_info import PlaybackInfo
 from src.dataclasses.playback_request import StartPlaybackRequest
-from src.dataclasses.playlist import Playlist
 from src.spotify import SpotifyClient
-import sys
 
 
 def spotify_controller(spotify: SpotifyClient):

backend/src/database/crud/album.py

@@ -1,5 +1,6 @@
 from typing import List
 from src.database.crud.artist import create_or_update_artist
+from src.database.crud.track import create_track_or_none
 from src.dataclasses.album import Album
 from src.database.models import (
     AlbumArtistRelationship,
@@ -12,10 +13,10 @@
 )
 
 
-def create_album_or_none(album: Album):
+def create_album_or_none(album: Album, ignore_tracks=False):
     if DbAlbum.get_or_none(DbAlbum.id == album.id):
         return
-    album = DbAlbum.create(
+    db_album = DbAlbum.create(
         id=album.id,
         album_type=album.album_type,
         total_tracks=album.total_tracks,
@@ -26,12 +27,15 @@ def create_album_or_none(album: Album):
         label=album.label,
         uri=album.uri,
     )
-    for artist in album.artists:
+    for artist in db_album.artists:
         create_or_update_artist(artist)
         AlbumArtistRelationship.create(album=album.id, artist=artist.id)
-    for genre in album.genres or []:
+    for genre in db_album.genres or []:
         db_genre = DbGenre.get_or_create(name=genre)
         AlbumGenreRelationship.create(album=album.id, genre=db_genre.id)
+    if not ignore_tracks:
+        for track in album.tracks:
+            create_track_or_none(track, album)
 
     return album
 

backend/src/database/crud/playlist.py

@@ -1,5 +1,6 @@
 from typing import List, Optional
 from src.database.crud.album import create_album_or_none
+from src.database.crud.track import create_track_or_none
 from src.database.models import (
     AlbumArtistRelationship,
     AlbumGenreRelationship,
@@ -22,8 +23,8 @@ def get_playlist_by_id_or_none(id: str):
     return DbPlaylist.get_or_none(DbPlaylist.id == id)
 
 
-def create_playlist(playlist: Playlist, albums: List[Album], user: DbUser):
-    playlist = DbPlaylist.create(
+def create_playlist(playlist: Playlist, user: DbUser):
+    db_playlist = DbPlaylist.create(
         id=playlist.id,
         description=playlist.description,
         image_url=playlist.images[0].url if playlist.images else None,
@@ -33,11 +34,25 @@ def create_playlist(playlist: Playlist, albums: List[Album], user: DbUser):
         uri=playlist.uri,
     )
 
-    for album in albums:
-        create_album_or_none(album)
-        PlaylistAlbumRelationship.create(playlist=playlist.id, album=album.id)
-
-    return playlist
+    album_index = 0
+    for track in playlist.tracks.items:
+        create_album_or_none(track.track.album, ignore_tracks=True)
+        if PlaylistAlbumRelationship.get_or_create(
+            playlist=playlist.id,
+            album=track.track.album.id,
+            defaults={"album_index": album_index},
+        )[1]:
+            album_index += 1
+        create_track_or_none(track.track)
+    return db_playlist
+
+
+def delete_playlist(playlist_id: str):
+    query = PlaylistAlbumRelationship.delete().where(
+        PlaylistAlbumRelationship.playlist == playlist_id
+    )
+    query.execute()
+    DbPlaylist.delete_by_id(playlist_id)
 
 
 def update_playlist_info(
@@ -67,25 +82,6 @@ def update_playlist_info(
     return None
 
 
-def update_playlist_with_albums(playlist: Playlist, albums: List[Album]):
-    playlist = DbPlaylist.update(
-        id=playlist.id,
-        description=playlist.description,
-        image_url=playlist.images[0].url if playlist.images else None,
-        name=playlist.name,
-        user_id=playlist.owner.id,
-        snapshot_id=playlist.snapshot_id,
-        uri=playlist.uri,
-    )
-    PlaylistAlbumRelationship.delete().where(playlist=playlist.id)
-
-    for album in albums:
-        create_album_or_none(album)
-        PlaylistAlbumRelationship.create(playlist=playlist.id, album=album.id)
-
-    return playlist
-
-
 def get_user_playlists(
     user_id: str,
     limit: Optional[int] = None,
@@ -304,18 +300,18 @@ def get_playlist_duration(playlist_id):
 
 
 def get_playlist_duration_up_to_track(playlist_id, track_id):
-    # Subquery to get albums in the playlist ordered by album_index
-    albums_in_playlist = (
-        PlaylistAlbumRelationship.select(PlaylistAlbumRelationship.album)
-        .where(PlaylistAlbumRelationship.playlist == playlist_id)
-        .order_by(PlaylistAlbumRelationship.album_index)
-    )
-
-    # Query to get all tracks in those albums, ordered by album_index, disc_number, and track_number
+    print(playlist_id)
+    # Query to get all tracks in the albums of the playlist, with proper joins and ordering
     tracks_in_playlist = (
         DbTrack.select(DbTrack.id, DbTrack.duration_ms)
-        .join(DbAlbum)
-        .where(DbTrack.album.in_(albums_in_playlist))
+        .join(DbAlbum, on=(DbTrack.album == DbAlbum.id))  # Join track with album
+        .join(
+            PlaylistAlbumRelationship,
+            on=(DbTrack.album == PlaylistAlbumRelationship.album),
+        )  # Join to get album_index
+        .where(
+            PlaylistAlbumRelationship.playlist == playlist_id
+        )  # Ensure we're only querying tracks in the specific playlist
         .order_by(
             PlaylistAlbumRelationship.album_index,
             DbTrack.disc_number,
@@ -331,5 +327,5 @@ def get_playlist_duration_up_to_track(playlist_id, track_id):
         total_duration += track.duration_ms
         if track.id == track_id:
             break
-
+    print(total_duration)
     return total_duration