Duplicate from hf-hackathon-2023-01/Spotify

Co-authored-by: Simon Brandeis <[email protected]>

.gitattributes

@@ -0,0 +1,34 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,13 @@
+---
+title: Spotify
+emoji: 🎶
+colorFrom: green
+colorTo: yellow
+sdk: gradio
+sdk_version: 3.16.1
+app_file: app.py
+pinned: false
+duplicated_from: hf-hackathon-2023-01/Spotify
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,327 @@
+import json
+from urllib import request
+from fastapi import FastAPI
+from starlette.middleware.sessions import SessionMiddleware
+from starlette.responses import HTMLResponse, RedirectResponse
+from starlette.requests import Request
+import gradio as gr
+import uvicorn
+from fastapi.responses import HTMLResponse
+from fastapi.responses import RedirectResponse
+import pandas as pd
+
+import spotipy
+from spotipy import oauth2
+
+import heatmap
+
+import numpy as np
+
+import matplotlib.pyplot as plt
+from matplotlib.patches import Circle, RegularPolygon
+from matplotlib.path import Path
+from matplotlib.projections.polar import PolarAxes
+from matplotlib.projections import register_projection
+from matplotlib.spines import Spine
+from matplotlib.transforms import Affine2D
+import matplotlib
+
+matplotlib.use('SVG')
+
+
+def get_features2(spotify):
+    features = []
+    for index in range(0, 10):
+        results = spotify.current_user_saved_tracks(offset=index*50, limit=50)
+        track_ids = [item['track']['id'] for item in results['items']]
+        features.extend(spotify.audio_features(track_ids))
+
+    df = pd.DataFrame(data=features)
+    names = [
+        'danceability',
+        'energy',
+        # 'loudness',
+        'speechiness',
+        'acousticness',
+        'instrumentalness',
+        'liveness',
+        'valence',
+    ]
+    features_means = df[names].mean()
+    return names, features_means.values
+
+
+def radar_factory(num_vars, frame='circle'):
+    """
+    Create a radar chart with `num_vars` axes.
+
+    This function creates a RadarAxes projection and registers it.
+
+    Parameters
+    ----------
+    num_vars : int
+        Number of variables for radar chart.
+    frame : {'circle', 'polygon'}
+        Shape of frame surrounding axes.
+
+    """
+    # calculate evenly-spaced axis angles
+    theta = np.linspace(0, 2*np.pi, num_vars, endpoint=False)
+
+    class RadarTransform(PolarAxes.PolarTransform):
+
+        def transform_path_non_affine(self, path):
+            # Paths with non-unit interpolation steps correspond to gridlines,
+            # in which case we force interpolation (to defeat PolarTransform's
+            # autoconversion to circular arcs).
+            if path._interpolation_steps > 1:
+                path = path.interpolated(num_vars)
+            return Path(self.transform(path.vertices), path.codes)
+
+    class RadarAxes(PolarAxes):
+
+        name = 'radar'
+        PolarTransform = RadarTransform
+
+        def __init__(self, *args, **kwargs):
+            super().__init__(*args, **kwargs)
+            # rotate plot such that the first axis is at the top
+            self.set_theta_zero_location('N')
+
+        def fill(self, *args, closed=True, **kwargs):
+            """Override fill so that line is closed by default"""
+            return super().fill(closed=closed, *args, **kwargs)
+
+        def plot(self, *args, **kwargs):
+            """Override plot so that line is closed by default"""
+            lines = super().plot(*args, **kwargs)
+            for line in lines:
+                self._close_line(line)
+
+        def _close_line(self, line):
+            x, y = line.get_data()
+            # FIXME: markers at x[0], y[0] get doubled-up
+            if x[0] != x[-1]:
+                x = np.append(x, x[0])
+                y = np.append(y, y[0])
+                line.set_data(x, y)
+
+        def set_varlabels(self, labels):
+            self.set_thetagrids(np.degrees(theta), labels)
+
+        def _gen_axes_patch(self):
+            # The Axes patch must be centered at (0.5, 0.5) and of radius 0.5
+            # in axes coordinates.
+            if frame == 'circle':
+                return Circle((0.5, 0.5), 0.5)
+            elif frame == 'polygon':
+                return RegularPolygon((0.5, 0.5), num_vars,
+                                      radius=.5, edgecolor="k")
+            else:
+                raise ValueError("Unknown value for 'frame': %s" % frame)
+
+        def _gen_axes_spines(self):
+            if frame == 'circle':
+                return super()._gen_axes_spines()
+            elif frame == 'polygon':
+                # spine_type must be 'left'/'right'/'top'/'bottom'/'circle'.
+                spine = Spine(axes=self,
+                              spine_type='circle',
+                              path=Path.unit_regular_polygon(num_vars))
+                # unit_regular_polygon gives a polygon of radius 1 centered at
+                # (0, 0) but we want a polygon of radius 0.5 centered at (0.5,
+                # 0.5) in axes coordinates.
+                spine.set_transform(Affine2D().scale(.5).translate(.5, .5)
+                                    + self.transAxes)
+                return {'polar': spine}
+            else:
+                raise ValueError("Unknown value for 'frame': %s" % frame)
+
+    register_projection(RadarAxes)
+    return theta
+
+def get_spider_plot(request: gr.Request):
+    token = request.request.session.get('token')
+    sp = spotipy.Spotify(token)
+    names, data = get_features2(sp)
+
+    theta = radar_factory(len(names), frame='polygon')
+
+    fig = plt.figure(figsize=(9, 9))
+    ax = fig.add_axes([0, 0, 1, 1], projection='radar')
+
+    # Plot the four cases from the example data on separate axes
+    title = 'test'
+    ax.set_rgrids([0.2, 0.4, 0.6, 0.8])
+    ax.set_title(title, weight='bold', size='medium', position=(0.5, 1.1),
+                    horizontalalignment='center', verticalalignment='center')
+
+    ax.plot(theta, data)
+    ax.fill(theta, data, alpha=0.25, label='_nolegend_')
+
+    ax.set_varlabels(names)
+
+    return fig
+
+
+PORT_NUMBER = 8080
+SPOTIPY_CLIENT_ID = 'c087fa97cebb4f67b6f08ba841ed8378'
+SPOTIPY_CLIENT_SECRET = 'ae27d6916d114ac4bb948bb6c58a72d9'
+SPOTIPY_REDIRECT_URI = 'https://hf-hackathon-2023-01-spotify.hf.space'
+SCOPE = 'ugc-image-upload user-read-playback-state user-modify-playback-state user-read-currently-playing app-remote-control streaming playlist-read-private playlist-read-collaborative playlist-modify-private playlist-modify-public user-follow-modify user-follow-read user-read-playback-position user-top-read user-read-recently-played user-library-modify user-library-read user-read-email user-read-private'
+
+sp_oauth = oauth2.SpotifyOAuth(SPOTIPY_CLIENT_ID, SPOTIPY_CLIENT_SECRET, SPOTIPY_REDIRECT_URI, scope=SCOPE)
+
+app = FastAPI()
+app.add_middleware(SessionMiddleware, secret_key="w.o.w")
+
+@app.get('/', response_class=HTMLResponse)
+async def homepage(request: Request):
+    token = request.session.get('token')
+    if token:
+        return RedirectResponse("/gradio")
+
+    url = str(request.url)
+    code = sp_oauth.parse_response_code(url)
+    if code != url:
+        token_info = sp_oauth.get_access_token(code)
+        request.session['token'] = token_info['access_token']
+        return RedirectResponse("/gradio")
+
+    auth_url = sp_oauth.get_authorize_url()
+    return "<a href='" + auth_url + "'>Login to Spotify</a>"
+
+
+
+from vega_datasets import data
+
+iris = data.iris()
+
+
+def scatter_plot_fn_energy(request: gr.Request):
+
+    token = request.request.session.get('token')
+    if token:
+        sp = spotipy.Spotify(token)
+        results = sp.current_user()
+        print(results)
+    df = get_features(sp)
+    return gr.ScatterPlot(
+        value=df,
+        x="danceability",
+        y="energy"
+    )
+
+def scatter_plot_fn_liveness(request: gr.Request):
+    token = request.request.session.get('token')
+    if token:
+        sp = spotipy.Spotify(token)
+        results = sp.current_user()
+        print(results)
+    df = get_features(sp)
+    print(df)
+    return gr.ScatterPlot(
+        value=df,
+        x="acousticness",
+        y="liveness"
+    )
+
+def heatmap_plot_fn(request: gr.Request):
+    token = request.request.session.get('token')
+    if token:
+        sp = spotipy.Spotify(token)
+        data = heatmap.build_heatmap(heatmap.fetch_recent_songs(sp))
+        fig, ax = heatmap.plot(data)
+        return fig
+
+
+def get_features(spotify):
+    features = []
+    for index in range(0, 10):
+        results = spotify.current_user_saved_tracks(offset=index*50, limit=50)
+        track_ids = [item['track']['id'] for item in results['items']]
+        features.extend(spotify.audio_features(track_ids))
+
+    df = pd.DataFrame(data=features)
+    names = [
+        'danceability',
+        'energy',
+        'loudness',
+        'speechiness',
+        'acousticness',
+        'instrumentalness',
+        'liveness',
+        'valence',
+        'tempo',
+    ]
+
+    # print (features_means.to_json())
+    return df
+
+
+def get_features(spotify):
+    features = []
+    for index in range(0, 10):
+        results = spotify.current_user_saved_tracks(offset=index*50, limit=50)
+        track_ids = [item['track']['id'] for item in results['items']]
+        features.extend(spotify.audio_features(track_ids))
+
+    df = pd.DataFrame(data=features)
+    names = [
+        'danceability', 
+        'energy',
+        'loudness',
+        'speechiness',
+        'acousticness',
+        'instrumentalness',
+        'liveness',
+        'valence',
+        'tempo',
+    ]
+    features_means = df[names].mean()
+    # print (features_means.to_json())
+    return features_means
+
+
+##########
+def get_started():
+    # redirects to spotify and comes back
+    # then generates plots
+    return
+
+with gr.Blocks() as demo:
+    gr.Markdown(" ## Spotify Analyzer 🥳🎉")
+    gr.Markdown("This app analyzes how cool your music taste is. We dare you to take this challenge!")
+    with gr.Row():
+        get_started_btn = gr.Button("Get Started")
+    with gr.Row():
+        spider_plot = gr.Plot()
+    # with gr.Row():
+    #     with gr.Column():
+    #         with gr.Row():
+    #             with gr.Column():
+    #                 energy_plot = gr.ScatterPlot(show_label=False).style(container=True)
+    #             with gr.Column():
+    #                 liveness_plot = gr.ScatterPlot(show_label=False).style(container=True)
+    with gr.Row():
+        gr.Markdown(" ### We have recommendations for you!")
+    with gr.Row():
+        heatmap_plot = gr.Plot()
+    with gr.Row():
+        gr.Markdown(" ### We have recommendations for you!")
+    with gr.Row():
+        gr.Dataframe(
+            headers=["Song", "Album", "Artist"],
+            datatype=["str", "str", "str"],
+            label="Reccomended Songs",
+            value=[["Fired Up", "Fired Up", "Randy Houser"], ["Something Just Like This", "Memories... Do Not Open", "The Chainsmokers"]]  # TODO: replace with actual reccomendations once get_started() is implemeted.
+        )
+    
+    demo.load(fn=get_spider_plot, outputs = spider_plot)
+    demo.load(fn=heatmap_plot_fn, outputs = heatmap_plot)
+    # demo.load(fn=scatter_plot_fn_energy, outputs = energy_plot)
+    # demo.load(fn=scatter_plot_fn_liveness, outputs = liveness_plot)
+
+
+gradio_app = gr.mount_gradio_app(app, demo, "/gradio")
+uvicorn.run(app, host="0.0.0.0", port=7860)

heatmap.py

@@ -0,0 +1,39 @@
+from datetime import datetime
+from typing import List
+import numpy as np
+from spotipy import Spotify
+from dateutil.parser import parse
+import matplotlib.pyplot as plt
+
+def fetch_recent_songs(client: Spotify):
+	cursor = client.current_user_recently_played()
+	recently_played: List[dict] = cursor["items"]
+
+	max_iterations = 30
+	it = 0
+	while it < max_iterations and cursor["cursors"] is not None:
+		cursor = client.current_user_recently_played(before=cursor["cursors"]["before"])
+		recently_played.extend(cursor["items"])
+
+	return recently_played
+
+def build_heatmap(recent_songs: List[dict]) -> np.ndarray:
+	heatmap = np.zeros((7, 20))
+	now = datetime.now().astimezone()
+
+	for track in recent_songs:
+		played_at = parse(track["played_at"])
+		weekday = datetime.weekday(played_at)
+		week_offset = (now - played_at).days // 7
+		heatmap[weekday, -(week_offset +1)] +=1 
+	return heatmap
+
+
+def plot(heatmap: np.ndarray):
+	fig, ax = plt.subplots()
+
+	ax.imshow(heatmap, cmap="Greens")
+	ax.set_ylim(0, 6)
+	ax.set_title("Recent activity")
+	ax.set_yticklabels(["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"])
+	return fig, ax

requirements.txt

@@ -0,0 +1,6 @@
+spotipy==2.22.0
+vega-datasets==0.9.0
+Authlib==1.2.0
+flask==2.2.2
+pandas==1.5.2
+matplotlib