spotipy.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyPlkf7fkOphn5tr/wza/ofD",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/RubyNixx/spotify_analysis_using_spotipy/blob/main/spotipy.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Set up\n",
        "You will need to create a .env file and include API_KEY and SECRET_KEY as lines within this code. See Github repo instructions with information how to do this. This will then store them as variables to use through the following code.\n",
        "\n",
        "I've used a standard callback URL to work with an API. You can change this or keep it set up as it is."
      ],
      "metadata": {
        "id": "bXiyo6pkkiPD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Install the python-dotenv package to handle .env files\n",
        "!pip install python-dotenv"
      ],
      "metadata": {
        "id": "EBG6I19TQlkh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Upload your local .env file to google colab\n",
        "from google.colab import files\n",
        "uploaded = files.upload()"
      ],
      "metadata": {
        "id": "mX-3fCQwQuRX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Load the .env file and make the variables accessible\n",
        "\n",
        "import os\n",
        "from dotenv import load_dotenv\n",
        "\n",
        "# Load the .env file\n",
        "load_dotenv('/content/spotipy_api_keys.env')\n",
        "\n",
        "# Access the environment variables\n",
        "API_KEY = os.environ.get('API_KEY')\n",
        "SECRET_KEY = os.environ.get('SECRET_KEY')\n"
      ],
      "metadata": {
        "id": "YgOQz5d2Q-0s"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Input your credentials here:\n",
        "\n",
        "Client_ID = API_KEY\n",
        "Client_Secret= SECRET_KEY\n",
        "\n",
        "redirect_uri = 'http://example.com/callback'  # Make sure this matches your spotify developer dashboard"
      ],
      "metadata": {
        "id": "y2jQxGepTMbN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Install spotipy library\n",
        "!pip install spotipy"
      ],
      "metadata": {
        "id": "AkDWvAtjOq-P"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Import libraries\n",
        "\n",
        "import spotipy\n",
        "from spotipy.oauth2 import SpotifyOAuth\n",
        "from collections import Counter\n",
        "from datetime import datetime, timedelta\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import seaborn as sns\n",
        "import pandas as pd\n",
        "from wordcloud import WordCloud\n",
        "import re\n",
        "!pip install adjustText\n",
        "from adjustText import adjust_text\n",
        "from pandas.plotting import parallel_coordinates\n",
        "import plotly.graph_objects as go\n",
        "import plotly.io as pio\n",
        "\n",
        "!pip install squarify\n",
        "import squarify"
      ],
      "metadata": {
        "id": "tE1hUNmaWxJQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Set up your credentials to Read access to user library.\n",
        "#Scope:https://developer.spotify.com/documentation/web-api/concepts/scopes\n",
        "\n",
        "sp = spotipy.Spotify(auth_manager=SpotifyOAuth(\n",
        "    client_id=Client_ID,\n",
        "    client_secret=Client_Secret,\n",
        "    redirect_uri=redirect_uri,\n",
        "    scope=\"user-library-read\",\n",
        "    open_browser=False #this is required if working in google colab\n",
        "))\n"
      ],
      "metadata": {
        "id": "IKPvXTZhTIsV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Set up your credentials to read access to a user’s recently played tracks.\n",
        "#Scope:https://developer.spotify.com/documentation/web-api/concepts/scopes\n",
        "\n",
        "sp_oauth = SpotifyOAuth(client_id=Client_ID,\n",
        "                        client_secret=Client_Secret,\n",
        "                        redirect_uri=redirect_uri,\n",
        "                        scope='user-top-read',\n",
        "                        open_browser=False)"
      ],
      "metadata": {
        "id": "RRSM5p1roRQ-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "This will output a URL. Open the URL in a new window, and if prompted click approve. Then copy and paste the URL into the box that shows below the URL."
      ],
      "metadata": {
        "id": "VMQFpy_HlETj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Get the authorization URL\n",
        "auth_url = sp_oauth.get_authorize_url()\n",
        "print(f\"Please go to this URL and authorize the app: {auth_url}\")\n",
        "\n",
        "# After authorizing, you'll be redirected to a URL. Copy that entire URL and paste it here:\n",
        "response = input(\"Enter the URL you were redirected to: \")\n",
        "\n",
        "# Extract the code from the response\n",
        "code = sp_oauth.parse_response_code(response)\n",
        "\n",
        "# Use the code to get the token\n",
        "token_info = sp_oauth.get_access_token(code)\n",
        "\n",
        "# Create the Spotify client\n",
        "sp = spotipy.Spotify(auth=token_info['access_token'])"
      ],
      "metadata": {
        "id": "kujhjXpjUVci"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Listening by Genre\n",
        "And top genres listened to based on the top 50 artists genre you've listened to in the medium term:"
      ],
      "metadata": {
        "id": "VobI3Wl8wa1W"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Fetch top artists\n",
        "top_artists = sp.current_user_top_artists(limit=50, time_range=\"medium_term\")\n",
        "\n",
        "# Extract genres from top artists\n",
        "all_genres = []\n",
        "for artist in top_artists['items']:\n",
        "    all_genres.extend(artist['genres'])\n",
        "\n",
        "# Count genre occurrences\n",
        "genre_counts = Counter(all_genres)\n",
        "\n",
        "# Get top 15 genres\n",
        "top_genres = genre_counts.most_common(20)"
      ],
      "metadata": {
        "id": "JDRCC-OYbZtK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Prepare data for treemap\n",
        "genres, counts = zip(*top_genres)\n",
        "total = sum(counts)\n",
        "percentages = [count / total * 100 for count in counts]\n",
        "\n",
        "# Create color map\n",
        "colors = plt.cm.viridis(np.linspace(0, 1, len(genres)))\n",
        "\n",
        "# Create treemap\n",
        "plt.figure(figsize=(12, 8))\n",
        "squarify.plot(sizes=counts, label=genres, alpha=.8, color=colors,\n",
        "              text_kwargs={'fontsize': 15})  # Reduce font size\n",
        "plt.title('Top 20 Genres You Listen To')\n",
        "plt.axis('off')\n",
        "\n",
        "# Add percentage labels\n",
        "rects = squarify.squarify(counts, 0, 0, 1, 1)\n",
        "for rect, genre, count in zip(rects, genres, counts):\n",
        "    x, y, dx, dy = rect['x'], rect['y'], rect['dx'], rect['dy']\n",
        "    percentage = count / total * 100\n",
        "    plt.text(x + dx/2, y + dy/2, f'{genre}\\n{percentage:.1f}%',\n",
        "         horizontalalignment='center',\n",
        "         verticalalignment='center',\n",
        "         fontsize=8,\n",
        "         clip_on=True,\n",
        "         zorder=10)  # Allow clipping of text outside rectangle\n",
        "\n",
        "plt.tight_layout()\n",
        "plt.show()\n"
      ],
      "metadata": {
        "id": "60lxuNGlYaWP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Print results of top 20 genres\n",
        "print(\"Your top 20 genres:\")\n",
        "for genre, count in top_genres:\n",
        "    print(f\"{genre}: {count} occurrences ({count/total*100:.1f}%)\")"
      ],
      "metadata": {
        "id": "9J1sbGx3jcuC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Top 10 Genres as a bar chart**"
      ],
      "metadata": {
        "id": "Uy5WgkY9w8SK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "results = sp.current_user_top_artists(limit=50, time_range=\"medium_term\")\n",
        "genres = []\n",
        "\n",
        "for item in results['items']:\n",
        "    genres.extend(item['genres'])\n",
        "\n",
        "genre_counts = pd.Series(genres).value_counts().head(10)\n",
        "\n",
        "# Spotify color palette\n",
        "spotify_colors = ['#1DB954', '#191414', '#FFFFFF', '#B3B3B3', '#B3B3B3']\n",
        "\n",
        "plt.figure(figsize=(12, 6))\n",
        "ax = genre_counts.plot(kind='bar', color=spotify_colors[0], edgecolor=spotify_colors[1])\n",
        "\n",
        "plt.xlabel('Genre', fontweight='bold', color=spotify_colors[3])\n",
        "plt.ylabel('Count', fontweight='bold', color=spotify_colors[3])\n",
        "plt.title('Top 10 Genres in Your Music', fontweight='bold', color=spotify_colors[3], fontsize=16)\n",
        "plt.xticks(rotation=45, ha='right', color=spotify_colors[3])\n",
        "plt.yticks(color=spotify_colors[3])\n",
        "\n",
        "# Customize the plot background and border\n",
        "ax.set_facecolor(spotify_colors[1])\n",
        "plt.gcf().set_facecolor(spotify_colors[1])\n",
        "for spine in ax.spines.values():\n",
        "    spine.set_edgecolor(spotify_colors[3])\n",
        "\n",
        "# Add value labels on top of each bar\n",
        "for i, v in enumerate(genre_counts):\n",
        "    ax.text(i, v, str(v), ha='center', va='bottom', color=spotify_colors[2], fontweight='bold')\n",
        "\n",
        "# Customize the grid\n",
        "ax.grid(axis='y', linestyle='--', alpha=0.7, color=spotify_colors[4])\n",
        "ax.set_axisbelow(True)\n",
        "\n",
        "plt.tight_layout()\n",
        "plt.show()\n"
      ],
      "metadata": {
        "id": "5TJ8jzmcsybW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Energy distribution across Genres**"
      ],
      "metadata": {
        "id": "vK5nCUyyw2eB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "results = sp.current_user_top_tracks(limit=50, time_range=\"medium_term\")\n",
        "data = []\n",
        "\n",
        "for item in results['items']:\n",
        "    track_features = sp.audio_features(item['id'])[0]\n",
        "    artist_info = sp.artist(item['artists'][0]['id'])\n",
        "    data.append({\n",
        "        'name': item['name'],\n",
        "        'genre': artist_info['genres'][0] if artist_info['genres'] else 'Unknown',\n",
        "        'danceability': track_features['danceability'],\n",
        "        'energy': track_features['energy'],\n",
        "        'valence': track_features['valence']\n",
        "    })\n",
        "\n",
        "df = pd.DataFrame(data)\n",
        "\n",
        "# Spotify color palette\n",
        "spotify_green = '#1DB954'\n",
        "spotify_black = '#191414'\n",
        "spotify_white = '#FFFFFF'\n",
        "spotify_gray = '#535353'\n",
        "\n",
        "# Set the style for the plot\n",
        "plt.style.use('dark_background')\n",
        "plt.rcParams['axes.facecolor'] = spotify_black\n",
        "plt.rcParams['figure.facecolor'] = spotify_black\n",
        "\n",
        "plt.figure(figsize=(12, 6))\n",
        "ax = sns.boxplot(x='genre', y='energy', data=df, color=spotify_green, medianprops={\"color\": spotify_white})\n",
        "\n",
        "# Customize the plot\n",
        "plt.xlabel('Genre', fontweight='bold', color=spotify_white)\n",
        "plt.ylabel('Energy', fontweight='bold', color=spotify_white)\n",
        "plt.title('Energy Distribution Across Genres', fontweight='bold', color=spotify_white, fontsize=16)\n",
        "plt.xticks(rotation=45, ha='right', color=spotify_white)\n",
        "plt.yticks(color=spotify_white)\n",
        "\n",
        "# Customize the grid\n",
        "ax.grid(axis='y', linestyle='--', alpha=0.7, color=spotify_gray)\n",
        "ax.set_axisbelow(True)\n",
        "\n",
        "# Customize the spines\n",
        "for spine in ax.spines.values():\n",
        "    spine.set_edgecolor(spotify_gray)\n",
        "\n",
        "plt.tight_layout()\n",
        "plt.show()\n"
      ],
      "metadata": {
        "id": "z7J0OKrCwDIz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Create a sunburst chart to visualise your music genres**"
      ],
      "metadata": {
        "id": "hCbELRNpbuhN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "pio.templates.default = \"plotly_dark\"\n",
        "\n",
        "genre_counts_sorted = genre_counts.sort_values(ascending=False).head(50)\n",
        "\n",
        "genres = genre_counts_sorted.index.tolist()\n",
        "counts = genre_counts_sorted.values.tolist()\n",
        "\n",
        "# Create sunburst data\n",
        "labels = [\"All Genres\"] + genres\n",
        "parents = [\"\"] + [\"All Genres\"] * len(genres)\n",
        "values = [sum(counts)] + counts\n",
        "\n",
        "# Create sunburst chart\n",
        "fig = go.Figure(go.Sunburst(\n",
        "    labels=labels,\n",
        "    parents=parents,\n",
        "    values=values,\n",
        "    branchvalues=\"total\",\n",
        "    marker=dict(colors=counts, colorscale=\"Viridis\"),\n",
        "    hovertemplate='<b>%{label}</b><br>Count: %{value}<br>Percentage: %{percentParent:.1%}',\n",
        "))\n",
        "\n",
        "fig.update_layout(title_text=\"Your Music Genre Universe\", width=800, height=800)\n",
        "fig.show()\n"
      ],
      "metadata": {
        "id": "Av_P8br9a4cM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Top Artists & Tracks\n",
        "This section outputs stats about your listening such as top 10 artists listened to in the medium term:"
      ],
      "metadata": {
        "id": "qXRpsNk0pUc-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Get top 10 artists you've listened to:\n",
        "top_artists = sp.current_user_top_artists(limit=10, time_range=\"medium_term\")\n",
        "for i, artist in enumerate(top_artists['items']):\n",
        "    print(f\"{i+1}. {artist['name']}\")\n"
      ],
      "metadata": {
        "id": "R5Jzlr-SVUl5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Bar chart visualisation showing top 20 tracks listened to in the medium term by popularity score."
      ],
      "metadata": {
        "id": "2V-0ltUOp2YP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Fetch top 20 tracks\n",
        "top_tracks = sp.current_user_top_tracks(limit=20, time_range=\"medium_term\")\n",
        "\n",
        "# Prepare data for visualization\n",
        "track_names = []\n",
        "popularities = []\n",
        "artists = []\n",
        "\n",
        "for track in top_tracks['items']:\n",
        "    track_names.append(track['name'])\n",
        "    popularities.append(track['popularity'])\n",
        "    artists.append(track['artists'][0]['name'])\n",
        "\n",
        "# Create a list of \"Artist - Track\" for labels\n",
        "labels = [f\"{artist} - {track}\" for artist, track in zip(artists, track_names)]\n",
        "\n",
        "# Spotify color palette\n",
        "spotify_green = '#1DB954'\n",
        "spotify_black = '#191414'\n",
        "spotify_white = '#FFFFFF'\n",
        "spotify_gray = '#535353'\n",
        "\n",
        "# Set up the plot\n",
        "plt.figure(figsize=(12, 10))\n",
        "plt.style.use('dark_background')\n",
        "plt.rcParams['axes.facecolor'] = spotify_black\n",
        "plt.rcParams['figure.facecolor'] = spotify_black\n",
        "\n",
        "# Create horizontal bar plot\n",
        "bars = plt.barh(range(len(popularities)), popularities, align='center', color=spotify_green)\n",
        "\n",
        "# Customize the plot\n",
        "plt.title(\"Your Top 20 Tracks on Spotify\", fontsize=16, color=spotify_white, fontweight='bold')\n",
        "plt.xlabel(\"Popularity Score\", fontsize=12, color=spotify_white, fontweight='bold')\n",
        "plt.ylabel(\"Track\", fontsize=12, color=spotify_white, fontweight='bold')\n",
        "\n",
        "# Set y-axis ticks and labels\n",
        "plt.yticks(range(len(labels)), labels, color=spotify_white)\n",
        "\n",
        "# Add popularity scores at the end of each bar\n",
        "for i, v in enumerate(popularities):\n",
        "    plt.text(v + 0.5, i, str(v), va='center', color=spotify_white, fontweight='bold')\n",
        "\n",
        "# Customize the grid\n",
        "plt.grid(axis='x', linestyle='--', alpha=0.7, color=spotify_gray)\n",
        "\n",
        "# Remove top and right spines\n",
        "plt.gca().spines['top'].set_visible(False)\n",
        "plt.gca().spines['right'].set_visible(False)\n",
        "\n",
        "# Color remaining spines\n",
        "plt.gca().spines['left'].set_color(spotify_gray)\n",
        "plt.gca().spines['bottom'].set_color(spotify_gray)\n",
        "\n",
        "# Adjust layout and display\n",
        "plt.tight_layout()\n",
        "plt.show()\n"
      ],
      "metadata": {
        "id": "2NWXyaL4boiW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "And the same for top 50 over a long term period"
      ],
      "metadata": {
        "id": "GYBmP_SsqL87"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Fetch top 50 tracks\n",
        "top_tracks = sp.current_user_top_tracks(limit=50, time_range=\"long_term\")\n",
        "\n",
        "# Prepare data for visualization\n",
        "track_names = []\n",
        "popularities = []\n",
        "artists = []\n",
        "\n",
        "for track in top_tracks['items']:\n",
        "    track_names.append(track['name'])\n",
        "    popularities.append(track['popularity'])\n",
        "    artists.append(track['artists'][0]['name'])\n",
        "\n",
        "# Create a list of \"Artist - Track\" for labels\n",
        "labels = [f\"{artist} - {track}\" for artist, track in zip(artists, track_names)]\n",
        "\n",
        "# Spotify color palette\n",
        "spotify_green = '#1DB954'\n",
        "spotify_black = '#191414'\n",
        "spotify_white = '#FFFFFF'\n",
        "spotify_gray = '#535353'\n",
        "\n",
        "# Set up the plot\n",
        "plt.figure(figsize=(12, 10))\n",
        "plt.style.use('dark_background')\n",
        "plt.rcParams['axes.facecolor'] = spotify_black\n",
        "plt.rcParams['figure.facecolor'] = spotify_black\n",
        "\n",
        "# Create horizontal bar plot\n",
        "bars = plt.barh(range(len(popularities)), popularities, align='center', color=spotify_green)\n",
        "\n",
        "# Customize the plot\n",
        "plt.title(\"Your Top 50 Tracks on Spotify\", fontsize=16, color=spotify_white, fontweight='bold')\n",
        "plt.xlabel(\"Popularity Score\", fontsize=12, color=spotify_white, fontweight='bold')\n",
        "plt.ylabel(\"Track\", fontsize=12, color=spotify_white, fontweight='bold')\n",
        "\n",
        "# Set y-axis ticks and labels\n",
        "plt.yticks(range(len(labels)), labels, color=spotify_white)\n",
        "\n",
        "# Add popularity scores at the end of each bar\n",
        "for i, v in enumerate(popularities):\n",
        "    plt.text(v + 0.5, i, str(v), va='center', color=spotify_white, fontweight='bold')\n",
        "\n",
        "# Customize the grid\n",
        "plt.grid(axis='x', linestyle='--', alpha=0.7, color=spotify_gray)\n",
        "\n",
        "# Remove top and right spines\n",
        "plt.gca().spines['top'].set_visible(False)\n",
        "plt.gca().spines['right'].set_visible(False)\n",
        "\n",
        "# Color remaining spines\n",
        "plt.gca().spines['left'].set_color(spotify_gray)\n",
        "plt.gca().spines['bottom'].set_color(spotify_gray)\n",
        "\n",
        "# Adjust layout and display\n",
        "plt.tight_layout()\n",
        "plt.show()\n"
      ],
      "metadata": {
        "id": "2-4a_7sncAHz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Print the list\n",
        "print(\"Your top 50 tracks:\")\n",
        "for i, (track, artist, popularity) in enumerate(zip(track_names, artists, popularities), 1):\n",
        "    print(f\"{i}. {artist} - {track} (Popularity: {popularity})\")\n"
      ],
      "metadata": {
        "id": "wJIwEEVkjvoa"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Short term vs Long Term Listening by features\n",
        "In this section we take the top 50 tracks from both the short term range and long term range, and then we compare them using a barbell chart. To visualise the temp on the same chart we've had to normalise it to a range. The features with the most space between them are the ones that have changed the greatest."
      ],
      "metadata": {
        "id": "yK29gwYzqR22"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def get_track_data(time_range, limit=50):\n",
        "    top_tracks = sp.current_user_top_tracks(limit=limit, time_range=time_range)\n",
        "    track_data = []\n",
        "    for track in top_tracks['items']:\n",
        "        track_id = track['id']\n",
        "        features = sp.audio_features(track_id)[0]\n",
        "        track_data.append({\n",
        "            'name': f\"{track['artists'][0]['name']} - {track['name']}\",\n",
        "            'popularity': track['popularity'],\n",
        "            'instrumentalness': features['instrumentalness'],\n",
        "            'speechiness': features['speechiness'],\n",
        "            'danceability': features['danceability'],\n",
        "            'energy': features['energy'],\n",
        "            'valence': features['valence'],\n",
        "            'tempo': features['tempo'] / 200  # Normalize tempo to 0-1 range (assuming max tempo is 200 BPM)\n",
        "        })\n",
        "    return track_data\n",
        "\n",
        "# Get track data for short-term and long-term\n",
        "short_term_data = get_track_data('short_term')\n",
        "long_term_data = get_track_data('long_term')\n",
        "\n",
        "# Calculate averages for each feature\n",
        "features = ['instrumentalness', 'speechiness', 'danceability', 'energy', 'valence', 'tempo']\n",
        "short_term_avg = {feature: np.mean([track[feature] for track in short_term_data]) for feature in features}\n",
        "long_term_avg = {feature: np.mean([track[feature] for track in long_term_data]) for feature in features}\n",
        "\n",
        "# Set up the plot\n",
        "fig, ax = plt.subplots(figsize=(12, 8), facecolor='#191414')\n",
        "ax.set_facecolor('#191414')\n",
        "\n",
        "# Plot the dumbbell chart\n",
        "y_pos = np.arange(len(features))\n",
        "ax.hlines(y_pos, [long_term_avg[f] for f in features], [short_term_avg[f] for f in features], color='white', alpha=0.5)\n",
        "ax.scatter(y_pos, [long_term_avg[f] for f in features], color='#FFF', s=100, label='Long Term')\n",
        "ax.scatter(y_pos, [short_term_avg[f] for f in features], color='#1DB954', s=100, label='Short Term')\n",
        "\n",
        "# Customize the plot\n",
        "ax.set_yticks(y_pos)\n",
        "ax.set_yticklabels(features)\n",
        "ax.set_xlabel('Feature Value', color='white')\n",
        "ax.set_title(\"Short-term vs Long-term Listening Habits\", color='white', fontsize=20)\n",
        "ax.legend(loc='upper right', fontsize=12)\n",
        "\n",
        "# Set x-axis limits\n",
        "ax.set_xlim(0, 1)\n",
        "\n",
        "# Adjust text color\n",
        "for text in ax.get_xticklabels() + ax.get_yticklabels():\n",
        "    text.set_color('white')\n",
        "\n",
        "# Add gridlines\n",
        "ax.grid(color='gray', linestyle='--', linewidth=0.5, alpha=0.3)\n",
        "\n",
        "# Add value labels\n",
        "for i, feature in enumerate(features):\n",
        "    ax.text(long_term_avg[feature], i, f'{long_term_avg[feature]:.2f}', va='center', ha='right', color='white', fontsize=15)\n",
        "    ax.text(short_term_avg[feature], i, f'{short_term_avg[feature]:.2f}', va='center', ha='left', color='#1DB954', fontsize=15)\n",
        "\n",
        "plt.tight_layout()\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "mRslWgakcovh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "We could also compare features for many tracks using a scatter plot."
      ],
      "metadata": {
        "id": "YTYFEoChrUEb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Print average values\n",
        "print(\"Average values:\")\n",
        "print(\"Feature      | Short Term | Long Term\")\n",
        "print(\"-------------|------------|----------\")\n",
        "for feature in features:\n",
        "    print(f\"{feature:<12} | {short_term_avg[feature]:.4f}    | {long_term_avg[feature]:.4f}\")\n"
      ],
      "metadata": {
        "id": "MBZmWisBqzga"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Fetch top 50 tracks and their features\n",
        "results = sp.current_user_top_tracks(limit=50, time_range=\"medium_term\")\n",
        "features = []\n",
        "\n",
        "for item in results['items']:\n",
        "    track_features = sp.audio_features(item['id'])[0]\n",
        "    features.append({\n",
        "        'name': item['name'],\n",
        "        'artist': item['artists'][0]['name'],\n",
        "        'acousticness': track_features['acousticness'],\n",
        "        'danceability': track_features['danceability'],\n",
        "        'energy': track_features['energy'],\n",
        "        'valence': track_features['valence']\n",
        "    })\n",
        "\n",
        "df = pd.DataFrame(features)\n",
        "\n",
        "# Spotify color palette\n",
        "spotify_green = '#1DB954'\n",
        "spotify_black = '#191414'\n",
        "spotify_white = '#FFFFFF'\n",
        "spotify_gray = '#535353'\n",
        "\n",
        "# Set up the plot\n",
        "plt.figure(figsize=(12, 8))\n",
        "plt.style.use('dark_background')\n",
        "plt.rcParams['axes.facecolor'] = spotify_black\n",
        "plt.rcParams['figure.facecolor'] = spotify_black\n",
        "\n",
        "# Create scatter plot\n",
        "scatter = plt.scatter(df['energy'], df['valence'], c=df['danceability'], cmap='viridis', alpha=0.7)\n",
        "\n",
        "# Customize the plot\n",
        "plt.title(\"Energy vs. Valence (color = Danceability)\", fontsize=16, color=spotify_white, fontweight='bold')\n",
        "plt.xlabel(\"Energy\", fontsize=12, color=spotify_white, fontweight='bold')\n",
        "plt.ylabel(\"Valence\", fontsize=12, color=spotify_white, fontweight='bold')\n",
        "\n",
        "# Customize the colorbar\n",
        "cbar = plt.colorbar(scatter)\n",
        "cbar.set_label('Danceability', color=spotify_white, fontweight='bold')\n",
        "cbar.ax.yaxis.set_tick_params(color=spotify_white)\n",
        "cbar.outline.set_edgecolor(spotify_gray)\n",
        "plt.setp(plt.getp(cbar.ax.axes, 'yticklabels'), color=spotify_white)\n",
        "\n",
        "# Customize the grid\n",
        "plt.grid(True, linestyle='--', alpha=0.3, color=spotify_gray)\n",
        "\n",
        "# Customize the spines\n",
        "for spine in plt.gca().spines.values():\n",
        "    spine.set_edgecolor(spotify_gray)\n",
        "\n",
        "# Customize tick colors\n",
        "plt.tick_params(colors=spotify_white)\n",
        "\n",
        "# Add Spotify logo colors to the plot\n",
        "plt.plot([], [], 'o', color=spotify_green, label='Spotify Green')\n",
        "plt.legend(labelcolor=spotify_white, facecolor=spotify_black, edgecolor=spotify_gray)\n",
        "\n",
        "plt.tight_layout()\n",
        "plt.show()\n"
      ],
      "metadata": {
        "id": "mThzT2LuiYXQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Find the song with the highest energy\n",
        "highest_energy_song = df.loc[df['energy'].idxmax()]\n",
        "\n",
        "print(\"Song with the highest energy:\")\n",
        "print(f\"Name: {highest_energy_song['name']}\")\n",
        "print(f\"Artist: {highest_energy_song['artist']}\")\n",
        "print(f\"Energy: {highest_energy_song['energy']:.2f}\")\n",
        "print(f\"Danceability: {highest_energy_song['danceability']:.2f}\")\n",
        "print(f\"Valence: {highest_energy_song['valence']:.2f}\")"
      ],
      "metadata": {
        "id": "qm3rvfUgil06"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Top Artists listened to\n",
        "over all periods, with the total songs if more than 1 song makes the top 50 for 1 artist."
      ],
      "metadata": {
        "id": "Iu_xujIIrEP-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Top Artists by Song Count within a medium term time range over 50 songs\n",
        "results = sp.current_user_top_tracks(limit=50, time_range=\"medium_term\")\n",
        "artist_count = {}\n",
        "\n",
        "for item in results['items']:\n",
        "    artist = item['artists'][0]['name']\n",
        "    artist_count[artist] = artist_count.get(artist, 0) + 1\n",
        "\n",
        "# Sort artists by count in descending order\n",
        "sorted_artists = sorted(artist_count.items(), key=lambda x: x[1], reverse=True)\n",
        "artists, counts = zip(*sorted_artists)\n",
        "\n",
        "# Create the plot\n",
        "plt.figure(figsize=(12, 6))\n",
        "plt.bar(artists, counts, color='#1DB954')  # Spotify green color\n",
        "\n",
        "# Customize the plot\n",
        "plt.xticks(rotation=90)\n",
        "plt.xlabel('Artist', fontsize=12)\n",
        "plt.ylabel('Number of Songs', fontsize=12)\n",
        "plt.title('Top Artists by Song Count (Medium Term)', fontsize=16)\n",
        "\n",
        "# Add value labels on top of each bar\n",
        "for i, v in enumerate(counts):\n",
        "    plt.text(i, v, str(v), ha='center', va='bottom')\n",
        "\n",
        "# Adjust layout and display\n",
        "plt.tight_layout()\n",
        "plt.show()\n"
      ],
      "metadata": {
        "id": "aAMz-AeKhQcL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Top Artists by Song Count within a medium term time range over 50 songs\n",
        "results = sp.current_user_top_tracks(limit=50, time_range=\"long_term\")\n",
        "artist_count = {}\n",
        "\n",
        "for item in results['items']:\n",
        "    artist = item['artists'][0]['name']\n",
        "    artist_count[artist] = artist_count.get(artist, 0) + 1\n",
        "\n",
        "# Sort artists by count in descending order\n",
        "sorted_artists = sorted(artist_count.items(), key=lambda x: x[1], reverse=True)\n",
        "artists, counts = zip(*sorted_artists)\n",
        "\n",
        "# Create the plot\n",
        "plt.figure(figsize=(12, 6))\n",
        "plt.bar(artists, counts, color='#1DB954')  # Spotify green color\n",
        "\n",
        "# Customize the plot\n",
        "plt.xticks(rotation=90)\n",
        "plt.xlabel('Artist', fontsize=12)\n",
        "plt.ylabel('Number of Songs', fontsize=12)\n",
        "plt.title('Top Artists by Song Count (Long Term)', fontsize=16)\n",
        "\n",
        "# Add value labels on top of each bar\n",
        "for i, v in enumerate(counts):\n",
        "    plt.text(i, v, str(v), ha='center', va='bottom')\n",
        "\n",
        "# Adjust layout and display\n",
        "plt.tight_layout()\n",
        "plt.show()\n"
      ],
      "metadata": {
        "id": "k4kcm-L7h6ls"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Top Artists by Song Count within a medium term time range over 50 songs\n",
        "results = sp.current_user_top_tracks(limit=50, time_range=\"short_term\")\n",
        "artist_count = {}\n",
        "\n",
        "for item in results['items']:\n",
        "    artist = item['artists'][0]['name']\n",
        "    artist_count[artist] = artist_count.get(artist, 0) + 1\n",
        "\n",
        "# Sort artists by count in descending order\n",
        "sorted_artists = sorted(artist_count.items(), key=lambda x: x[1], reverse=True)\n",
        "artists, counts = zip(*sorted_artists)\n",
        "\n",
        "# Create the plot\n",
        "plt.figure(figsize=(12, 6))\n",
        "plt.bar(artists, counts, color='#1DB954')  # Spotify green color\n",
        "\n",
        "# Customize the plot\n",
        "plt.xticks(rotation=90)\n",
        "plt.xlabel('Artist', fontsize=12)\n",
        "plt.ylabel('Number of Songs', fontsize=12)\n",
        "plt.title('Top Artists by Song Count (Short Term)', fontsize=16)\n",
        "\n",
        "# Add value labels on top of each bar\n",
        "for i, v in enumerate(counts):\n",
        "    plt.text(i, v, str(v), ha='center', va='bottom')\n",
        "\n",
        "# Adjust layout and display\n",
        "plt.tight_layout()\n",
        "plt.show()\n"
      ],
      "metadata": {
        "id": "z3xoPaqTiIKL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Tracks by popular words\n",
        "\n",
        "In this code you can handle removal of words such as 'feat' which referred to a 'featuring' an artists and therefore wasnt part of the track name."
      ],
      "metadata": {
        "id": "9XKtz92_xHsC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "results = sp.current_user_top_tracks(limit=50, time_range=\"long_term\")\n",
        "\n",
        "# Preprocess track names to remove 'feat' and anything after it\n",
        "track_names = ' '.join([re.sub(r'\\(feat\\..*?\\)|\\(ft\\..*?\\)', '', item['name']).strip() for item in results['items']])\n",
        "\n",
        "# Create a WordCloud object\n",
        "wordcloud = WordCloud(width=800, height=400, background_color=spotify_black, colormap='viridis').generate(track_names)\n",
        "\n",
        "# Set up the plot\n",
        "plt.figure(figsize=(12, 6))\n",
        "plt.style.use('dark_background')\n",
        "plt.rcParams['axes.facecolor'] = spotify_black\n",
        "plt.rcParams['figure.facecolor'] = spotify_black\n",
        "\n",
        "# Display the word cloud\n",
        "plt.imshow(wordcloud, interpolation='bilinear')\n",
        "plt.axis('off')\n",
        "plt.title('Word Cloud of Your Top Tracks', fontsize=16, color=spotify_white, fontweight='bold')\n",
        "\n",
        "# Add Spotify logo colors to the plot\n",
        "plt.plot([], [], 'o', color=spotify_green, label='Spotify Green')\n",
        "plt.legend(labelcolor=spotify_white, facecolor=spotify_black, edgecolor=spotify_gray, loc='upper right')\n",
        "\n",
        "plt.tight_layout()\n",
        "plt.show()\n"
      ],
      "metadata": {
        "id": "MFRei0Q5wKKg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Artist Popularity and Followers"
      ],
      "metadata": {
        "id": "CqA9eKW9xCMy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "results = sp.current_user_top_artists(limit=35, time_range=\"short_term\")\n",
        "popularity = []\n",
        "followers = []\n",
        "names = []\n",
        "\n",
        "for item in results['items']:\n",
        "    popularity.append(item['popularity'])\n",
        "    followers.append(item['followers']['total'])\n",
        "    names.append(item['name'])\n",
        "\n",
        "plt.figure(figsize=(12, 6), facecolor='white')\n",
        "scatter = plt.scatter(followers, popularity, alpha=0.7, color='#1DB954')  # Spotify green\n",
        "plt.xlabel('Number of Followers', fontsize=12, color='black')\n",
        "plt.ylabel('Popularity', fontsize=12, color='black')\n",
        "plt.title('Artist Popularity vs. Number of Followers', fontsize=14, color='black')\n",
        "plt.xscale('log')\n",
        "\n",
        "# Customize the appearance\n",
        "plt.tick_params(colors='black')\n",
        "plt.gca().spines['bottom'].set_color('black')\n",
        "plt.gca().spines['left'].set_color('black')\n",
        "plt.gca().spines['top'].set_visible(False)\n",
        "plt.gca().spines['right'].set_visible(False)\n",
        "\n",
        "texts = []\n",
        "for i, name in enumerate(names):\n",
        "    texts.append(plt.text(followers[i], popularity[i], name, color='white', fontsize=12))\n",
        "\n",
        "adjust_text(texts, arrowprops=dict(arrowstyle='->', color='white', lw=2.5))\n",
        "\n",
        "plt.tight_layout()\n",
        "plt.show()\n"
      ],
      "metadata": {
        "id": "FrzXLMYgtY0F"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Tracks listened to the most"
      ],
      "metadata": {
        "id": "YkAWrZnmYlTs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "results = sp.current_user_top_tracks(limit=20, time_range=\"long_term\")\n",
        "sizes = []\n",
        "colors = []\n",
        "labels = []\n",
        "\n",
        "for i, item in enumerate(results['items']):\n",
        "    sizes.append(20 - i)\n",
        "    colors.append(item['popularity'])\n",
        "    labels.append(item['name'])\n",
        "\n",
        "colors = np.array(colors) / 100\n",
        "\n",
        "plt.figure(figsize=(12, 8))\n",
        "squarify.plot(sizes=sizes, color=plt.cm.viridis(colors), label=labels, alpha=0.8)\n",
        "plt.axis('off')\n",
        "plt.title('Top Tracks: Size = Listening Frequency, Colour = Popularity')\n",
        "plt.tight_layout()\n",
        "plt.show()\n"
      ],
      "metadata": {
        "id": "d6yia4Byxgc8"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}