Merge pull request #13 from mgoltzsche/playlist-support

Implement getPlaylists and getPlaylist endpoints

Author: BinaryBrain

beetsplug/beetstream/__init__.py

@@ -15,6 +15,7 @@
 
 """Beetstream is a Beets.io plugin that exposes SubSonic API endpoints."""
 from beets.plugins import BeetsPlugin
+from beets import config
 from beets import ui
 import flask
 from flask import g
@@ -39,6 +40,7 @@ def home():
 import beetsplug.beetstream.albums
 import beetsplug.beetstream.artists
 import beetsplug.beetstream.dummy
+import beetsplug.beetstream.playlists
 import beetsplug.beetstream.search
 import beetsplug.beetstream.songs
 import beetsplug.beetstream.users
@@ -55,6 +57,7 @@ def __init__(self):
             'reverse_proxy': False,
             'include_paths': False,
             'never_transcode': False,
+            'playlist_dir': '',
         })
 
     def commands(self):
@@ -75,6 +78,10 @@ def func(lib, opts, args):
 
             app.config['INCLUDE_PATHS'] = self.config['include_paths']
             app.config['never_transcode'] = self.config['never_transcode']
+            playlist_dir = self.config['playlist_dir']
+            if not playlist_dir:
+                playlist_dir = config['smartplaylist']['playlist_dir'].get()
+            app.config['playlist_dir'] = playlist_dir
 
             # Enable CORS if required.
             if self.config['cors']:

beetsplug/beetstream/dummy.py

@@ -41,20 +41,6 @@ def getLicense():
         l.set("trialExpires", "3000-01-01T00:00:00.000Z")
         return Response(xml_to_string(root), mimetype='text/xml')
 
-# TODO link with https://beets.readthedocs.io/en/stable/plugins/playlist.html
-@app.route('/rest/getPlaylists', methods=["GET", "POST"])
-@app.route('/rest/getPlaylists.view', methods=["GET", "POST"])
-def playlists():
-    res_format = request.values.get('f') or 'xml'
-    if (is_json(res_format)):
-        return jsonpify(request, wrap_res("playlists", {
-            "playlist": []
-        }))
-    else:
-        root = get_xml_root()
-        ET.SubElement(root, 'playlists')
-        return Response(xml_to_string(root), mimetype='text/xml')
-
 @app.route('/rest/getMusicFolders', methods=["GET", "POST"])
 @app.route('/rest/getMusicFolders.view', methods=["GET", "POST"])
 def music_folder():

beetsplug/beetstream/playlistprovider.py

@@ -0,0 +1,97 @@
+import glob
+import os
+import pathlib
+import re
+from werkzeug.utils import safe_join
+
+extinf_regex = re.compile(r'^#EXTINF:([0-9]+)( [^,]+)?,[\s]*(.*)')
+
+class PlaylistProvider:
+    def __init__(self, dir):
+        self._dir = dir
+        self._playlists = {}
+
+    def _refresh(self):
+        paths = glob.glob(os.path.join(self._dir, "**.m3u8"))
+        paths += glob.glob(os.path.join(self._dir, "**.m3u"))
+        paths.sort()
+        self._playlists = {self._path2id(p): self._playlist(p) for p in paths}
+
+    def playlists(self):
+        self._refresh()
+        ids = [k for k in self._playlists]
+        ids.sort()
+        return [self._playlists[id] for id in ids]
+
+    def playlist(self, id):
+        self._refresh()
+        filepath = safe_join(self._dir, id)
+        return self._playlist(filepath)
+
+    def _playlist(self, filepath):
+        id = self._path2id(filepath)
+        name = pathlib.Path(os.path.basename(filepath)).stem
+        playlist = self._playlists.get(id)
+        mtime = pathlib.Path(filepath).stat().st_mtime
+        if playlist and playlist.modified == mtime:
+            return playlist # cached
+        return Playlist(id, name, mtime, filepath)
+
+    def _path2id(self, filepath):
+        return os.path.relpath(filepath, self._dir)
+
+class Playlist():
+    def __init__(self, id, name, modified, path):
+        self.id = id
+        self.name = name
+        self.modified = modified
+        self.path = path
+        self.count = 0
+        self.duration = 0
+        for item in parse_m3u_playlist(self.path):
+            self.count += 1
+            self.duration += item.duration
+
+    def items(self):
+        return parse_m3u_playlist(self.path)
+
+def parse_m3u_playlist(filepath):
+    '''
+    Parses an M3U playlist and yields its items, one at a time.
+    CAUTION: Attribute values that contain ',' or ' ' are not supported!
+    '''
+    with open(filepath, 'r', encoding='UTF-8') as file:
+        linenum = 0
+        item = PlaylistItem()
+        while line := file.readline():
+            line = line.rstrip()
+            linenum += 1
+            if linenum == 1:
+                assert line == '#EXTM3U', f"File {filepath} is not an EXTM3U playlist!"
+                continue
+            if len(line.strip()) == 0:
+                continue
+            m = extinf_regex.match(line)
+            if m:
+                item = PlaylistItem()
+                duration = m.group(1)
+                item.duration = int(duration)
+                attrs = m.group(2)
+                if attrs:
+                    item.attrs = {k: v.strip('"') for k,v in [kv.split('=') for kv in attrs.strip().split(' ')]}
+                else:
+                    item.attrs = {}
+                item.title = m.group(3)
+                continue
+            if line.startswith('#'):
+                continue
+            item.uri = line
+            yield item
+            item = PlaylistItem()
+
+class PlaylistItem():
+    def __init__(self):
+        self.title = None
+        self.duration = None
+        self.uri = None
+        self.attrs = None

beetsplug/beetstream/playlists.py

@@ -0,0 +1,53 @@
+import xml.etree.cElementTree as ET
+from beetsplug.beetstream.utils import *
+from beetsplug.beetstream import app
+from flask import g, request, Response
+from .playlistprovider import PlaylistProvider
+
+_playlist_provider = PlaylistProvider('')
+
+# TODO link with https://beets.readthedocs.io/en/stable/plugins/playlist.html
+@app.route('/rest/getPlaylists', methods=['GET', 'POST'])
+@app.route('/rest/getPlaylists.view', methods=['GET', 'POST'])
+def playlists():
+    res_format = request.values.get('f') or 'xml'
+    playlists = playlist_provider().playlists()
+    if (is_json(res_format)):
+        return jsonpify(request, wrap_res('playlists', {
+            'playlist': [map_playlist(p) for p in playlists]
+        }))
+    else:
+        root = get_xml_root()
+        playlists_el = ET.SubElement(root, 'playlists')
+        for p in playlists:
+            playlist_el = ET.SubElement(playlists_el, 'playlist')
+            map_playlist_xml(playlist_el, p)
+        return Response(xml_to_string(root), mimetype='text/xml')
+
+@app.route('/rest/getPlaylist', methods=['GET', 'POST'])
+@app.route('/rest/getPlaylist.view', methods=['GET', 'POST'])
+def playlist():
+    res_format = request.values.get('f') or 'xml'
+    id = request.values.get('id')
+    playlist = playlist_provider().playlist(id)
+    items = playlist.items()
+    if (is_json(res_format)):
+        p = map_playlist(playlist)
+        p['entry'] = [_song(item.attrs['id']) for item in items]
+        return jsonpify(request, wrap_res('playlist', p))
+    else:
+        root = get_xml_root()
+        playlist_xml = ET.SubElement(root, 'playlist')
+        map_playlist_xml(playlist_xml, playlist)
+        for item in items:
+            song = g.lib.get_item(item.attrs['id'])
+            entry = ET.SubElement(playlist_xml, 'entry')
+            map_song_xml(entry, song)
+        return Response(xml_to_string(root), mimetype='text/xml')
+
+def _song(id):
+    return map_song(g.lib.get_item(int(id)))
+
+def playlist_provider():
+    _playlist_provider._dir = app.config['playlist_dir']
+    return _playlist_provider

beetsplug/beetstream/utils.py

@@ -208,6 +208,22 @@ def map_artist_xml(xml, artist_name):
     xml.set("albumCount", "1")
     xml.set("artistImageUrl", "https://t4.ftcdn.net/jpg/00/64/67/63/360_F_64676383_LdbmhiNM6Ypzb3FM4PPuFP9rHe7ri8Ju.jpg")
 
+def map_playlist(playlist):
+    return {
+        'id': playlist.id,
+        'name': playlist.name,
+        'songCount': playlist.count,
+        'duration': playlist.duration,
+        'created': timestamp_to_iso(playlist.modified),
+    }
+
+def map_playlist_xml(xml, playlist):
+    xml.set('id', playlist.id)
+    xml.set('name', playlist.name)
+    xml.set('songCount', str(playlist.count))
+    xml.set('duration', str(ceil(playlist.duration)))
+    xml.set('created', timestamp_to_iso(playlist.modified))
+
 def artist_name_to_id(name):
     base64_name = base64.b64encode(name.encode('utf-8')).decode('utf-8')
     return f"{ARTIST_ID_PREFIX}{base64_name}"