Support for playlist management (v2)

mopidy_spotify/browse.py

@@ -234,6 +234,8 @@ def _browse_your_music(web_client, variant):
             ]
         )
         if variant == "tracks":
+            # TODO: without check_playable=False this will hide unplayable
+            # tracks; this will bite us when implementing library editing.
             return list(translator.web_to_track_refs(items))
         else:
             return list(translator.web_to_album_refs(items))

mopidy_spotify/playlists.py

@@ -1,16 +1,21 @@
 import logging
+import math
+import time
 
 from mopidy import backend
 
 import spotify
-from mopidy_spotify import translator, utils
+from mopidy_spotify import translator, utils, web, Extension
 
 _sp_links = {}
 
 logger = logging.getLogger(__name__)
 
 
 class SpotifyPlaylistsProvider(backend.PlaylistsProvider):
+    # Maximum number of items accepted by the Spotify Web API
+    _chunk_size = 100
+
     def __init__(self, backend):
         self._backend = backend
         self._timeout = self._backend._config["spotify"]["timeout"]
@@ -40,13 +45,87 @@ def lookup(self, uri):
         with utils.time_logger(f"playlists.lookup({uri!r})", logging.DEBUG):
             return self._get_playlist(uri)
 
-    def _get_playlist(self, uri, as_items=False):
+    def _get_playlist(self, uri, as_items=False, with_owner=False):
         return playlist_lookup(
             self._backend._session,
             self._backend._web_client,
             uri,
             self._backend._bitrate,
             as_items,
+            with_owner,
+        )
+
+    @staticmethod
+    def _span(p, xs):  # like haskell's Data.List.span
+        i = next((i for i, v in enumerate(xs) if not p(v)), len(xs))
+        return xs[:i], xs[i:]
+
+    def _patch_playlist(self, playlist, operations):
+        # Note: We need two distinct delta_f/t to be able to keep track of move
+        # operations.  This is because when moving multiple (distinct) sections
+        # so their old and new positions overlap, one bound can be inside the
+        # range and the other outide. Then, only the inside bound must add
+        # delta_f/t, while the outside one must not.
+        delta_f = 0
+        delta_t = 0
+        unwind_f = []
+        unwind_t = []
+        for op in operations:
+            # from the list of "active" mov-deltas, split off the ones newly
+            # outside the range and neutralize them:
+            ended_ranges_f, unwind_f = self._span(
+                lambda e: e[0] < op.frm, unwind_f
+            )
+            ended_ranges_t, unwind_t = self._span(
+                lambda e: e[0] < op.to, unwind_t
+            )
+            delta_f -= sum((v for k, v in ended_ranges_f))
+            delta_t -= sum((v for k, v in ended_ranges_t))
+
+            length = len(op.tracks)
+            if op.op == "-":
+                web.remove_tracks_from_playlist(
+                    self._backend._web_client,
+                    playlist,
+                    op.tracks,
+                    op.frm + delta_f,
+                )
+                delta_f -= length
+                delta_t -= length
+            elif op.op == "+":
+                web.add_tracks_to_playlist(
+                    self._backend._web_client,
+                    playlist,
+                    op.tracks,
+                    op.frm + delta_f,
+                )
+                delta_f += length
+                delta_t += length
+            elif op.op == "m":
+                web.move_tracks_in_playlist(
+                    self._backend._web_client,
+                    playlist,
+                    range_start=op.frm + delta_f,
+                    insert_before=op.to + delta_t,
+                    range_length=length,
+                )
+                # if we move right, the delta is active in the range (op.frm, op.to),
+                # when we move left, it's in the range (op.to, op.frm+length)
+                position = op.to if op.frm < op.to else op.frm + length
+                amount = length * (-1 if op.frm < op.to else 1)
+                # While add/del deltas will be active for the rest of the
+                # playlist, mov deltas only affect the range of tracks between
+                # their old end new positions. We must undo them once we get
+                # outside this range, so we store the position at which point
+                # to subtract the amount again.
+                unwind_f.append((position, amount))
+                unwind_t.append((position, amount))
+                delta_f += amount
+                delta_t += amount
+
+    def _replace_playlist(self, playlist, tracks):
+        web.replace_playlist(
+            self._backend._web_client, playlist, tracks, self._chunk_size
         )
 
     def refresh(self):
@@ -65,16 +144,114 @@ def refresh(self):
         self._loaded = True
 
     def create(self, name):
-        pass  # TODO
+        logger.info(f"Creating playlist {name}")
+        uri = web.create_playlist(self._backend._web_client, name)
+        self._get_flattened_playlist_refs()
+        return self.lookup(uri) if uri else None
 
     def delete(self, uri):
-        pass  # TODO
+        logger.info(f"Deleting playlist {uri}")
+        ok = web.delete_playlist(self._backend._web_client, uri)
+        self._get_flattened_playlist_refs()
+        return ok
+
+    @staticmethod
+    def _len_replace(playlist, n=_chunk_size):
+        return math.ceil(len(playlist.tracks) / n)
+
+    @staticmethod
+    def _is_spotify_track(track_uri):
+        return track_uri.startswith("spotify:track:")
 
     def save(self, playlist):
-        pass  # TODO
+        saved_playlist = self._get_playlist(playlist.uri, with_owner=True)
+        if not saved_playlist:
+            return
+
+        saved_playlist, owner = saved_playlist
+        # We limit playlist editing to the user's own playlists, since mopidy
+        # mangles the names of other people's playlists.
+        if owner and owner != self._backend._web_client.user_id:
+            logger.error(
+                f"Refusing to modify someone else's playlist ({playlist.uri})"
+            )
+            return
+
+        # We cannot add or (easily) remove spotify:local: tracks, so refuse
+        # editing if the current playlist contains such tracks.
+        if any(
+            (t.uri.startswith("spotify:local:") for t in saved_playlist.tracks)
+        ):
+            logger.error(
+                "Cannot modify playlist containing 'Spotify Local Files'."
+            )
+            for t in saved_playlist.tracks:
+                if t.uri.startswith("spotify:local:"):
+                    logger.error(f"{t.name} ({t.uri})")
+            return
+
+        new_tracks = [track.uri for track in playlist.tracks]
+        cur_tracks = [track.uri for track in saved_playlist.tracks]
+
+        if any((not self._is_spotify_track(t) for t in new_tracks)):
+            new_tracks = list(filter(self._is_spotify_track, new_tracks))
+            logger.warning(
+                "Cannot add non-spotify tracks to spotify playlist; skipping those."
+            )
+
+        operations = utils.diff(cur_tracks, new_tracks, self._chunk_size)
+
+        # calculate number of operations required for each strategy:
+        ops_patch = len(operations)
+        ops_replace = self._len_replace(playlist)
+
+        try:
+            if ops_replace < ops_patch:
+                self._replace_playlist(saved_playlist, new_tracks)
+            else:
+                self._patch_playlist(saved_playlist, operations)
+        except RuntimeError as e:
+            logger.error(f"Failed to save Spotify playlist: {e}")
+            # In the unlikely event that we used the replace strategy, and the
+            # first PUT went through but the following POSTs didn't, we have
+            # truncated the playlist. At this point, we still have the playlist
+            # data available, so we write it to an m3u file as a last resort
+            # effort for the user to recover from.
+            if ops_replace < ops_patch:
+                safe_name = playlist.name.translate(
+                    str.maketrans(" @`!\"#$%&'()*+;[{<\\|]}>^~/?", "_" * 27)
+                )
+                filename = (
+                    Extension.get_data_dir(self._backend._config)
+                    / f"{safe_name}-{playlist.uri}-{time.time()}.m3u"
+                )
+                with open(filename, "wb") as f:
+                    f.write(b"#EXTM3U\n#EXTENC: UTF-8\n\n")
+                    for track in playlist.tracks:
+                        length = int(track.length / 1000)
+                        artists = ", ".join(a.name for a in track.artists)
+                        f.write(
+                            f"#EXTINF:{length},{artists} - {track.name}\n"
+                            f"{track.uri}\n\n".encode("utf-8")
+                        )
+                logger.error(f'Created backup in "{filename}"')
+            return None
+
+        # Playlist rename logic
+        if playlist.name != saved_playlist.name:
+            logger.info(
+                f"Renaming playlist [{saved_playlist.name}] to [{playlist.name}]"
+            )
+            web.rename_playlist(
+                self._backend._web_client, playlist.uri, playlist.name
+            )
+
+        return self.lookup(saved_playlist.uri)
 
 
-def playlist_lookup(session, web_client, uri, bitrate, as_items=False):
+def playlist_lookup(
+    session, web_client, uri, bitrate, as_items=False, with_owner=False
+):
     if web_client is None or not web_client.logged_in:
         return
 
@@ -90,6 +267,9 @@ def playlist_lookup(session, web_client, uri, bitrate, as_items=False):
         username=web_client.user_id,
         bitrate=bitrate,
         as_items=as_items,
+        # Note: we are not filtering out (currently) unplayable tracks;
+        # otherwise they would be removed when editing the playlist.
+        check_playable=False,
     )
     if playlist is None:
         return
@@ -109,4 +289,7 @@ def playlist_lookup(session, web_client, uri, bitrate, as_items=False):
             except ValueError as exc:
                 logger.info(f"Failed to get link {track.uri!r}: {exc}")
 
+    if with_owner:
+        owner = web_playlist.get("owner", {}).get("id")
+        return playlist, owner
     return playlist

mopidy_spotify/translator.py

@@ -214,6 +214,7 @@ def to_playlist(
     bitrate=None,
     as_ref=False,
     as_items=False,
+    check_playable=True,
 ):
     ref = to_playlist_ref(web_playlist, username)
     if ref is None or as_ref:
@@ -224,12 +225,18 @@ def to_playlist(
         return
 
     if as_items:
-        return list(web_to_track_refs(web_tracks))
+        return list(
+            web_to_track_refs(web_tracks, check_playable=check_playable)
+        )
 
-    tracks = [
-        web_to_track(web_track.get("track", {}), bitrate=bitrate)
+    tracks = (
+        web_to_track(
+            web_track.get("track", {}),
+            bitrate=bitrate,
+            check_playable=check_playable,
+        )
         for web_track in web_tracks
-    ]
+    )
     tracks = [t for t in tracks if t]
 
     return models.Playlist(uri=ref.uri, name=ref.name, tracks=tracks)
@@ -315,11 +322,14 @@ def web_to_album(web_album):
     ]
     artists = [a for a in artists if a]
 
-    return models.Album(uri=ref.uri, name=ref.name, artists=artists)
+    # Note: date can by YYYY-MM-DD, YYYY-MM or YYYY.
+    date = web_album.get("release_date", "").split("-")[0] or None
+
+    return models.Album(uri=ref.uri, name=ref.name, artists=artists, date=date)
 
 
-def web_to_track(web_track, bitrate=None):
-    ref = web_to_track_ref(web_track)
+def web_to_track(web_track, bitrate=None, *, check_playable=True):
+    ref = web_to_track_ref(web_track, check_playable=check_playable)
     if ref is None:
         return
 

mopidy_spotify/utils.py

@@ -1,4 +1,6 @@
 import contextlib
+import difflib
+import functools
 import logging
 import time
 
@@ -33,3 +35,71 @@ def time_logger(name, level=TRACE):
 
 def flatten(list_of_lists):
     return [item for sublist in list_of_lists for item in sublist]
+
+
+class op:
+    def __init__(self, op, tracks, frm, to=0):
+        self.op = op
+        self.tracks = tracks
+        self.frm = frm
+        self.to = to
+
+    def __repr__(self):
+        length = len(self.tracks)
+        if length < 1:
+            return "<invalid op()>"
+        first = self.tracks[0].split(":")[-1]
+        last = self.tracks[-1].split(":")[-1]
+        tracks = f"{first}...{last}" if length > 1 else first
+        action = {"-": "delete", "+": "insert", "m": "move"}
+        pos = f"{self.frm} to {self.to}" if self.op == "m" else self.frm
+        return f"<{action.get(self.op)} {length} tracks [{tracks}] at {pos}>"
+
+
+def _is_move(op1, op2):
+    return op1.op == "-" and op2.op == "+" and op1.tracks == op2.tracks
+
+
+def _op_split(o, chunksize):
+    def partition(o, n):
+        def inc(m, i):
+            return m + i if o.op == "-" or o.op == "m" else m
+
+        for i in range(0, len(o.tracks), n):
+            yield op(o.op, o.tracks[i : i + n], inc(o.frm, i), inc(o.to, i))
+
+    return list(partition(o, chunksize)) if o.op != "m" else [o]
+
+
+def diff(old, new, chunksize=100):
+    # first, apply python's built-in diff algorithm, remove unmodified ranges,
+    # split replacements into seperate insertions and deletions and transform
+    # the data structure into op-objects:
+    ops = []
+    for tag, i1, i2, j1, j2 in difflib.SequenceMatcher(
+        a=old, b=new, autojunk=False
+    ).get_opcodes():
+        if tag in ("insert", "replace"):
+            ops.append(op("+", new[j1:j2], i1))
+        if tag in ("delete", "replace"):
+            ops.append(op("-", old[i1:i2], i1))
+
+    # then, merge pairs of insertions and deletions into a transposition:
+    # for this, we start from the rightmost element,
+    for R in reversed(range(len(ops))):
+        # and compare against all elements on its left
+        for L in reversed(range(R)):
+            # if we found a pair of ins/del that can be combined,
+            if _is_move(ops[R], ops[L]) or _is_move(ops[L], ops[R]):
+                # replace the left item with a mov
+                del_at = ops[L].frm if ops[L].op == "-" else ops[R].frm
+                ins_at = ops[L].frm if ops[L].op == "+" else ops[R].frm
+                ops[L] = op("m", ops[L].tracks, del_at, ins_at)
+                # and delete the right one (this is why we go right-to-left)
+                del ops[R]
+                break  # check the next outer element
+
+    # finally, split add/del ops to work on <= 100 tracks (but not mov ops):
+    ops = functools.reduce(lambda xs, x: xs + _op_split(x, chunksize), ops, [])
+
+    return ops