Spaces:
Runtime error
Runtime error
| import requests | |
| import streamlit | |
| from PIL import Image | |
| from utils import * | |
| from app_utils import * | |
| import time | |
| from spotipy.oauth2 import SpotifyClientCredentials | |
| debug = False | |
| dir_path = os.path.dirname(os.path.realpath(__file__)) | |
| st.set_page_config( | |
| page_title="EmotionalPlaylist", | |
| page_icon="🎧", | |
| ) | |
| st.title('Emotional Playlists') | |
| def log_to_spotify(): | |
| st.subheader("Step 1: Connect to your Spotify app") | |
| st.markdown("Log into your Spotify account to let the app create the custom playlist.") | |
| if 'login' not in st.session_state or debug: | |
| if debug: | |
| client_credentials_manager = SpotifyClientCredentials() | |
| sp = spotipy.Spotify(client_credentials_manager=client_credentials_manager) | |
| user_id = None | |
| auth_manager = None | |
| else: | |
| sp, user_id, auth_manager = new_get_client(session=st.session_state) | |
| if sp != None: | |
| legit_genres = sp.recommendation_genre_seeds()['genres'] | |
| st.session_state['login'] = (sp, user_id, legit_genres, auth_manager) | |
| st.success('You are logged in.') | |
| else: | |
| legit_genres = None | |
| else: | |
| sp, user_id, legit_genres, auth_manager = st.session_state['login'] | |
| st.success('You are logged in.') | |
| return sp, user_id, legit_genres, auth_manager | |
| def get_user_playlists(users_links): | |
| global sp | |
| # Scanning users | |
| n_playlists = 0 | |
| all_uris, all_names = [], [] | |
| if users_links != "": | |
| try: | |
| print(users_links) | |
| user_ids = extract_uris_from_links(users_links, url_type='user') | |
| print(user_ids) | |
| all_uris, all_names = get_all_playlists_uris_from_users(sp, user_ids) | |
| n_playlists = len(all_uris) | |
| except: | |
| st.warning('Please enter a valid list of user names (one url per line)') | |
| return all_uris, all_names, n_playlists | |
| def get_filtered_user_playlists(user_links): | |
| global sp | |
| st.spinner(text="Scanning users..") | |
| all_uris, all_names, n_playlists = get_user_playlists(user_links) | |
| if n_playlists <= 1: | |
| return all_uris | |
| else: | |
| with st.expander("##### Select user playlists (default all)"): | |
| # let the user uncheck playlists | |
| st.markdown("Check boxes to select playlists from the selected users." | |
| "Note: to check all, first uncheck all (bug).") | |
| columns = st.columns(np.ones(5)) | |
| with columns[1]: | |
| check_all_playlists = st.button('Check all') | |
| with columns[3]: | |
| uncheck_all_playlists = st.button('Uncheck all') | |
| if 'checkboxes' not in st.session_state.keys(): | |
| st.session_state['checkboxes_playlists'] = [True] * n_playlists | |
| empty_checkboxes = wall_of_checkboxes(all_names, max_width=5) | |
| if check_all_playlists: | |
| st.session_state['checkboxes_playlists'] = [True] * n_playlists | |
| if uncheck_all_playlists: | |
| st.session_state['checkboxes_playlists'] = [False] * n_playlists | |
| for i_emc, emc in enumerate(empty_checkboxes): | |
| st.session_state['checkboxes_playlists'][i_emc] = emc.checkbox(all_names[i_emc], value=st.session_state['checkboxes_playlists'][i_emc]) | |
| filter_playlist = centered_button(st.button, 'Update user playlists', n_columns=5) | |
| if filter_playlist: | |
| return list(np.array(all_uris)[np.where(st.session_state['checkboxes_playlists'])]) | |
| else: | |
| return [] | |
| def get_non_user_playlists(playlist_links): | |
| # Scanning playlists | |
| new_playlist_uris = [] | |
| if playlist_links != "": | |
| st.spinner(text="Scanning playlists..") | |
| try: | |
| new_playlist_uris = extract_uris_from_links(playlist_links, url_type='playlist') | |
| except: | |
| st.warning('Please enter a valid list of playlists (one url per line)') | |
| return new_playlist_uris | |
| def extract_tracks(playlist_uris): | |
| global sp | |
| # extracting tracks | |
| data_tracks = get_all_tracks_from_playlists(sp, playlist_uris, verbose=True) | |
| return data_tracks | |
| def extract_audio_features(data_tracks, legit_genres): | |
| # Extract audio features | |
| all_tracks_uris = np.array(list(data_tracks.keys())) | |
| all_audio_features = [data_tracks[uri]['track']['audio_features'] for uri in all_tracks_uris] | |
| valid_indexes = np.array([i for i in range(len(all_tracks_uris)) if all_audio_features[i] is not None]) | |
| all_tracks_uris = all_tracks_uris[valid_indexes] | |
| all_audio_features = np.array(all_audio_features)[valid_indexes] | |
| all_tracks_audio_features = dict(zip(relevant_audio_features, [[audio_f[k] for audio_f in all_audio_features] for k in relevant_audio_features])) | |
| all_tracks_genres = [] | |
| indexes_by_genre = dict() | |
| for index, uri in enumerate(all_tracks_uris): | |
| track = data_tracks[uri] | |
| track_genres = track['track']['genres'] | |
| all_tracks_genres.append([]) | |
| for glabel in track_genres: | |
| legit_genre = find_legit_genre(glabel, legit_genres) | |
| if legit_genre in indexes_by_genre.keys(): | |
| indexes_by_genre[legit_genre].append(index) | |
| else: | |
| indexes_by_genre[legit_genre] = [index] | |
| all_tracks_genres[-1].append(legit_genre) | |
| all_tracks_genres[-1] = sorted(set(all_tracks_genres[-1])) | |
| genres_labels = sorted(indexes_by_genre.keys()) | |
| all_tracks_genres = np.array(all_tracks_genres) | |
| return all_tracks_uris, all_tracks_audio_features, all_tracks_genres, indexes_by_genre, genres_labels | |
| # st.session_state['music_extracted'] = dict(all_tracks_uris=all_tracks_uris, | |
| # all_tracks_audio_features=all_tracks_audio_features, | |
| # genres=genres, | |
| # genres_labels=genres_labels) | |
| def select_songs(legit_genres): | |
| global sp | |
| st.subheader("Step 2: Select candidate songs") | |
| st.markdown("This can be done in two ways: \n" | |
| "1. Get songs from a list of users (and their playlists)\n" | |
| "2. Get songs from a list of playlists.\n" | |
| "For this you'll need to collect user and/or playlist urls by clicking on \"Share\" and \"Copy link\" in the Spotify app.") | |
| users_playlists = "Add a list of user urls, one per line (optional)" | |
| users_links = st.text_area(users_playlists, value="") | |
| label_playlists = "Add a list of playlists urls, one per line (optional)" | |
| playlist_links = st.text_area(label_playlists, value="https://open.spotify.com/playlist/1H7a4q8JZArMQiidRy6qon\nhttps://open.spotify.com/playlist/6wbaZqht4w6CMv3od5taax?si=5c6ebe13fdd049b6") | |
| extract_button = centered_button(st.button, 'Extract music', n_columns=5) | |
| all_tracks_uris, all_tracks_audio_features, all_tracks_genres, indexes_by_genre, genres_labels = [None] * 5 | |
| updated_sources = False | |
| if extract_button or debug or 'extract_button' in st.session_state.keys(): | |
| if extract_button: | |
| updated_sources = True | |
| st.session_state['extract_button'] = True | |
| # check the user input music sourc | |
| if playlist_links == "" and users_links == "": | |
| st.warning('Please enter at least one source of music.') | |
| else: | |
| st.spinner(text="Scanning music sources..") | |
| playlist_uris = [] | |
| init_time = time.time() | |
| init_time_tot = init_time | |
| user_playlists = get_filtered_user_playlists(users_links) | |
| playlist_uris += user_playlists | |
| print(f'1. user playlist: {time.time() - init_time:.2f}') | |
| init_time = time.time() | |
| new_playlist_uris = get_non_user_playlists(playlist_links) | |
| playlist_uris += new_playlist_uris | |
| n_users = len(users_links.split('\n')) | |
| st.success(f'{len(playlist_uris)} new playlists added from {n_users} users.') | |
| print(f'2. non user playlist: {time.time() - init_time:.2f}') | |
| init_time = time.time() | |
| if str(playlist_uris) in st.session_state.keys(): | |
| data_tracks = st.session_state[str(playlist_uris)] | |
| else: | |
| data_tracks = extract_tracks(playlist_uris) | |
| st.session_state[str(playlist_uris)] = data_tracks | |
| print(f'3. track extraction: {time.time() - init_time:.2f}') | |
| init_time = time.time() | |
| if len(data_tracks.keys()) < 10: | |
| st.warning('Please select more music sources.') | |
| else: | |
| all_tracks_uris, all_tracks_audio_features, all_tracks_genres, indexes_by_genre, genres_labels = extract_audio_features(data_tracks, legit_genres) | |
| print(f'4. audio feature extraction: {time.time() - init_time:.2f}') | |
| print(f'\t total extraction: {time.time() - init_time_tot:.2f}') | |
| st.success(f'{len(data_tracks.keys())} tracks found!') | |
| return all_tracks_uris, all_tracks_audio_features, all_tracks_genres, indexes_by_genre, genres_labels, updated_sources | |
| def customize_widgets(genres_labels, updated_sources): | |
| st.subheader("Step 3: Customize it!") | |
| st.markdown('##### Which genres?') | |
| expanded = True if 'expanded_genres' in st.session_state else False | |
| with st.expander("Unroll to select (default all)", expanded=expanded): | |
| st.session_state['expanded_genres'] = True | |
| st.markdown("Check boxes to select genres. Note: to check all, first uncheck all (bug).") | |
| columns = st.columns(np.ones(5)) | |
| with columns[1]: | |
| check_all = st.button('Check all') | |
| with columns[3]: | |
| uncheck_all = st.button('Uncheck all') | |
| if 'checkboxes' not in st.session_state.keys() or updated_sources: | |
| st.session_state['checkboxes'] = [True] * len(genres_labels) | |
| updated_sources = False | |
| empty_checkboxes = wall_of_checkboxes(genres_labels, max_width=5) | |
| if check_all: | |
| st.session_state['checkboxes'] = [True] * len(genres_labels) | |
| if uncheck_all: | |
| st.session_state['checkboxes'] = [False] * len(genres_labels) | |
| for i_emc, emc in enumerate(empty_checkboxes): | |
| st.session_state['checkboxes'][i_emc] = emc.checkbox(genres_labels[i_emc], value=st.session_state['checkboxes'][i_emc]) | |
| st.markdown("##### What's the mood?") | |
| valence = st.slider('Valence (0 negative, 100 positive)', min_value=0, max_value=100, value=60, step=1) / 100 | |
| energy = st.slider('Energy (0 low, 100 high)', min_value=0, max_value=100, value=60, step=1) / 100 | |
| danceability = st.slider('Danceability (0 low, 100 high)', min_value=0, max_value=100, value=60, step=1) / 100 | |
| target_mood = np.array([valence, energy, danceability]).reshape(1, 3) | |
| streamlit.markdown('##### Shall we explore?') | |
| streamlit.write("Set the strength of music exploration:\n" | |
| "* 0%: all songs are selected from the music sources\n" | |
| "* 100%: all songs are new.") | |
| exploration = st.slider('Exploration (0%, 100%)', min_value=0, max_value=100, value=50, step=1) / 100 | |
| return target_mood, exploration | |
| def filter_songs_by_genre(checkboxes, genres_labels, indexes_by_genre): | |
| # filter songs by genres | |
| selected_labels = [genres_labels[i] for i in range(len(genres_labels)) if checkboxes[i]] | |
| genre_selected_indexes = [] | |
| for label in selected_labels: | |
| genre_selected_indexes += indexes_by_genre[label] | |
| genre_selected_indexes = np.array(sorted(set(genre_selected_indexes))) | |
| return genre_selected_indexes | |
| def find_best_songs_for_mood(all_tracks_audio_features, genre_selected_indexes, target_mood): | |
| candidate_moods = np.array([np.array(all_tracks_audio_features[feature])[genre_selected_indexes] for feature in ['valence', 'energy', 'danceability']]).T | |
| distances = np.sqrt(((candidate_moods - target_mood) ** 2).sum(axis=1)) | |
| min_dist_indexes = np.argsort(distances) | |
| n_candidates = distances.shape[0] | |
| return min_dist_indexes, n_candidates | |
| def run_exploration(selected_tracks_uris, selected_tracks_genres, playlist_length, exploration, all_tracks_uris, target_mood, selected_genres): | |
| # sample exploration songs | |
| if exploration > 0: | |
| n_known = int(playlist_length * (1 - exploration)) | |
| n_new = playlist_length - n_known | |
| print(f'Number of new songs: {n_new}, known songs: {n_known}') | |
| known_songs = selected_tracks_uris[:n_known] | |
| seed_songs = selected_tracks_uris[-n_new:] | |
| seed_genres = selected_tracks_genres[-n_new:] | |
| dict_args = dict() # enforce bounds on recommendations' moods | |
| for i_m, m in enumerate(['valence', 'energy', 'danceability']): | |
| dict_args[f'min_{m}'] = max(0, target_mood[i_m] - 0.1) | |
| dict_args[f'max_{m}'] = min(1, target_mood[i_m] + 0.1) | |
| dict_args_loose = dict() # enforce bounds on recommendations' moods | |
| for i_m, m in enumerate(['valence', 'energy', 'danceability']): | |
| dict_args_loose[f'min_{m}'] = max(0, target_mood[i_m] - 0.2) | |
| dict_args_loose[f'max_{m}'] = min(1, target_mood[i_m] + 0.2) | |
| dict_args_looser = dict() # enforce bounds on recommendations' moods | |
| for i_m, m in enumerate(['valence', 'energy', 'danceability']): | |
| dict_args_loose[f'min_{m}'] = max(0, target_mood[i_m] - 0.3) | |
| dict_args_loose[f'max_{m}'] = min(1, target_mood[i_m] + 0.3) | |
| new_songs = [] | |
| counter_seed = 0 | |
| print(selected_genres) | |
| while len(new_songs) < n_new: | |
| try: | |
| print(seed_songs[counter_seed]) | |
| print(dict_args) | |
| np.random.shuffle(selected_genres) | |
| reco = sp.recommendations(seed_tracks=[seed_songs[counter_seed]], seed_genres=selected_genres, | |
| market="from_token", country='from_token', **dict_args)['tracks'] | |
| if len(reco) == 0: | |
| print('Using loose bounds') | |
| np.random.shuffle(selected_genres) | |
| reco = sp.recommendations(seed_tracks=[seed_songs[counter_seed]], seed_genres=selected_genres, | |
| market="from_token", country='from_token', **dict_args_loose)['tracks'] | |
| if len(reco) == 0: | |
| print('Using looser bounds') | |
| np.random.shuffle(selected_genres) | |
| reco = sp.recommendations(seed_tracks=[seed_songs[counter_seed]], seed_genres=selected_genres, | |
| market="from_token", country='from_token', **dict_args_looser)['tracks'] | |
| if len(reco) == 0: | |
| print('Removing bounds') | |
| reco = sp.recommendations(seed_tracks=[seed_songs[counter_seed]], market="from_token")['tracks'] | |
| assert len(reco) > 0 | |
| for r in reco: | |
| if r['uri'] not in all_tracks_uris and r['uri'] not in new_songs: | |
| new_songs.append(r['uri']) | |
| break | |
| except: | |
| pass | |
| print(counter_seed, len(new_songs)) | |
| counter_seed = (counter_seed + 1) % len(seed_songs) | |
| assert len(new_songs) == n_new | |
| assert len(known_songs) == n_known | |
| selected_tracks_uris = np.array(list(known_songs) + new_songs) | |
| np.random.shuffle(selected_tracks_uris) | |
| return selected_tracks_uris | |
| def sample_playlist(n_candidates, playlist_length, genre_selected_indexes, min_dist_indexes, all_tracks_uris, all_tracks_genres): | |
| # give more freedom to randomize the playlist | |
| if n_candidates > 5 * playlist_length: | |
| selected_tracks_indexes = genre_selected_indexes[min_dist_indexes[:int(playlist_length * 2)]] | |
| else: | |
| selected_tracks_indexes = genre_selected_indexes[min_dist_indexes[:playlist_length]] | |
| shuffled_indexes = np.arange(len(selected_tracks_indexes)) | |
| np.random.shuffle(shuffled_indexes) | |
| selected_tracks_uris = all_tracks_uris[selected_tracks_indexes][shuffled_indexes] | |
| selected_tracks_genres = all_tracks_genres[selected_tracks_indexes][shuffled_indexes] | |
| selected_tracks_uris = selected_tracks_uris[:playlist_length] | |
| selected_tracks_genres = selected_tracks_genres[:playlist_length] | |
| return selected_tracks_uris, selected_tracks_genres | |
| def run_app(): | |
| global sp | |
| setup_credentials() | |
| image = Image.open(dir_path + '/image.png') | |
| st.image(image) | |
| st.markdown("This app let's you quickly build playlists in a customized way: ") | |
| st.markdown("* **It's easy**: you won't have to add songs one by one,\n" | |
| "* **You're in control**: you provide the source of songs, select genres and pick the mood,\n" | |
| "* **You're free to explore**: set the exploration strength from no new songs to all new songs.") | |
| sp, user_id, legit_genres, auth_manager = log_to_spotify() | |
| if 'login' in st.session_state or debug: | |
| all_tracks_uris, all_tracks_audio_features, all_tracks_genres, indexes_by_genre, genres_labels, updated_sources = select_songs(legit_genres) | |
| if all_tracks_uris is not None: | |
| target_mood, exploration = customize_widgets(genres_labels, updated_sources) | |
| custom_button = centered_button(st.button, 'Run customization', n_columns=5) | |
| if custom_button or 'run_custom' in st.session_state.keys() or debug: | |
| st.session_state['run_custom'] = True | |
| checkboxes = st.session_state['checkboxes'].copy() | |
| selected_genres = [genres_labels[i] for i in range(len(genres_labels)) if checkboxes[i] and genres_labels[i] != 'unknown'] | |
| init_time = time.time() | |
| genre_selected_indexes = filter_songs_by_genre(checkboxes, genres_labels, indexes_by_genre) | |
| if len(genre_selected_indexes) < 10: | |
| genre_selected_indexes = None | |
| st.warning('Please select more genres or add more music sources.') | |
| else: | |
| st.success(f'{len(genre_selected_indexes)} candidate tracks selected.') | |
| print(f'6. filter by genre: {time.time() - init_time:.2f}') | |
| init_time = time.time() | |
| if genre_selected_indexes is not None: | |
| min_dist_indexes, n_candidates = find_best_songs_for_mood(all_tracks_audio_features, genre_selected_indexes, target_mood) | |
| print(f'7. filter by mood: {time.time() - init_time:.2f}') | |
| init_time = time.time() | |
| if n_candidates < 25: | |
| st.warning('Please add more music sources or select more genres.') | |
| else: | |
| playlist_length = st.number_input(f'Pick a playlist length, given {n_candidates} candidates.', min_value=5, | |
| value=min(10, n_candidates//3), max_value=n_candidates//3) | |
| selected_tracks_uris, selected_tracks_genres = sample_playlist(n_candidates, playlist_length, genre_selected_indexes, | |
| min_dist_indexes, all_tracks_uris, all_tracks_genres) | |
| print(f'8. Sample songs: {time.time() - init_time:.2f}') | |
| init_time = time.time() | |
| playlist_name = st.text_input('Playlist name', value='Mood Playlist') | |
| if playlist_name == '': | |
| st.warning('Please enter a playlist name.') | |
| else: | |
| generation_button = centered_button(st.button, 'Generate playlist', n_columns=5) | |
| if generation_button: | |
| selected_tracks_uris = run_exploration(selected_tracks_uris, selected_tracks_genres, playlist_length, exploration, all_tracks_uris, | |
| target_mood.flatten(), selected_genres) | |
| print(f'9. run exploration: {time.time() - init_time:.2f}') | |
| init_time = time.time() | |
| target_mood = np.array(target_mood).flatten() * 100 | |
| description = f'Emotion Playlist for Valence: {int(target_mood[0])}, ' \ | |
| f'Energy: {int(target_mood[1])}, ' \ | |
| f'Danceability: {int(target_mood[2])}). ' \ | |
| f'Playlist generated by the EmotionPlaylist app: https://huggingface.co/spaces/ccolas/EmotionPlaylist.' | |
| playlist_info = sp.user_playlist_create(user_id, playlist_name, public=True, collaborative=False, description=description) | |
| playlist_uri = playlist_info['uri'].split(':')[-1] | |
| sp.playlist_add_items(playlist_uri, selected_tracks_uris) | |
| st.write( | |
| f""" | |
| <html> | |
| <body> | |
| <center> | |
| <iframe style = "border-radius:12px" src="https://open.spotify.com/embed/playlist/{playlist_uri}" allowtransparency="true" | |
| allow="encrypted-media" width="80%" height="580" frameborder="0"></iframe></center></body></html> | |
| """, unsafe_allow_html=True) | |
| st.success(f'The playlist has been generated, find it [here](https://open.spotify.com/playlist/{playlist_uri}).') | |
| stop = 1 | |
| if __name__ == '__main__': | |
| run_app() |