Imprimer la liste de lecture à partir de Google Play Music

Je souhaite imprimer une liste de chansons (avec l'artiste, l'album, le classement et, si possible, le nombre de lectures et la durée) à partir de mon compte Google Play Music .

Il n'y a pas de moyen facile de faire cela à partir de l'application. Faire des écrans d’impression pendant que je feuillette une longue liste de chansons n’est pas tenable.

Je serais heureux avec une exportation de données vers un format standard (texte brut, CSV, XML, etc.) que je peux manipuler moi-même.

Aucune suggestion?

En modifiant la réponse de darkliquid , j’ai proposé ce qui suit qui permet d’ enregistrer plusieurs listes de lecture à la fois .

Instructions:

1. Allez à la page Vos playlists .
2. Collez le code JavaScript ci-dessous dans votre console.
3. Cliquez sur une liste de lecture que vous souhaitez enregistrer en texte.
4. Une fois sur la page de la liste de lecture, faites défiler vers le bas relativement lentement.
5. Une fois que vous avez fait défiler l'écran vers le bas, revenez à la page des listes de lecture (comme à l'étape 1) à l'aide du menu ou du bouton retour de votre navigateur.
6. Répétez les étapes 3 à 5 pour toutes les listes de lecture que vous souhaitez enregistrer en texte.
7. Une fois que vous avez fait cela pour toutes les listes de lecture que vous souhaitez enregistrer en texte, vous pouvez taper JSON.stringify(tracklistObj, null, '\t')(changer le '\t'en ' 'si vous voulez une indentation minimale) ou tracklistObjsi vous voulez simplement que l'objet JavaScript le manipule à votre façon. Si vous souhaitez le trier, exécutez la commande Object.values(tracklistObj).forEach(a => a.sort()) avant d' appeler la JSON.stringifycommande.

Veillez à ne pas actualiser la page avant d'avoir terminé tout ce que vous souhaitez faire, sinon vous devrez redémarrer à partir de l'étape 1.

// Setup
var tracklistObj = {},
    currentPlaylist,
    checkIntervalTime = 100,
    lastTime;

// Process the visible tracks
function getVisibleTracks() {
    var playlist = document.querySelectorAll('.song-table tr.song-row');
    for(var i = 0; i < playlist.length ; i++) { 
        var l = playlist[i];

        var title = l.querySelector('td[data-col="title"] .column-content');
        if(title !== null)
            title = title.textContent;

        var artist = l.querySelector('td[data-col="artist"] .column-content');
        if(artist !== null)
            artist = artist.textContent;

        var duration = l.querySelector('td[data-col="duration"] span');
        if(duration !== null)
            duration = duration.textContent;

        var album = l.querySelector('td[data-col="album"] .column-content');
        if(album !== null)
            album = album.textContent;

        var playCount = l.querySelector('td[data-col="play-count"] span');
        if(playCount !== null)
            playCount = playCount.textContent;

        var rating = l.querySelector('td[data-col="rating"]');
        if(rating !== null)
            rating = rating.textContent;

        // Add it if it doesn't exist already
        if(tracklistObj[currentPlaylist] && !tracklistObj[currentPlaylist].includes(artist + " - " + title)) {
            tracklistObj[currentPlaylist].push(artist + " - " + title);

            if(printTracksToConsole) {
                console.log(artist + ' - ' + title);
            }
        }
    }
}

// Listen for page changes
window.onhashchange = function(e) {
    currentPlaylist = null; 

    var doneLoading = setInterval(function() {
        var playListName = document.querySelector('.gpm-detail-page-header h2[slot="title"]');
        if(playListName != null) {
            currentPlaylist = playListName.innerText;
            if(tracklistObj[currentPlaylist] === undefined) {
                tracklistObj[currentPlaylist] = [];
            }

            console.log("===================================");
            console.log("Adding to playlist " + currentPlaylist);

            getVisibleTracks();

            clearInterval(doneLoading);
        }
    }, 100);

}

// Check for new tracks every so often
setInterval(function() {
    getVisibleTracks();
}, checkIntervalTime);

// Whether or not to print the tracks obtained to the console
var printTracksToConsole = false;

Vous pouvez également imprimer les noms de piste sur la console au fur et à mesure en passant printTracksToConsoleà true(vous devez le faire avant l'étape 3).

Notez que vous pouvez probablement ignorer toutes les erreurs GET et POST dans la console (celles-ci sont générées par Play Music lui-même, et non par ce script).

Notez également que la configuration actuellement de seulement donner Artist - Track name, mais vous pouvez facilement modifier la ligne qui a tracklistObj[currentPlaylist].push(artist + " - " + title);avec album, playCount, durationou rating, et / ou tout autre forme que vous voulez (y compris le format CSV si vous le s'il vous plaît).

Exemple de sortie (toutes les listes de lecture Google Play que j'ai actuellement) avec les paramètres par défaut. Il a fallu environ 5 minutes au total pour naviguer dans chacune des 32 listes de lecture, les faire défiler, puis convertir le résultat en texte.

_{PS Vous pourriez être intéressé par l’utilisation d’un site appelé « Régler ma musique» pour créer des listes de lecture YouTube (mais la création de listes de lecture est limitée à 10 par jour) afin que vos amis puissent écouter vos listes de lecture Google. Si vous faites cela, vous voudrez probablement utiliser quelque chose comme TextMechanic pour supprimer les guillemets et .mp3la liste en sortie.}

(Mis à jour le 2016-05-09, plus robuste que la réponse principale actuelle)

Si vous avez juste besoin de sauvegarder quelques playlists, vous pouvez simplement utiliser mon extrait de code Javascript ci-dessous. Cet extrait de code peut enregistrer toutes les listes telles qu'elles apparaissent sur la page Web. Il fonctionne donc également pour toutes les vues de bibliothèque de chansons / albums / artistes. J'ai énuméré deux autres alternatives à la fin de cette réponse.

1. Accédez à la page https://play.google.com/music/listen#/all (ou à votre playlist).

2. Ouvrez une console de développeur (F12 pour Chrome). Collez le code ci-dessous dans la console.

3. Toutes les chansons grattées sont stockées dans l' allsongsobjet et une version texte de la liste est copiée dans le Presse-papiers. Je recommande de courir songsToText("all",true)après pour obtenir toutes les informations CSV. Exécuter copy(outText)manuellement si la copie du presse-papiers ne fonctionnait pas du premier coup.

Code (dernière version le 10 mai 2016, rév. 30):

var allsongs = []
var outText = "";
var songsToText = function(style, csv, likedonly){
  if (style === undefined){
    console.log("style is undefined.");
    return;
  }
  var csv = csv || false; // defaults to false
  var likedonly = likedonly || false; // defaults to false
  if (likedonly) {
    console.log("Only selecting liked songs");
  }
  if (style == "all" && !csv){
    console.log("Duration, ratings, and playcount will only be exported with the CSV flag");
  }
  outText = "";
  if (csv) {
    if (style == "all") {
      //extra line
      outText = "artist,album,title,duration,playcount,rating,rating_interpretation" + "\n";
    } else if (style == "artist") {
    } else if (style == "artistsong") {
    } else if (style == "artistalbum") {
    } else if (style == "artistalbumsong") {
    } else {
      console.log("style not defined");
    }
  }
  var numEntries = 0;
  var seen = {};
  for (var i = 0; i < allsongs.length; i++) {
    var curr = "";
    var properTitle = allsongs[i].title.replace(/[\n\r!]/g, '').trim();
    if (!likedonly || (likedonly && allsongs[i].rating >= 5)){
      if (csv) {
        if (style == "all") {
          //extra line
          curr += '"' + allsongs[i].artist.replace(/"/g, '""').trim() + '"' + ",";
          curr += '"' + allsongs[i].album.replace(/"/g, '""').trim() + '"' + ",";
          curr += '"' + properTitle.replace(/"/g, '""').trim() + '"' + ",";
          curr += '"' + allsongs[i].duration.replace(/"/g, '""').trim() + '"' + ",";
          curr += '"' + allsongs[i].playcount.replace(/"/g, '""').trim() + '"' + ",";
          curr += '"' + allsongs[i].rating.replace(/"/g, '""').trim() + '"' + ",";
          curr += '"' + allsongs[i].rating_interpretation.replace(/"/g, '""').trim() + '"';
        } else if (style == "artist") {
          curr += '"' + allsongs[i].artist.replace(/"/g, '""').trim() + '"';
        } else if (style == "artistsong") {
          curr += '"' + allsongs[i].artist.replace(/"/g, '""').trim() + '"' + ",";
          curr += '"' + properTitle.replace(/"/g, '""').trim() + '"';
        } else if (style == "artistalbum") {
          curr += '"' + allsongs[i].artist.replace(/"/g, '""').trim() + '"' + ",";
          curr += '"' + allsongs[i].album.replace(/"/g, '""').trim() + '"';
        } else if (style == "artistalbumsong") {
          curr += '"' + allsongs[i].artist.replace(/"/g, '""').trim() + '"' + ",";
          curr += '"' + allsongs[i].album.replace(/"/g, '""').trim() + '"' + ",";
          curr += '"' + properTitle.replace(/"/g, '""').trim() + '"';
        } else {
          console.log("style not defined");
        }
      } else {
        if (style == "all"){
          curr = allsongs[i].artist + " - " + allsongs[i].album + " - " + properTitle + " [[playcount: " + allsongs[i].playcount + ", rating: " + allsongs[i].rating_interpretation + "]]" ;
        } else if (style == "artist"){
          curr = allsongs[i].artist;
        } else if (style == "artistalbum"){
          curr = allsongs[i].artist + " - " + allsongs[i].album;
        } else if (style == "artistsong"){
          curr = allsongs[i].artist + " - " + properTitle;
        } else if (style == "artistalbumsong"){
          curr = allsongs[i].artist + " - " + allsongs[i].album + " - " + properTitle;
        } else {
          console.log("style not defined");
        }
      }
      if (!seen.hasOwnProperty(curr)){ // hashset
        outText = outText + curr + "\n";
        numEntries++;
        seen[curr] = true;
      } else {
        //console.log("Skipping (duplicate) " + curr);
      }
    }
  }
  console.log("=============================================================");
  console.log(outText);
  console.log("=============================================================");
  try {
    copy(outText);
    console.log("copy(outText) to clipboard succeeded.");
  } catch (e) {
    console.log(e);
    console.log("copy(outText) to clipboard failed, please type copy(outText) on the console or copy the log output above.");
  }
  console.log("Done! " + numEntries + " lines in output. Used " + numEntries + " unique entries out of " + allsongs.length + ".");
};
var scrapeSongs = function(){
  var intervalms = 1; //in ms
  var timeoutms = 3000; //in ms
  var retries = timeoutms / intervalms;
  var total = [];
  var seen = {};
  var topId = "";
  document.querySelector("#mainContainer").scrollTop = 0; //scroll to top
  var interval = setInterval(function(){
    var songs = document.querySelectorAll("table.song-table tbody tr.song-row");
    if (songs.length > 0) {
      // detect order
      var colNames = {
        index: -1,
        title: -1,
        duration: -1,
        artist: -1,
        album: -1,
        playcount: -1,
        rating: -1
        };
      for (var i = 0; i < songs[0].childNodes.length; i++) {
        colNames.index = songs[0].childNodes[i].getAttribute("data-col") == "index" ? i : colNames.index;
        colNames.title = songs[0].childNodes[i].getAttribute("data-col") == "title" ? i : colNames.title;
        colNames.duration = songs[0].childNodes[i].getAttribute("data-col") == "duration" ? i : colNames.duration;
        colNames.artist = songs[0].childNodes[i].getAttribute("data-col") == "artist" ? i : colNames.artist;
        colNames.album = songs[0].childNodes[i].getAttribute("data-col") == "album" ? i : colNames.album;
        colNames.playcount = songs[0].childNodes[i].getAttribute("data-col") == "play-count" ? i : colNames.playcount;
        colNames.rating = songs[0].childNodes[i].getAttribute("data-col") == "rating" ? i : colNames.rating;
      }
      // check if page has updated/scrolled
      var currId = songs[0].getAttribute("data-id");
      if (currId == topId){ // page has not yet changed
        retries--;
        scrollDiv = document.querySelector("#mainContainer");
        isAtBottom = scrollDiv.scrollTop == (scrollDiv.scrollHeight - scrollDiv.offsetHeight)
        if (isAtBottom || retries <= 0) {
          clearInterval(interval); //done
          allsongs = total;
          console.log("Got " + total.length + " songs and stored them in the allsongs variable.");
          console.log("Calling songsToText with style all, csv flag true, likedonly false: songsToText(\"all\", false).");
          songsToText("artistalbumsong", false, false);
        }
      } else {
        retries = timeoutms / intervalms;
        topId = currId;
        // read page
        for (var i = 0; i < songs.length; i++) {
          var curr = {
            dataid: songs[i].getAttribute("data-id"),
            index: (colNames.index != -1 ? songs[i].childNodes[colNames.index].textContent : ""),
            title: (colNames.title != -1 ? songs[i].childNodes[colNames.title].textContent : ""),
            duration: (colNames.duration != -1 ? songs[i].childNodes[colNames.duration].textContent : ""),
            artist: (colNames.artist != -1 ? songs[i].childNodes[colNames.artist].textContent : ""),
            album: (colNames.album != -1 ? songs[i].childNodes[colNames.album].textContent : ""),
            playcount: (colNames.playcount != -1 ? songs[i].childNodes[colNames.playcount].textContent : ""),
            rating: (colNames.rating != -1 ? songs[i].childNodes[colNames.rating].getAttribute("data-rating") : ""),
            rating_interpretation: "",
            }
          if(curr.rating == "undefined") {
            curr.rating_interpretation = "never-rated"
          }
          if(curr.rating == "0") {
            curr.rating_interpretation = "not-rated"
          }
          if(curr.rating == "1") {
            curr.rating_interpretation = "thumbs-down"
          }
          if(curr.rating == "5") {
            curr.rating_interpretation = "thumbs-up"
          }
          if (!seen.hasOwnProperty(curr.dataid)){ // hashset
            total.push(curr);
            seen[curr.dataid] = true;
          }
        }
        songs[songs.length-1].scrollIntoView(true); // go to next page
      }
    }
  }, intervalms);
};
scrapeSongs();
// for the full CSV version you can now call songsToText("all", true);

Le dernier code sur Github (Gist) ici: https://gist.github.com/jmiserez/c9a9a0f41e867e5ebb75

• Si vous souhaitez que la sortie soit au format texte, vous pouvez appeler la fonction songsToText (). Vous pouvez sélectionner un style, choisir le format et, si seuls les morceaux appréciés / optimisés doivent être exportés. La liste résultante sera ensuite collée dans le presse-papier. Les styles sont all, artist, artistalbum, artistsong, artistalbumsong. CSV donnera un fichier CSV et peut être omis (faux par défaut). Likedonly peut être omis (par défaut, false) ou défini sur true, et filtrera toutes les chansons ayant une note supérieure ou égale à 5. Par exemple:

  • songsToText("all",true,false) exportera toutes les chansons au format csv.
  • songsToText("all",true,true) exportera uniquement les chansons préférées au format csv.
  • songsToText("artistsong",false,false) exportera toutes les chansons sous forme de texte.

• Vous pouvez ensuite coller les données où bon vous semble, par exemple http://www.ivyishere.org/ si vous souhaitez ajouter les chansons ou les albums à votre compte Spotify. Pour que Ivy reconnaisse les albums complets, utilisez le style "artistalbum". Pour les chansons, utilisez le style "artistes".

À propos de l'extrait: Ceci est basé sur la réponse originale de Michael Smith, mais est un peu plus robuste. J'ai apporté les améliorations suivantes:

• Fonctionne sur les playlists ainsi que sur la bibliothèque. Toutes les colonnes manquantes sont ignorées et l'ordre est déterminé. Il devrait donc fonctionner sur presque toutes les listes de chansons de Google Music.

• Il s'arrête lorsqu'il atteint le bas (détecte la position du défilement) ou après le délai spécifié. Le délai d'attente est là pour empêcher une boucle sans fin au cas où le code de détection de défilement serait désactivé de quelques pixels.

• Il est beaucoup plus rapide (intervalle toutes les 1 ms), mais attend si les données ne sont pas prêtes (jusqu’à l’expiration du délai spécifié, actuellement de 3 secondes).

• Effectue la déduplication en cours de fonctionnement et sur la sortie.

• Gathers ratings: "undefined" n'est jamais noté, "0" n'est pas noté (c.-à-d. Une fois noté, puis supprimé), "1" correspond au pouce vers le bas et "5" au pouce levé.

En plus des améliorations de base, il formate également le texte et le copie dans le presse-papiers. Vous pouvez également obtenir les données au format CSV si vous le souhaitez, en exécutant la songsToTextfonction une seconde fois.

Alternatives:

1. Si vous avez besoin d'une API Python, consultez le projet non officiel d'API Google Music .

2. Si vous avez des tonnes de listes de lecture et que vous souhaitez toutes les exporter en une seule fois, essayez l' exportateur de listes de lecture gmusic-scripts qui peut le faire (Python utilise le projet d'API non officiel).

Si cela ne vous dérange pas d'exécuter un peu de code javascript dans la console de développement de votre navigateur, vous pouvez extraire des informations de la page de la manière suivante (testé uniquement dans Chrome):

var playlist = document.querySelectorAll('.song-table tr.song-row');
for(var i =0; i<playlist.length ; i++) { 
  var l = playlist[i]; 
  var title = l.querySelector('td[data-col="title"] .column-content').textContent;
  var artist = l.querySelector('td[data-col="artist"] .column-content').textContent;
  var album = l.querySelector('td[data-col="album"] .column-content').textContent;
  console.log(artist + ' --- ' + title + ' --- ' + album); 
}

Ceci imprimera sur la console une liste de la plupart des chansons actuellement visibles dans la fenêtre. Vous aurez besoin de faire défiler et réexécutez-le pour obtenir plus. Pour le moment, je n'ai pas encore trouvé de moyen convenable de saisir l'info dans son intégralité, mais ce rapide piratage de 5 minutes est mieux que rien.

À l'aide de la réponse principale (à l'époque) et à la recherche d'une solution complète, j'ai créé le code suivant, qui fait défiler la liste de musique vers le bas et ajoute des objets JSON à un tableau au fur et à mesure.

Faute de savoir exactement quelles chansons sont visibles, le code les ajoute toutes, puis se dédoublent à la fin. (Testé uniquement dans Chrome.)

Pour utiliser: allez dans votre bibliothèque, où vous voyez votre liste complète de chansons, et lancez

var total = [];
var interval = setInterval(function(){
    var songs = document.querySelectorAll("table.song-table tbody tr.song-row");
    for (var i = 0; i < songs.length; i++) {
        total.push({name: songs[i].childNodes[0].textContent,
        length: songs[i].childNodes[1].textContent,
        artist: songs[i].childNodes[2].textContent,
        album: songs[i].childNodes[3].textContent,
        plays: songs[i].childNodes[4].textContent
        });
        songs[i].scrollIntoView(true);
    }
}, 800);

Quand cela arrive au bas de la page, lancez-le pour arrêter le défilement, dé-dupliquer le tableau et copier JSON dans le Presse-papiers.

clearInterval(interval);
for (var i = 0; i < total.length; i++) {
    for (var j = i + 1; j < total.length; j++) {
        if (total.hasOwnProperty(i) && total.hasOwnProperty(j) && total[i].name == total[j].name && total[j].artist == total[i].artist) {
            total.splice(j,1);
        }
    }
}
copy(total);

J'ai un JavaScript beaucoup plus court que vous pouvez coller dans la console. Au lieu de ré-exécuter le code, vous pouvez simplement faire défiler l'écran vers le bas et tous les albums qui apparaissent sont ajoutés. Ensuite, vous pouvez télécharger la liste de lecture sous forme de feuille de calcul.

Instructions

1. Allez ici: https://play.google.com/music/listen#/ap/auto-playlist-thumbs-up

2. Ouvrez les outils de développement (F12) et collez le code ci-dessous dans l' onglet Console .

3. Faites défiler pour que chaque album de la liste de lecture soit visible au moins une fois

4. Double-cliquez quelque part sur la page pour télécharger export-google-play.csv

5. Ouvrir export-google-play.csvdans Excel.

Code

alert("Please scroll through the playlist so that each album is visible once.\n" + 
      "Then double-click the page to export a spreadsheet.");
var albums = ["Artist,Album,Purchased"];

var addVisibleAlbums = function(){
    [].forEach.call(document.querySelectorAll(".song-row"), function(e){ 
        var albumNodes = [e.querySelector("td[data-col='artist']"), 
              e.querySelector("td[data-col='album']"),
              e.querySelector("td[data-col='title'] .title-right-items")];

        var albumString = albumNodes.map(function(s){ 
            return s.innerText.trim().replace(/,/g,""); 
        }).join(",");

        if(albums.indexOf(albumString) === -1){
            albums.push(albumString); console.log("Added: " + albumString)
        }
    });
}

var createCsv = function(){
    var csv = "data:text/csv;charset=utf-8,";
    albums.forEach(function(row){ csv += row + "\n"; }); 

    var uri = encodeURI(csv);
    var link = document.createElement("a");
    link.setAttribute("href", uri);
    link.setAttribute("download", "export-google-play.csv");
    document.body.appendChild(link);
    link.click(); 
    alert("Download beginning!")
}

document.body.addEventListener("DOMNodeInserted", addVisibleAlbums, false);
document.body.addEventListener("dblclick", createCsv, false);

Sortie

GitHub

J'ai modifié un peu l'approche de la réponse principale. Cela fonctionnait mieux pour moi avec la méthode copier / coller d'Ivy ( http://www.ivyishere.org/ivy ):

Étape 1 Ouvrez la liste de lecture de Google Music dans Chrome que vous souhaitez et collez-la dans la console:

document.querySelector('body.material').style.height = (document.querySelector('table.song-table tbody').getAttribute('data-count') * 100) + 'px';

Cela devrait entraîner le rendu de toute votre liste de lecture plutôt que seulement une partie.

Étape 2 Collez ce script dans la console:

var i, j, playlistString = '', playlist = document.querySelectorAll('.song-table tr.song-row');
for (i = 0, j = playlist.length; i < j; i++) {
    var track = playlist[i]; 
    var artist = track.querySelector('[href][aria-label]').textContent;
    var title = track.querySelector('td[data-col="title"]').textContent;
    playlistString += ('"' + artist + '", "' + title + '"\n');
}
console.log(playlistString);

Étape 3 Allez à Ivy et lorsque vous arrivez à l'étape 2, sélectionnez l'onglet Copier / Coller et collez la sortie de la console à cet endroit.

MODIFIER

Script mis à jour proposé par Alex Pedersen

Itérant sur le raffinement de samurauturetskys (je n'ai pas encore assez de réputation pour commenter son post). Je pense que le style de Googleplay a été mis à jour et que le script ci-dessous donne encore une jolie sortie.

var i, j, playlistString = '', playlist = document.querySelectorAll('.song-table tr.song-row');
for (i = 0, j = playlist.length; i < j; i++) {
    var track = playlist[i]; 
    var artist = track.querySelector('[href][aria-label]').textContent;
    var title = track.querySelector('span[class="column-content fade-out tooltip"]').textContent;
    playlistString += ('"' + artist + '", "' + title + '"\n');
}
console.log(playlistString);

Il vous suffit de faire Ctrl+ –jusqu'à ce que le texte soit très petit, puis de tout sélectionner. Cela fonctionne comme un charme sans scripts et applications.

Je viens de tomber sur cette question à la recherche de quelque chose de similaire.

Je suppose que votre meilleure option est de:

1. installer une application comme "Playlist Backup"
2. Exportez la liste de lecture Google Music vers un fichier texte avec cette application.
3. Renommez-le en .m3u avec une application FileManager (comme Ghost Commander)
4. Ouvrez la liste de lecture avec une autre application disposant de plus d'options (comme MusiXMatch).