Update app.py

app.py

@@ -15,6 +15,154 @@ 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',
+    ]
+    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'
@@ -103,6 +251,8 @@ with gr.Blocks() as demo:
     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():
@@ -126,6 +276,7 @@ with gr.Blocks() as demo:
         )
     demo.load(fn=scatter_plot_fn, outputs=plot)
     demo.load(fn=heatmap_plot_fn, output=hm_plot)
+    demo.load(fn=get_spider_plot, outputs=spider_plot)
 
 
 gradio_app = gr.mount_gradio_app(app, demo, "/gradio")