Tutoriel Spotipy – Créer une playlist de recommandations Spotify

N’avez-vous jamais été surpris par la qualité des recommandations de Spotify, une fois l’écoute d’un album terminée ? Le service de streaming dispose de données plutôt riches concernant les titres de son catalogue et peut ainsi créer des enchaînements pertinents. Par exemple, Spotify prend en compte des critères d’énergie, de positivité, de tempo, etc.

Je vous propose de manipuler l’API Spotify en Python, à l’aide de la librairie Spotipy. L’objectif est de créer une playlist qui faciliterait la découverte d’un genre musical, à partir d’un nom d’artiste. Autrement dit, je vais chercher à constituer une playlist qui se composerait de morceaux d’artistes similaires à un artiste donné.  Pour faciliter ces découvertes, ma playlist sera composée de deux types de morceaux :
– Les titres parmi les plus populaires, d’artistes similaires.
– Des titres recommandés par Spotify en fonction de l’artiste cherché.

 

Etape 1 – Créer une application Spotify

Pour accéder à l’API Spotify, vous devez déclarer une application. Depuis les paramètres, vous récupérez vos codes d’accès :
– un client ID
– un client secret

Il vous faut aussi paramétrer l’URI de redirection dans les paramètres. Dans notre cas, nous utiliserons http://localhost/

 

Etape 2 – Authentification à Spotify

Ici, je reprends l’exemple présenté dans la documentation de la librairie Spotipy. Pour en savoir plus sur le processus d’autorisation, la documentation de Spotify est exhaustive.

Tout d’abord, nous allons commencer par importer les librairies utiles à notre projet.

 import pprint
 import sys
 import spotipy    # la librairie pour manipuler l'api spotify
 import spotipy.util as util
 import simplejson as json  #pour manipuler les réponses json
 import time  #pour créer une playlist horodatée
 from datetime import datetime
 from random import shuffle #pour attribuer un classement aléatoire aux morceaux

 

Nous définissons ensuite les paramètres nécessaires à l’authentification. Tout d’abord, créez des variables avec votre nom d’utilisateur, votre client ID et votre client secret.

 username="erwan.lenagard"
 clientId= "xxxxxx"
 clientSecret="yyyyyyy"

Puis, définissez un scope d’accès aux données. Nous allons créer et modifier une playlist, il nous faut a minima les accès ‘playlist-modify-public’ et ‘playlist-modify-private’. Voici tous les scopes possibles :

scope = 'playlist-read-private playlist-read-collaborative playlist-modify-public playlist-modify-private streaming ugc-image-upload user-follow-modify user-follow-read user-library-read user-library-modify user-read-private user-read-birthdate user-read-email user-top-read user-read-playback-state user-modify-playback-state user-read-currently-playing user-read-recently-played'

L’authentification se fait en deux temps :

if len(sys.argv) > 1:
     username = sys.argv[1]
else:
     print("Usage: %s username" % (sys.argv[0],))
     sys.exit()

token = util.prompt_for_user_token(username,scope,client_id=clientId,client_secret=clientSecret,redirect_uri='http://localhost/')

Vous êtes alors redirigé vers une URL comprenant un token d’accès. Copiez-le dans la fenêtre de commande qui est apparue sur Jupyter Notebook.

Etape 3 – Création d’une playlist

Je commence par initialiser mes variables : la recherche sur un nom d’artiste, le titre de ma playlist, le nombre de top titres des artistes similaires et le nombre de recommandations pour ces artistes. J’utilise la fonction time pour horodater ma playlist

search="quicksand"
timestr = time.strftime("%Y%m%d")
playlistname=timestr+"_related_"+search

Je peux maintenant créer ma playlist. Je vérifie d’abord que mon token est valide puis j’accède à l’API avec la fonction spotipy.Spotify(). Il ne me reste plus qu’à créer la playlist avec la fonction user_playlist_create(). Je stocke l’ID de la playlist dans une variable pour plus tard..

if token:
     sp = spotipy.Spotify(auth=token)
     sp.trace = False

     # Création de la playlist
     playlist=sp.user_playlist_create('erwan.lenagard',name=playlistname, public=publicOrprivate)
     playlist_id= str(playlist['id'])
 
else:
     print("Can't get token for", username)

Etape 4 – Ajouter les titres recommandés

final_top_track=[]
final_top_track_noduplicates=[]
tmp_top_track=[]
ntoptrack=3 
nb_recos=3

if token:
     #on cherche l'artiste demandé
     results_search=sp.search(search, type='artist', limit=1)
     artistid=results_search['artists']['items'][0]['uri']
     print(artistid)
     related = sp.artist_related_artists(artistid)
     # on cherche les artistes associés 
     for artistrelated in related['artists']:
           artistrelated_id = artistrelated['id']
           artistrelated_uri=artistrelated['uri']
           #Pour chaque artiste lié on récupère un nombre de chanson recommandées (pas forcément de cet artiste)
           reco=sp.recommendations(market='fr', seed_artists=[artistrelated_uri], limit=nb_recos)
           for trackreco in reco['tracks'] : 
                trackreco_id=["spotify:track:" + trackreco['id']]
                final_top_track.append(trackreco_id)
 
           #pour chaque artiste lié, on récupère ses 10 tops tracks
           result=sp.artist_top_tracks(artistrelated_id, country='FR')
           for toptrack in result['tracks']:
                trackid=["spotify:track:" + toptrack['id']]
                tmp_top_track.append(trackid)
                shuffle(tmp_top_track)
 
           # après les avoir mélangées aléatoirement, on en pioche 3
           for item in tmp_top_track[:3]:
                final_top_track.append(item)
 
     #on supprime les doublons dans la liste de chanson 
      [final_top_track_noduplicates.append(item) for item in final_top_track if item not in final_top_track_noduplicates]
      shuffle(final_top_track_noduplicates)
 
      #on ajoute les titres à la playlist. Au final, pour chaque artiste associé à la recherche, 
      # on a 3 tops titres + 3 recommendations d'autres artistes moins les doublons
      for toptrack in final_top_track_noduplicates:
           sp.user_playlist_add_tracks('erwan.lenagard', playlist_id, toptrack)
           print(toptrack)
           print(len(final_top_track_noduplicates), " titres ajoutés à la playlist")


else:
      print("Can't get token for", username)

 

La première étape consiste à récupérer l’ID d’un artiste à l’aide du moteur de recherche Spotify. A l’étape précédente, nous avons initialisé une variable search contenant le nom ‘quicksand’.  La fonction search() nous retourne une série de résultats de recherche, que nous allons limiter à un seul artiste.

results_search=sp.search(search, type='artist', limit=1)
artistid=results_search['artists']['items'][0]['uri']
print(artistid)

>>> spotify:artist:3r32a6mMdoPaSP1C7kYhMc

Dans un deuxième temps nous récupérons la liste des artistes similaires à Quicksand à l’aide de la fonction artist_related_artists(). La documentation Spotify présente un exemple de réponse API. Pour chaque artiste similaire à Quicksand, nous demandons à Spotify de nous recommander 3 morceaux disponibles pour le marché français. A noter que le paramètre seed_artists peut contenir une liste de 5 artistes.

related = sp.artist_related_artists(artistid)

ntoptrack=3 
nb_recos=3

for artistrelated in related['artists']:
          artistrelated_id=artistrelated['id'] 
          artistrelated_uri=artistrelated['uri']
          reco=sp.recommendations(market='fr', seed_artists=[artistrelated_uri], limit=nb_recos)

Les paramètres de la fonction recommendations() peuvent être affinés, en ajoutant des critères concernant le type de morceau et en leur attribuant des seuils min / max ou target. Par exemple, si je veux des morceaux énergiques, plutôt dansants, positifs mais pas trop intenses :

reco=sp.recommendations(market='fr', seed_artists=[artistrelated_uri], limit=nb_recos, min_energy=0.7, target_danceability=0.7, min_valence=0.5, max_loudness=-5)

Ensuite, nous ajoutons chaque ID de morceau recommandé dans un tableau. Je formate ces ID sous forme d’URI Spotify afin de faciliter l’ajout dans la playlist à la fin du script.

 for trackreco in reco['tracks'] : 
     trackreco_id=["spotify:track:" + trackreco['id']]
     final_top_track.append(trackreco_id)

Maintenant, nous allons récupérer les titres populaires des artistes similaires à Quicksand à l’aide de la fonction artist_top_tracks(). Spotify en retourne 10 par défaut, et nous allons en sélectionner 3 aléatoirement.

result=sp.artist_top_tracks(artistrelated_id, country='FR')
 for toptrack in result['tracks']:
     trackid=["spotify:track:" + toptrack['id']]
     tmp_top_track.append(trackid)
     shuffle(tmp_top_track)

 

Je supprime ensuite les doublons possibles dans ma liste de chansons et je mélange aléatoirement la liste.

[final_top_track_noduplicates.append(item) for item in final_top_track if item not in final_top_track_noduplicates]
shuffle(final_top_track_noduplicates)

 

Enfin, il ne me reste plus qu’à parcourir ma liste de chanson et de les ajouter à ma playlist à l’aide de la fonction user_playlist_add_tracks(). A noter que cette étape pourrait être optimisée puisque Spotify accepte qu’on lui transmette les URIs par centaine.

for toptrack in final_top_track_noduplicates:
     sp.user_playlist_add_tracks('erwan.lenagard', playlist_id, toptrack)

Tadam ! Ca fait plusieurs semaines que j’utilise ce moyen pour me concocter des playlists d’artistes que je découvre, et je dois dire que le résultat est assez bluffant. En tous cas, l’API est très facile à prendre en main !

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *