Spotify_Discovery.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "view-in-github"
   },
   "source": [
    "<a href=\"https://colab.research.google.com/github/teticio/Deej-A.I./blob/master/Spotify_Discovery.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ncrIRvwjf-6D"
   },
   "source": [
    "# How to discover new music on Spotify with Artificial Inteligence\n",
    "## Find similar sounding music by artists you may never have heard of"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-08-15T13:55:47.862160Z",
     "start_time": "2019-08-15T13:55:07.073113Z"
    },
    "cellView": "form",
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 2133
    },
    "colab_type": "code",
    "id": "_BDwwQ7WC1PC",
    "outputId": "8163961d-0a93-4b69-9365-3d8a6624d61c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loaded data for 320949 Spotify tracks\n",
      "Search keywords: mozart eine\n",
      "1. Wolfgang Amadeus Mozart - Eine kleine Nachtmusik K. 525: Allegro\n",
      "2. Wolfgang Amadeus Mozart - Serenade In G Major: Eine Kleine Nachtmusik, K. 525: I. Allegro\n",
      "3. Wolfgang Amadeus Mozart - Serenade In G Major: Eine Kleine Nachtmusik, K. 525: I. Allegro\n",
      "Input track number, ENTER to finish, or search keywords: 1\n",
      "Added Wolfgang Amadeus Mozart - Eine kleine Nachtmusik K. 525: Allegro to playlist\n",
      "Input track number, ENTER to finish, or search keywords: ace of spades\n",
      "1. Andreas Stabell - Ace of Spades 2016 (feat. Olav Haust)\n",
      "2. Motörhead - Ace of Spades\n",
      "3. Motörhead - Ace of Spades\n",
      "Input track number, ENTER to finish, or search keywords: 2\n",
      "Added Motörhead - Ace of Spades to playlist\n",
      "Input track number, ENTER to finish, or search keywords: \n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<h2>Joining the dots (creativity = 1)</h2>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<iframe src=\"https://open.spotify.com/embed/track/2mRUmSG3XGjFloqgAT2UJN\"                      width=\"100%\" height=\"80\" frameborder=\"0\" allowtransparency=\"true\"                      allow=\"encrypted-media\"></iframe>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<iframe src=\"https://open.spotify.com/embed/track/3v4O5D704CYOEbjKMwaqMc\"                          width=\"100%\" height=\"80\" frameborder=\"0\" allowtransparency=\"true\"                          allow=\"encrypted-media\"></iframe>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<iframe src=\"https://open.spotify.com/embed/track/1n8NKQRg8LVHy7oUhUgbFF\"                          width=\"100%\" height=\"80\" frameborder=\"0\" allowtransparency=\"true\"                          allow=\"encrypted-media\"></iframe>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<iframe src=\"https://open.spotify.com/embed/track/2v3Ezj7MnwBe3s1VRaUcDt\"                          width=\"100%\" height=\"80\" frameborder=\"0\" allowtransparency=\"true\"                          allow=\"encrypted-media\"></iframe>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<iframe src=\"https://open.spotify.com/embed/track/32stMPqC2Dw0ln5mRHRw2q\"                          width=\"100%\" height=\"80\" frameborder=\"0\" allowtransparency=\"true\"                          allow=\"encrypted-media\"></iframe>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<iframe src=\"https://open.spotify.com/embed/track/4rvDQAW3boZffZIzaYqnAc\"                          width=\"100%\" height=\"80\" frameborder=\"0\" allowtransparency=\"true\"                          allow=\"encrypted-media\"></iframe>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<iframe src=\"https://open.spotify.com/embed/track/4yDjiL2VjW95Z1CyVisFJA\"                          width=\"100%\" height=\"80\" frameborder=\"0\" allowtransparency=\"true\"                          allow=\"encrypted-media\"></iframe>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<iframe src=\"https://open.spotify.com/embed/track/7i9wHznK8dfkPZvXhrnv6l\"                          width=\"100%\" height=\"80\" frameborder=\"0\" allowtransparency=\"true\"                          allow=\"encrypted-media\"></iframe>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<iframe src=\"https://open.spotify.com/embed/track/3UDmHZcBTQp8Iu8droNtUl\"                          width=\"100%\" height=\"80\" frameborder=\"0\" allowtransparency=\"true\"                          allow=\"encrypted-media\"></iframe>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<iframe src=\"https://open.spotify.com/embed/track/4GwNeCsNlcnxtss75iWnDY\"                          width=\"100%\" height=\"80\" frameborder=\"0\" allowtransparency=\"true\"                          allow=\"encrypted-media\"></iframe>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<iframe src=\"https://open.spotify.com/embed/track/1CCJJe6yON6joOBjHoKKIi\"                          width=\"100%\" height=\"80\" frameborder=\"0\" allowtransparency=\"true\"                          allow=\"encrypted-media\"></iframe>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<iframe src=\"https://open.spotify.com/embed/track/1T45V6RDj1vTLFY6Cw4tNf\"                  width=\"100%\" height=\"80\" frameborder=\"0\" allowtransparency=\"true\"                  allow=\"encrypted-media\"></iframe>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#@title <- Press the \"play\" button to start!\n",
    "!pip3 install -q spotipy\n",
    "import spotipy\n",
    "import spotipy.util as util\n",
    "import os\n",
    "import requests\n",
    "import numpy as np\n",
    "import pickle\n",
    "import random\n",
    "from IPython.core.display import display, HTML\n",
    "\n",
    "#-----------------------------------------------------------------------------#\n",
    "\n",
    "lookback = 3       # Number of previous tracks to consider (default 3)\n",
    "size = 10          #@param {type:\"integer\"}\n",
    "creativity = 0.5   #@param {type:\"slider\", min:0, max:1, step:0.01}\n",
    "noise = 0          #@param {type:\"slider\", min:0, max:1, step:0.01}\n",
    "\n",
    "#@markdown (Optional) If you want to be able to load your playlists into Spotify, you will need to get credentials from [here](https://developer.spotify.com/dashboard/applications)\n",
    "scope = 'playlist-modify-public'\n",
    "username = ''      #@param {type: \"string\"}\n",
    "playlist_name = '' #@param {type: \"string\"}\n",
    "#@markdown (Playlist must already exist. Uncheck the box if you want to extend it.)\n",
    "replace = True     #@param {type:\"boolean\"}\n",
    "client_id ='194086cb37be48ebb45b9ba4ce4c5936'      #@param {type: \"string\"}\n",
    "client_secret ='fb9fb4957a9841fcb5b2dbc7804e1e85'  #@param {type: \"string\"}\n",
    "redirect_uri ='https://www.attentioncoach.es/'   #@param {type: \"string\"}\n",
    "\n",
    "#-----------------------------------------------------------------------------#\n",
    "\n",
    "def download_file_from_google_drive(id, destination):\n",
    "    if os.path.isfile(destination):\n",
    "        return None\n",
    "    print(f'Downloading {destination}')\n",
    "    URL = \"https://docs.google.com/uc?export=download\"\n",
    "    session = requests.Session()\n",
    "    response = session.get(URL, params = { 'id' : id }, stream = True)\n",
    "    token = get_confirm_token(response)\n",
    "    if token:\n",
    "        params = { 'id' : id, 'confirm' : token }\n",
    "        response = session.get(URL, params = params, stream = True)\n",
    "    save_response_content(response, destination)    \n",
    "\n",
    "def get_confirm_token(response):\n",
    "    for key, value in response.cookies.items():\n",
    "        if key.startswith('download_warning'):\n",
    "            return value\n",
    "    return None\n",
    "\n",
    "def save_response_content(response, destination):\n",
    "    CHUNK_SIZE = 32768\n",
    "    with open(destination, \"wb\") as f:\n",
    "        for chunk in response.iter_content(CHUNK_SIZE):\n",
    "            if chunk: # filter out keep-alive new chunks\n",
    "                f.write(chunk)\n",
    "\n",
    "def most_similar(mp3tovecs, weights, positive=[], negative=[], noise=0):\n",
    "    if isinstance(positive, str):\n",
    "        positive = [positive] # broadcast to list\n",
    "    if isinstance(negative, str):\n",
    "        negative = [negative] # broadcast to list\n",
    "    similar = np.zeros((len(mp3tovecs[0]), 2, len(weights)), dtype=np.float64)\n",
    "    for k, mp3tovec in enumerate(mp3tovecs):\n",
    "        mp3_vec_i = np.sum([mp3tovec[i] for i in positive] +\n",
    "                           [-mp3tovec[i] for i in negative], axis=0)\n",
    "        mp3_vec_i += np.random.normal(0, noise, len(mp3_vec_i))\n",
    "        mp3_vec_i = mp3_vec_i / np.linalg.norm(mp3_vec_i)\n",
    "        for j, track_j in enumerate(mp3tovec):\n",
    "            if track_j in positive or track_j in negative:\n",
    "                continue\n",
    "            mp3_vec_j = mp3tovec[track_j]\n",
    "            similar[j, 0, k] = j\n",
    "            similar[j, 1, k] = np.dot(mp3_vec_i, mp3_vec_j)\n",
    "    return sorted(similar, key=lambda x:-np.dot(x[1], weights))    \n",
    "\n",
    "def most_similar_by_vec(mp3tovecs, weights, positives=None, negatives=None, noise=0):\n",
    "    similar = np.zeros((len(mp3tovecs[0]), 2, len(weights)), dtype=np.float64)\n",
    "    positive = negative = []\n",
    "    for k, mp3tovec in enumerate(mp3tovecs):\n",
    "        if positives is not None:\n",
    "            positive = positives[k]\n",
    "        if negatives is not None:\n",
    "            negative = negatives[k]\n",
    "        if isinstance(positive, str):\n",
    "            positive = [positive] # broadcast to list\n",
    "        if isinstance(negative, str):\n",
    "            negative = [negative] # broadcast to list\n",
    "        mp3_vec_i = np.sum([i for i in positive] + [-i for i in negative], axis=0)\n",
    "        mp3_vec_i += np.random.normal(0, noise, len(mp3_vec_i))\n",
    "        mp3_vec_i = mp3_vec_i / np.linalg.norm(mp3_vec_i)\n",
    "        for j, track_j in enumerate(mp3tovec):\n",
    "            mp3_vec_j = mp3tovec[track_j]\n",
    "            similar[j, 0, k] = j\n",
    "            similar[j, 1, k] = np.dot(mp3_vec_i, mp3_vec_j)\n",
    "    return sorted(similar, key=lambda x:-np.dot(x[1], weights))\n",
    "\n",
    "def add_track_to_playlist(sp, username, playlist_id, track_id, replace=False):\n",
    "    if sp is not None and username is not None and playlist_id is not None:\n",
    "        try:\n",
    "            if replace:\n",
    "                sp.user_playlist_replace_tracks(username, playlist_id, [track_id])\n",
    "            else:\n",
    "                sp.user_playlist_add_tracks(username, playlist_id, [track_id])\n",
    "        except spotipy.client.SpotifyException:\n",
    "            # token has probably gone stale\n",
    "            token = util.prompt_for_user_token(username, scope, client_id, client_secret, redirect_uri)\n",
    "            sp = spotipy.Spotify(token)\n",
    "            if replace:\n",
    "                sp.user_playlist_replace_tracks(username, playlist_id, [track_id])\n",
    "            else:\n",
    "                sp.user_playlist_add_tracks(username, playlist_id, [track_id])\n",
    "\n",
    "def make_playlist(sp, username, playlist_id, mp3tovecs, weights, seed_tracks, \\\n",
    "                  tracks, track_ids, size=10, lookback=3, noise=0, replace=True):\n",
    "    playlist = seed_tracks\n",
    "    playlist_tracks = [tracks[_] for _ in playlist]\n",
    "    for i in range(0, len(seed_tracks)):\n",
    "        add_track_to_playlist(sp, username, playlist_id, playlist[i], replace and len(playlist) == 1)\n",
    "        display(HTML(f'<iframe src=\"https://open.spotify.com/embed/track/{playlist[i]}\" \\\n",
    "                     width=\"100%\" height=\"80\" frameborder=\"0\" allowtransparency=\"true\" \\\n",
    "                     allow=\"encrypted-media\"></iframe>'))\n",
    "    for i in range(len(seed_tracks), size):\n",
    "        candidates = most_similar(mp3tovecs, weights, positive=playlist[-lookback:], noise=noise)\n",
    "        for candidate in candidates:\n",
    "            track_id = track_ids[int(candidate[0][0])]\n",
    "            if track_id not in playlist and tracks[track_id] not in playlist_tracks:\n",
    "                break\n",
    "        playlist.append(track_id)\n",
    "        playlist_tracks.append(tracks[track_id])\n",
    "        add_track_to_playlist(sp, username, playlist_id, playlist[-1])\n",
    "        display(HTML(f'<iframe src=\"https://open.spotify.com/embed/track/{playlist[-1]}\" \\\n",
    "                     width=\"100%\" height=\"80\" frameborder=\"0\" allowtransparency=\"true\" \\\n",
    "                     allow=\"encrypted-media\"></iframe>'))\n",
    "    return playlist\n",
    "\n",
    "# create a musical journey between given track \"waypoints\"\n",
    "def join_the_dots(sp, username, playlist_id, mp3tovecs, weights, ids, \\\n",
    "                  tracks, track_ids, n=5, noise=0, replace=True):\n",
    "    playlist = []\n",
    "    playlist_tracks = [tracks[_] for _ in ids]\n",
    "    end = start = ids[0]\n",
    "    start_vec = [mp3tovec[start] for k, mp3tovec in enumerate(mp3tovecs)]\n",
    "    for end in ids[1:]:\n",
    "        end_vec = [mp3tovec[end] for k, mp3tovec in enumerate(mp3tovecs)]\n",
    "        playlist.append(start)\n",
    "        add_track_to_playlist(sp, username, playlist_id, playlist[-1], replace and len(playlist) == 1)\n",
    "        display(HTML(f'<iframe src=\"https://open.spotify.com/embed/track/{playlist[-1]}\" \\\n",
    "                     width=\"100%\" height=\"80\" frameborder=\"0\" allowtransparency=\"true\" \\\n",
    "                     allow=\"encrypted-media\"></iframe>'))\n",
    "        for i in range(n):\n",
    "            candidates = most_similar_by_vec(mp3tovecs, weights,\n",
    "                                             [[(n-i+1)/n * start_vec[k] +\n",
    "                                               (i+1)/n * end_vec[k]]\n",
    "                                              for k in range(len(mp3tovecs))],\n",
    "                                             noise=noise)\n",
    "            for candidate in candidates:\n",
    "                track_id = track_ids[int(candidate[0][0])]\n",
    "                if track_id not in playlist + ids and tracks[track_id] not in playlist_tracks:\n",
    "                    break\n",
    "            playlist.append(track_id)\n",
    "            playlist_tracks.append(tracks[track_id])\n",
    "            add_track_to_playlist(sp, username, playlist_id, playlist[-1])\n",
    "            display(HTML(f'<iframe src=\"https://open.spotify.com/embed/track/{playlist[-1]}\" \\\n",
    "                         width=\"100%\" height=\"80\" frameborder=\"0\" allowtransparency=\"true\" \\\n",
    "                         allow=\"encrypted-media\"></iframe>'))\n",
    "        start = end\n",
    "        start_vec = end_vec\n",
    "    playlist.append(end)\n",
    "    add_track_to_playlist(sp, username, playlist_id, playlist[-1])\n",
    "    display(HTML(f'<iframe src=\"https://open.spotify.com/embed/track/{playlist[-1]}\" \\\n",
    "                 width=\"100%\" height=\"80\" frameborder=\"0\" allowtransparency=\"true\" \\\n",
    "                 allow=\"encrypted-media\"></iframe>'))\n",
    "    return playlist\n",
    "\n",
    "def spotify():\n",
    "    sp = playlist_id = None\n",
    "    if username !='' and playlist_name != '':\n",
    "        if client_id == '':\n",
    "            display(HTML('Get your Spotify Credentials <a href=\"https://developer.spotify.com\\\n",
    "                         /dashboard/applications\">here</a> and fill in the form...'))\n",
    "            display(HTML('...or simply leave the username empty'))\n",
    "            return None\n",
    "        token = util.prompt_for_user_token(username, scope, client_id, client_secret, redirect_uri)\n",
    "        if token is not None:\n",
    "            sp = spotipy.Spotify(token)\n",
    "            if sp is not None:\n",
    "                playlists = sp.user_playlists(username)\n",
    "                if playlists is not None:\n",
    "                    playlist_ids = [playlist['id'] for playlist in playlists['items'] \\\n",
    "                                    if playlist['name'] == playlist_name]\n",
    "                    if len(playlist_ids) > 0:\n",
    "                        playlist_id = playlist_ids[0]\n",
    "        if playlist_id is None:\n",
    "            print(f'Unable to access playlist {playlist_name} for user {username}')\n",
    "        else:\n",
    "            print(f'Creating playlist {playlist_name} for user {username}')\n",
    "    mp3tovecs = pickle.load(open('spotifytovec.p', 'rb'))\n",
    "    mp3tovecs = dict(zip(mp3tovecs.keys(), [mp3tovecs[_] / np.linalg.norm(mp3tovecs[_]) for _ in mp3tovecs]))\n",
    "    tracktovecs = pickle.load(open('tracktovec.p', 'rb'))\n",
    "    tracktovecs = dict(zip(tracktovecs.keys(), [tracktovecs[_] / np.linalg.norm(tracktovecs[_]) for _ in tracktovecs]))\n",
    "    tracks = pickle.load(open('spotify_tracks.p', 'rb'))\n",
    "    track_ids = [_ for _ in mp3tovecs]\n",
    "    print(f'Loaded data for {len(mp3tovecs)} Spotify tracks')\n",
    "    user_input = input('Search keywords: ')\n",
    "    input_tracks = []\n",
    "    while True:\n",
    "        if user_input == '':\n",
    "            break\n",
    "        ids = sorted([track for track in mp3tovecs\n",
    "                      if all(word in tracks[track].lower()\n",
    "                             for word in user_input.lower().split())],\n",
    "                     key = lambda x: tracks[x])\n",
    "        for i, id in enumerate(ids):\n",
    "            print(f'{i+1}. {tracks[id]}')\n",
    "        while True:\n",
    "            user_input = input('Input track number, ENTER to finish, or search keywords: ')\n",
    "            if user_input == '':\n",
    "                break\n",
    "            if user_input.isdigit() and len(ids) > 0:\n",
    "                if int(user_input)-1 >= len(ids):\n",
    "                    continue\n",
    "                id = ids[int(user_input)-1]\n",
    "                input_tracks.append(id)\n",
    "                print(f'Added {tracks[id]} to playlist')\n",
    "            else:\n",
    "                break\n",
    "    if len(input_tracks) == 0:\n",
    "        ids = [track for track in tracks]\n",
    "        input_tracks.append(ids[random.randint(0, len(tracks))])\n",
    "    if len(input_tracks) > 1:\n",
    "        display(HTML(f'<h2>Joining the dots (creativity = {creativity})</h2>'))\n",
    "        playlist = join_the_dots(sp, username, playlist_id, [mp3tovecs, tracktovecs], \\\n",
    "                                 [creativity, 1-creativity], input_tracks, tracks, track_ids, \\\n",
    "                                  n=size, noise=noise, replace=replace)\n",
    "    else:\n",
    "        display(HTML(f'<h2>Playlist (creativity = {creativity})</h2>'))\n",
    "        playlist = make_playlist(sp, username, playlist_id, [mp3tovecs, tracktovecs], \\\n",
    "                                 [creativity, 1-creativity], input_tracks, tracks, track_ids, \\\n",
    "                                 size=size, lookback=lookback, noise=noise, replace=replace)\n",
    "    return playlist\n",
    "       \n",
    "if __name__ == \"__main__\":\n",
    "    download_file_from_google_drive('1Mg924qqF3iDgVW5w34m6Zaki5fNBdfSy', 'spotifytovec.p')\n",
    "    download_file_from_google_drive('1geEALPQTRBNUvkpI08B-oN4vsIiDTb5I', 'tracktovec.p')\n",
    "    download_file_from_google_drive('1Qre4Lkym1n5UTpAveNl5ffxlaAmH1ntS', 'spotify_tracks.p')\n",
    "    track_details = spotify()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "_cpg_wGyhDlU"
   },
   "source": [
    "### Some tips...\n",
    "If you choose more than one track, it will create a playlist which \"joins the dots\" between the tracks you select by smoothly moving from one to another. This helps give the playlist direction. If you only specify one track, it will generate each new track in the playlist based on the previous 3. You can control this number with the *lookback* parameter. The playlists are intended to be played in the order in which they are created.\n",
    "\n",
    "The *creativity* parameter controls the mix of considering songs that tend to appear close to each other in a playlist and songs that sound similar. A value of 0 will tend to pick out similar artists, while a value of 1 will likely choose songs with a similar mood, energy, rhythm or instrumentation. A good setting is usually around 0.5. For very popular artists, you may find you have to jack up the creativity parameter if you want to get off the beaten track. On the other hand, for less distinctive types of music, you may need to reduce the creativity parameter.\n",
    "\n",
    "Finally, you can add a sprinkling of randomness to the mix by tweaking the *noise* parameter.\n",
    "\n",
    "### What about creating automatic playlists with my own music collection?\n",
    "You can and more! Check out the complete project [here](https://github.com/teticio/Deej-A.I.)."
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "include_colab_link": true,
   "name": "Spotify Discovery",
   "provenance": [],
   "toc_visible": true,
   "version": "0.3.2"
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  },
  "nbTranslate": {
   "displayLangs": [
    "en",
    "es"
   ],
   "hotkey": "alt-t",
   "langInMainMenu": true,
   "sourceLang": "es",
   "targetLang": "en",
   "useGoogleTranslate": true
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}