Merge pull request #14 from mgoltzsche/aggregate-playlist-artists

list top artists/playlist, add mime types, fallback to default mime type

Author: BinaryBrain

beetsplug/beetstream/__init__.py

@@ -80,7 +80,10 @@ def func(lib, opts, args):
             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()
+                try:
+                    playlist_dir = config['smartplaylist']['playlist_dir'].get()
+                except:
+                    pass
             app.config['playlist_dir'] = playlist_dir
 
             # Enable CORS if required.

beetsplug/beetstream/playlistprovider.py

@@ -2,59 +2,102 @@
 import os
 import pathlib
 import re
+import sys
+from beetsplug.beetstream.utils import strip_accents
+from flask import current_app as app
 from werkzeug.utils import safe_join
 
 extinf_regex = re.compile(r'^#EXTINF:([0-9]+)( [^,]+)?,[\s]*(.*)')
+highint32 = 1<<31
 
 class PlaylistProvider:
     def __init__(self, dir):
-        self._dir = 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"))
+        self._playlists = {p.id: p for p in self._load_playlists()}
+        app.logger.debug(f"Loaded {len(self._playlists)} playlists")
+
+    def _load_playlists(self):
+        if not self.dir:
+            return
+        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}
+        for path in paths:
+            try:
+                yield self._playlist(path)
+            except Exception as e:
+                app.logger.error(f"Failed to load playlist {filepath}: {e}")
 
     def playlists(self):
         self._refresh()
-        ids = [k for k in self._playlists]
+        playlists = self._playlists
+        ids = [k for k, v in playlists.items() if v]
         ids.sort()
-        return [self._playlists[id] for id in ids]
+        return [playlists[id] for id in ids]
 
     def playlist(self, id):
-        self._refresh()
-        filepath = safe_join(self._dir, id)
-        return self._playlist(filepath)
+        filepath = safe_join(self.dir, id)
+        playlist = self._playlist(filepath)
+        if playlist.id not in self._playlists: #  add to cache
+            playlists = self._playlists.copy()
+            playlists[playlist.id] = playlist
+            self._playlists = playlists
+        return playlist
 
     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 # cached metadata
+        app.logger.debug(f"Loading playlist {filepath}")
         return Playlist(id, name, mtime, filepath)
 
     def _path2id(self, filepath):
-        return os.path.relpath(filepath, self._dir)
+        return os.path.relpath(filepath, self.dir)
 
-class Playlist():
+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):
+        artists = {}
+        max_artists = 10
+        for item in self.items():
             self.count += 1
             self.duration += item.duration
+            artist = Artist(item.title.split(' - ')[0])
+            found = artists.get(artist.key)
+            if found:
+                found.count += 1
+            else:
+                if len(artists) > max_artists:
+                    l = _sortedartists(artists)[:max_artists]
+                    artists = {a.key: a for a in l}
+                artists[artist.key] = artist
+        self.artists = ', '.join([a.name for a in _sortedartists(artists)])
 
     def items(self):
         return parse_m3u_playlist(self.path)
 
+def _sortedartists(artists):
+    l = [a for _,a in artists.items()]
+    l.sort(key=lambda a: (highint32-a.count, a.name))
+    return l
+
+class Artist:
+    def __init__(self, name):
+        self.key = strip_accents(name.lower())
+        self.name = name
+        self.count = 1
+
 def parse_m3u_playlist(filepath):
     '''
     Parses an M3U playlist and yields its items, one at a time.

beetsplug/beetstream/playlists.py

@@ -49,5 +49,8 @@ def _song(id):
     return map_song(g.lib.get_item(int(id)))
 
 def playlist_provider():
-    _playlist_provider._dir = app.config['playlist_dir']
+    if 'playlist_dir' in app.config:
+        _playlist_provider.dir = app.config['playlist_dir']
+    if not _playlist_provider.dir:
+        app.logger.warning('No playlist_dir configured')
     return _playlist_provider

beetsplug/beetstream/utils.py

@@ -11,11 +11,15 @@
 from math import ceil
 from xml.dom import minidom
 
+DEFAULT_MIME_TYPE = 'application/octet-stream'
 EXTENSION_TO_MIME_TYPE_FALLBACK = {
     '.aac'  : 'audio/aac',
     '.flac' : 'audio/flac',
     '.mp3'  : 'audio/mpeg',
+    '.mp4'  : 'audio/mp4',
+    '.m4a'  : 'audio/mp4',
     '.ogg'  : 'audio/ogg',
+    '.opus' : 'audio/opus',
 }
 
 def strip_accents(s):
@@ -214,6 +218,7 @@ def map_playlist(playlist):
         'name': playlist.name,
         'songCount': playlist.count,
         'duration': playlist.duration,
+        'comment': playlist.artists,
         'created': timestamp_to_iso(playlist.modified),
     }
 
@@ -222,6 +227,7 @@ def map_playlist_xml(xml, playlist):
     xml.set('name', playlist.name)
     xml.set('songCount', str(playlist.count))
     xml.set('duration', str(ceil(playlist.duration)))
+    xml.set('comment', playlist.artists)
     xml.set('created', timestamp_to_iso(playlist.modified))
 
 def artist_name_to_id(name):
@@ -257,7 +263,9 @@ def path_to_content_type(path):
     if result:
         return result
 
-    raise RuntimeError(f"Unable to determine content type for {path}")
+    flask.current_app.logger.warning(f"No mime type mapped for {ext} extension: {path}")
+
+    return DEFAULT_MIME_TYPE
 
 def handleSizeAndOffset(collection, size, offset):
     if size is not None: