Refactor SpotifyBackend to use properties on self which encapsulates logic and caching instead of working directly on the Spotify session

mopidy/__main__.py

@@ -14,8 +14,6 @@ def main():
     _setup_logging(2)
     backend = SpotifyBackend()
     MpdServer(backend=backend)
-    print 'Please connect to %s port %s using a MPD client.' % (
-        settings.MPD_SERVER_HOSTNAME, settings.MPD_SERVER_PORT)
     asyncore.loop()
 
 def _setup_logging(verbosity_level):

mopidy/backends/spotify.py

@@ -6,78 +6,100 @@ import spytify
 from mopidy import settings
 from mopidy.backends.base import BaseBackend
 
-logger = logging.getLogger('spotify')
+logger = logging.getLogger(u'spotify')
+
+def encode(string):
+    return string.encode('utf-8')
+
+def decode(string):
+    return string.decode('utf-8')
 
 class SpotifyBackend(BaseBackend):
     def __init__(self, *args, **kwargs):
         super(SpotifyBackend, self).__init__(*args, **kwargs)
-
-        logger.debug('Signing in')
+        logger.info(u'Connecting to Spotify')
         self.spotify = spytify.Spytify(self.username, self.password)
-
-        self._playlist_load_cache = None
-        self.current_playlist = []
-        self.current_playlist_version = 0
+        logger.info(u'Preloading data')
+        self.playlists
+        logger.info(u'Done preloading data')
 
     @property
     def username(self):
-        username = settings.SPOTIFY_USERNAME.encode('utf-8')
+        username = encode(settings.SPOTIFY_USERNAME)
         if not username:
-            sys.exit('Setting SPOTIFY_USERNAME is not set.')
+            sys.exit(u'Setting SPOTIFY_USERNAME is not set.')
         return username
 
     @property
     def password(self):
-        password = settings.SPOTIFY_PASSWORD.encode('utf-8')
+        password = encode(settings.SPOTIFY_PASSWORD)
         if not password:
-            sys.exit('Setting SPOTIFY_PASSWORD is not set.')
+            sys.exit(u'Setting SPOTIFY_PASSWORD is not set.')
         return password
 
-    def playlist_load(self, name):
-        for playlist in self.spotify.stored_playlists:
-            if playlist.name == name:
-                self.current_playlist = playlist.tracks
-                self.current_playlist_version += len(playlist.tracks)
-                break
-
-    def playlists_list(self):
-        if self._playlist_load_cache is None:
-            self._playlist_load_cache = []
+    @property
+    def playlists(self):
+        if not hasattr(self, '_cached_playlists') or not self._cached_playlists:
+            logger.debug(u'Caching stored playlists')
+            self._cached_playlists = []
             for playlist in self.spotify.stored_playlists:
-                self._playlist_load_cache.append(u'playlist: %s' % playlist.name.decode('utf-8'))
-        return self._playlist_load_cache
+                self._cached_playlists.append(playlist)
+        return self._cached_playlists
 
-    def status_playlist_length(self):
-        return len(self.current_playlist)
+    @property
+    def current_playlist(self):
+        if not hasattr(self, '_current_playlist'):
+            self._current_playlist = []
+        return self._current_playlist
 
-    def playlist_changes(self, songpos):
-        tracks = []
-        pos = 0
-        id = 0
+    @property
+    def current_playlist_version(self):
+        if not hasattr(self, '_current_playlist_version'):
+            self._current_playlist_version = 0
+        return self._current_playlist_version
 
-        for track in self.current_playlist:
-            tracks.append(u'file: %s' % track.track_id.decode('utf-8'))
-            tracks.append(u'Time: %d' % (track.length/1000))
-            tracks.append(u'Artist: %s' % track.artists[0].name.decode('utf-8'))
-            tracks.append(u'Title: %s' % track.title.decode('utf-8'))
-            tracks.append(u'Album: %s' % track.album.decode('utf-8'))
-            tracks.append(u'Track: %s' % track.tracknumber)
-            tracks.append(u'Pos: %d' % pos)
-            tracks.append(u'Id: %d' % id)
+    @current_playlist.setter
+    def current_playlist(self, tracks):
+        self._current_playlist = tracks
+        self._current_playlist_version += 1
 
-            pos += 1
-            id += 1
-        return tracks
+    ### MPD handlers
 
     def play_id(self, songid):
         track = self.current_playlist[songid]
         self.spotify.play(track)
 
+    def playlist_load(self, name):
+        playlists = filter(lambda p: decode(p.name) == name, self.playlists)
+        if playlists:
+            self.current_playlist = playlists[0].tracks
+        else:
+            self.current_playlist = []
+
+    def playlists_list(self):
+        return [u'playlist: %s' % decode(p.name) for p in self.playlists]
+
+    def playlist_changes(self, songpos):
+        tracks = []
+        for i, track in enumerate(self.current_playlist):
+            tracks.append(u'file: %s' % decode(track.track_id))
+            tracks.append(u'Time: %d' % (track.length // 1000))
+            tracks.append(u'Artist: %s' % decode(track.artists[0].name))
+            tracks.append(u'Title: %s' % decode(track.title))
+            tracks.append(u'Album: %s' % decode(track.album))
+            tracks.append(u'Track: %s' % track.tracknumber)
+            tracks.append(u'Pos: %d' % i)
+            tracks.append(u'Id: %d' % i)
+        return tracks
+
     def stop(self):
         self.spotify.stop()
 
     def status_playlist(self):
         return self.current_playlist_version
 
+    def status_playlist_length(self):
+        return len(self.current_playlist)
+
     def url_handlers(self):
         return [u'spotify:', u'http://open.spotify.com/']

mopidy/server.py

@@ -17,6 +17,8 @@ class MpdServer(asyncore.dispatcher):
         self.set_reuse_addr()
         self.bind((settings.MPD_SERVER_HOSTNAME, settings.MPD_SERVER_PORT))
         self.listen(1)
+        logger.info(u'Please connect to %s port %s using a MPD client.',
+            settings.MPD_SERVER_HOSTNAME, settings.MPD_SERVER_PORT)
 
     def handle_accept(self):
         (client_socket, client_address) = self.accept()