Upload 3 files

Add usage of Spotify API

01_Recommend_from_Song🎤.py

@@ -0,0 +1,147 @@
+import spotipy
+import streamlit as st
+import numpy as np
+from spotipy.oauth2 import SpotifyClientCredentials
+from PIL import Image
+import requests
+import pandas as pd
+
+st.set_page_config(
+    page_title="Find Songs Similar to Yours🎤", page_icon="🎤", layout="wide"
+)
+
+# Spotify API
+SPOTIPY_CLIENT_ID = st.secrets.spot_creds.spot_client_id
+SPOTIPY_CLIENT_SECRET = st.secrets.spot_creds.spot_client_secret
+
+sp = spotipy.Spotify(
+    auth_manager=SpotifyClientCredentials(
+        client_id=SPOTIPY_CLIENT_ID, client_secret=SPOTIPY_CLIENT_SECRET
+    )
+)
+
+"""
+# Analyze Song and Get Recommendations🎤
+
+Input a song title and the app will return recommendations as well as the features of the song.
+
+Data is obtained using the Python library [Spotipy](https://spotipy.readthedocs.io/en/2.18.0/) that uses [Spotify Web API.](https://developer.spotify.com/documentation/web-api/)
+
+"""
+song = st.text_input("Enter a song title", value="Somebody Else")
+search = sp.search(q="track:" + song, type="track")
+
+
+class GetSongInfo:
+    def __init__(self, search):
+        self.search = search
+
+    def song_id(self):
+        song_id = search["tracks"]["items"][0]["id"]  # -gets song id
+        return song_id
+
+    def song_album(self):
+        song_album = search["tracks"]["items"][0]["album"][
+            "name"
+        ]  # -gets song album name
+        return song_album
+
+    def song_image(self):
+        song_image = search["tracks"]["items"][0]["album"]["images"][0][
+            "url"
+        ]  # -gets song image URL
+        return song_image
+
+    def song_artist_name(self):
+        song_artist_name = search["tracks"]["items"][0]["artists"][0][
+            "name"
+        ]  # -gets artist for song
+        return song_artist_name
+
+    def song_name(self):
+        song_name = search["tracks"]["items"][0]["name"]  # -gets song name
+        return song_name
+
+    def song_preview(self):
+        song_preview = search["tracks"]["items"][0]["preview_url"]
+        return song_preview
+
+
+songs = GetSongInfo(song)
+
+###
+
+
+def url(song):
+    url_to_song = "https://open.spotify.com/track/" + songs.song_id()
+    st.write(
+        f"Link to stream '{songs.song_name()}' by {songs.song_artist_name()} on Spotify: {url_to_song}"
+    )
+
+
+# Set up two-column layout for Streamlit app
+image, stats = st.columns(2)
+
+with image:
+    try:
+        url(song)
+        r = requests.get(songs.song_image())
+        open("img/" + songs.song_id() + ".jpg", "w+b").write(r.content)
+        image_album = Image.open("img/" + songs.song_id() + ".jpg")
+        st.image(
+            image_album,
+            caption=f"{songs.song_artist_name()} - {songs.song_album()}",
+            use_column_width="auto",
+        )
+
+        feat = sp.audio_features(tracks=[songs.song_id()])
+        features = feat[0]
+        p = pd.Series(features).to_frame()
+        data_feat = p.loc[
+            [
+                "acousticness",
+                "danceability",
+                "energy",
+                "liveness",
+                "speechiness",
+                "valence",
+            ]
+        ]
+        bpm = p.loc[["tempo"]]
+        values = bpm.values[0]
+        bpms = values.item()
+        ticks = np.linspace(0, 1, 11)
+
+        plot = data_feat.plot.barh(
+            xticks=ticks, legend=False, color="limegreen"
+        )  # Use Pandas plot
+        plot.set_xlabel("Value")
+        plot.set_ylabel("Parameters")
+        plot.set_title(f"Analysing '{songs.song_name()}' by {songs.song_artist_name()}")
+        plot.invert_yaxis()
+        st.pyplot(plot.figure)
+        st.subheader(f"BPM (Beats Per Minute): {bpms}")
+
+        st.warning(
+            "Note: Audio previews may have very high default volume and will reset after page refresh"
+        )
+        st.audio(songs.song_preview(), format="audio/wav")
+
+    except IndexError or NameError:
+        st.error(
+            "This error is possibly due to the API being unable to find the song. Maybe try to retype it using the song title followed by artist without any hyphens (e.g. In my Blood Shawn Mendes)"
+        )
+
+# Recommendations
+with stats:
+    st.subheader("You might also like")
+
+    reco = sp.recommendations(
+        seed_artists=None, seed_tracks=[songs.song_id()], seed_genres=[], limit=10
+    )
+
+    for i in reco["tracks"]:
+        st.write(f"\"{i['name']}\" - {i['artists'][0]['name']}")
+        image_reco = requests.get(i["album"]["images"][2]["url"])
+        open("img/" + i["id"] + ".jpg", "w+b").write(image_reco.content)
+        st.image(Image.open("img/" + i["id"] + ".jpg"))

02_Recommend_from_Genre_Features🎸.py

@@ -0,0 +1,175 @@
+import streamlit as st
+
+# Configure Streamlit page
+st.set_page_config(
+    page_title="Find the Song that You Like🎸", page_icon="🎸", layout="wide"
+)
+
+import pandas as pd
+import plotly.express as px
+import streamlit.components.v1 as components
+from sklearn.neighbors import NearestNeighbors
+
+
+@st.cache(allow_output_mutation=True)
+def data_import():
+    """Function for loading in cleaned data csv file."""
+    df = pd.read_csv("data/clean_data.csv")
+    df["genres"] = df.genres.apply(
+        lambda x: [i[1:-1] for i in str(x)[1:-1].split(", ")]
+    )
+    df_explode = df.explode("genres")
+    return df_explode
+
+
+genre_names = [
+    "Dance Pop",
+    "Electronic",
+    "Electropop",
+    "Hip Hop",
+    "Jazz",
+    "K-pop",
+    "Latin",
+    "Pop",
+    "Pop Rap",
+    "R&B",
+    "Rock",
+]
+audio_params = [
+    "acousticness",
+    "danceability",
+    "energy",
+    "instrumentalness",
+    "valence",
+    "tempo",
+]
+
+df_explode = data_import()
+
+
+def match_song(genre, yr_start, yr_end, test_feat):
+    """Function for finding similar songs with KNN algorithm."""
+    genre = genre.lower()
+    genre_data = df_explode[
+        (df_explode["genres"] == genre)
+        & (df_explode["release_year"] >= yr_start)
+        & (df_explode["release_year"] <= yr_end)
+    ]
+    genre_data = genre_data.sort_values(by="popularity", ascending=False)[:500]
+
+    # Load KNN from SkLearn
+    neigh = NearestNeighbors()
+    neigh.fit(genre_data[audio_params].to_numpy())
+
+    n_neighbors = neigh.kneighbors(
+        [test_feat], n_neighbors=len(genre_data), return_distance=False
+    )[0]
+
+    uris = genre_data.iloc[n_neighbors]["uri"].tolist()
+    audios = genre_data.iloc[n_neighbors][audio_params].to_numpy()
+
+    return uris, audios
+
+
+# Setup page order
+def page():
+    title = "Find Your Song🎸"
+    st.title(title)
+
+    st.write(
+        "Get recommended songs on Spotify based on genre and key audio parameters."
+    )
+    st.markdown("##")
+
+    # Streamlit column layout
+    with st.container():
+        col1, col2, col3, col4 = st.columns((2, 0.5, 0.5, 0.5))
+
+        with col3:
+            st.markdown("***Select genre:***")
+            genre = st.radio("", genre_names, index=genre_names.index("Rock"))
+
+        with col1:
+            st.markdown("***Select audio parameters to customize:***")
+            yr_start, yr_end = st.slider(
+                "Select the year range", 1908, 2022, (1980, 2022)
+            )
+            acousticness = st.slider("Acousticness", 0.0, 1.0, 0.5)
+            danceability = st.slider("Danceability", 0.0, 1.0, 0.5)
+            energy = st.slider("Energy", 0.0, 1.0, 0.5)
+            instrumentalness = st.slider("Instrumentalness", 0.0, 1.0, 0.5)
+            valence = st.slider("Valence", 0.0, 1.0, 0.45)
+            tempo = st.slider("Tempo", 0.0, 244.0, 125.01)
+
+    pr_page_tracks = 6
+    test_feat = [acousticness, danceability, energy, instrumentalness, valence, tempo]
+    uris, audios = match_song(genre, yr_start, yr_end, test_feat)
+
+    tracks = []
+    for uri in uris:
+        track = """<iframe src="https://open.spotify.com/embed/track/{}" width="280" height="400" frameborder="0" allowtransparency="true" allow="encrypted-media"></iframe>""".format(
+            uri
+        )
+        tracks.append(track)
+
+    if "previous_inputs" not in st.session_state:
+        st.session_state["previous_inputs"] = [genre, yr_start, yr_end] + test_feat
+
+    current_inputs = [genre, yr_start, yr_end] + test_feat
+    if current_inputs != st.session_state["previous_inputs"]:
+        if "start_track_i" in st.session_state:
+            st.session_state["start_track_i"] = 0
+
+        st.session_state["previous_inputs"] = current_inputs
+
+    if "start_track_i" not in st.session_state:
+        st.session_state["start_track_i"] = 0
+
+    with st.container():
+        col1, col2, col3 = st.columns([2, 1, 2])
+        if st.button("More Songs"):
+            if st.session_state["start_track_i"] < len(tracks):
+                st.session_state["start_track_i"] += pr_page_tracks
+
+        current_tracks = tracks[
+            st.session_state["start_track_i"] : st.session_state["start_track_i"]
+            + pr_page_tracks
+        ]
+        current_audios = audios[
+            st.session_state["start_track_i"] : st.session_state["start_track_i"]
+            + pr_page_tracks
+        ]
+        if st.session_state["start_track_i"] < len(tracks):
+            for i, (track, audio) in enumerate(zip(current_tracks, current_audios)):
+                if i % 2 == 0:
+                    with col1:
+                        components.html(
+                            track,
+                            height=400,
+                        )
+                        with st.expander("Display Chart"):
+                            df = pd.DataFrame(dict(r=audio[:5], theta=audio_params[:5]))
+                            fig = px.line_polar(
+                                df, r="r", theta="theta", line_close=True
+                            )
+                            fig.update_layout(height=400, width=340)
+                            st.plotly_chart(fig)
+
+                else:
+                    with col3:
+                        components.html(
+                            track,
+                            height=400,
+                        )
+                        with st.expander("Display Chart"):
+                            df = pd.DataFrame(dict(r=audio[:5], theta=audio_params[:5]))
+                            fig = px.line_polar(
+                                df, r="r", theta="theta", line_close=True
+                            )
+                            fig.update_layout(height=400, width=340)
+                            st.plotly_chart(fig)
+        else:
+            st.write("No more songs")
+
+
+page()

Introduction🎶.py

@@ -0,0 +1,33 @@
+import streamlit as st
+from streamlit import session_state as session
+
+# Configure Streamlit page
+st.set_page_config(page_title="Song Recommender🎶", page_icon="🎶")
+
+st.title("Song Recommender🎶")
+st.markdown("Click on '**Recommend from Song🎤**' from the side panel to get recommended songs via the Spotify API.")
+st.markdown("**How does '**Recommend from Genre Features🎸**' work?**")
+st.markdown(
+    "The songs come from the [Spotify and Genius Track Dataset](https://www.kaggle.com/datasets/saurabhshahane/spotgen-music-dataset) on Kaggle. The [k-Nearest Neighbor algorithm](https://scikit-learn.org/stable/modules/neighbors.html) is used to obtain recommendations, i.e., the top songs which are closest in distance to the set of parameter inputs specified by you."
+)
+
+st.markdown("This app will recommend you songs based on the characteristics below.")
+st.markdown(
+    """  
+            **Acousticness**: A metric describing the 'acousticness' of a song. 1.0 represents high confidence the song is acoustic.<br>
+            
+            **Danceability**: Describes a song's suitability for dancing based on combination of elements including tempo, rhythm stability, beat strength, and overall regularity. 
+                        0.0 is least danceable and 1.0 is most danceable.<br>
+
+            **Energy**: Measure of intensity and activity. Often, energetic songs feel fast, loud, and noisy.<br>
+
+            **Liveness**: A metric describing the likelihood that a track is a recording of a live performance.<br>
+
+            **Speechiness**: How much lyrics the track contains.<br>
+
+            **Valence**: A metric ranging from 0.0 to 1.0 describing the positivity conveyed by a track.<br>
+            
+            Source: [Spotify Web API](https://developer.spotify.com/documentation/web-api/reference)
+            """,
+    unsafe_allow_html=True,
+)