Merge lp:~thisfred/autoqueue/lp-777351 into lp:autoqueue

[Eric Casteleijn]

fixed rhythmbox support

fixed rhythmbox support

=== modified file 'autoqueue/__init__.py'
--- autoqueue/__init__.py	2011-05-06 00:03:33 +0000
+++ autoqueue/__init__.py	2011-05-06 15:33:27 +0000
@@ -24,6 +24,7 @@
 import os
 import random
 
+from abc import ABCMeta, abstractmethod
 from dbus.mainloop.glib import DBusGMainLoop
 from collections import deque
 from datetime import datetime, timedelta
@@ -45,51 +46,49 @@
 class SongBase(object):
     """A wrapper object around player specific song objects."""
 
+    __metaclass__ = ABCMeta
+
     def __init__(self, song):
         self.song = song
 
     def __str__(self):
         return "<Song: %s - %s>" % (self.get_artist(), self.get_title())
 
+    @abstractmethod
     def get_artist(self):
         """Return lowercase UNICODE name of artist."""
-        return NotImplemented
 
+    @abstractmethod
     def get_artists(self):
         """Return lowercase UNICODE name of artists and performers."""
-        return NotImplemented
 
+    @abstractmethod
     def get_title(self):
         """Return lowercase UNICODE title of song."""
-        return NotImplemented
 
+    @abstractmethod
     def get_tags(self):
         """Return a list of tags for the song."""
-        return []
 
+    @abstractmethod
     def get_filename(self):
         """Return filename for the song."""
-        return NotImplemented
 
+    @abstractmethod
     def get_length(self):
         """Return length in seconds."""
-        return NotImplemented
 
+    @abstractmethod
     def get_last_started(self):
         """Return the datetime the song was last played."""
-        return NotImplemented
 
+    @abstractmethod
     def get_rating(self):
         """Return the rating of the song."""
-        return NotImplemented
 
+    @abstractmethod
     def get_playcount(self):
         """Return the playcount of the song."""
-        return NotImplemented
-
-    def get_added(self):
-        """Return the datetime the song was added to the library."""
-        return NotImplemented
 
     def get_play_frequency(self):
         """Return the play frequency of the song (plays / day)."""
@@ -124,27 +123,19 @@
 class AutoQueueBase(object):
     """Generic base class for autoqueue plugins."""
 
+    __metaclass__ = ABCMeta
+
     def __init__(self):
         self.artist_block_time = 1
         self._blocked_artists = deque([])
         self._blocked_artists_times = deque([])
         self._cache_dir = None
-        self.desired_queue_length = 0
+        self.desired_queue_length = 15 * 60
         self.cached_misses = deque([])
-        self.by_mirage = False
-        self.by_tracks = True
-        self.by_artists = True
-        self.by_tags = True
         self.running = False
         self.verbose = False
-        self.weed = False
         self.song = None
         self.restrictions = None
-        self.prune_artists = []
-        self.prune_titles = []
-        self.prune_filenames = []
-        self._rows = []
-        self._nrows = []
         self.player_set_variables_from_config()
         self.get_blocked_artists_pickle()
         self.last_songs = []
@@ -249,45 +240,45 @@
                 song.get_filename() for song in self.player_search(search)])
         return filenames
 
+    @abstractmethod
     def player_construct_file_search(self, filename, restrictions=None):
         """Construct a search that looks for songs with this artist and title.
 
         """
-        return NotImplemented
 
+    @abstractmethod
     def player_construct_track_search(self, artist, title, restrictions=None):
         """Construct a search that looks for songs with this artist
         and title.
         """
-        return NotImplemented
 
+    @abstractmethod
     def player_construct_artist_search(self, artist, restrictions=None):
         """Construct a search that looks for songs with this artist."""
-        return NotImplemented
 
+    @abstractmethod
     def player_construct_tag_search(self, tags, restrictions=None):
         """Construct a search that looks for songs with these tags."""
-        return NotImplemented
 
+    @abstractmethod
     def player_set_variables_from_config(self):
         """Initialize user settings from the configuration storage."""
-        return NotImplemented
 
+    @abstractmethod
     def player_get_queue_length(self):
         """Get the current length of the queue."""
-        return 0
 
+    @abstractmethod
     def player_enqueue(self, song):
         """Put the song at the end of the queue."""
-        return NotImplemented
 
+    @abstractmethod
     def player_search(self, search):
         """Perform a player search."""
-        return NotImplemented
 
+    @abstractmethod
     def player_get_songs_in_queue(self):
         """Return (wrapped) song objects for the songs in the queue."""
-        return []
 
     def player_execute_async(self, method, *args, **kwargs):
         """Override this if the player has a way to execute methods
@@ -418,7 +409,7 @@
                 return song
         self.cached_misses.append((artist, title, filename, tags))
         while len(self.cached_misses) > 1000:
-            print self.cached_misses.popleft()
+            self.cached_misses.popleft()
 
     def fill_queue(self):
         """Search for appropriate songs and put them in the queue."""
 
=== modified file 'autoqueue/tests/test_autoqueue.py'
--- autoqueue/tests/test_autoqueue.py	2011-05-06 00:03:33 +0000
+++ autoqueue/tests/test_autoqueue.py	2011-05-06 15:33:27 +0000
@@ -213,6 +213,10 @@
             artist_name,
             len(self._blocked_artists)))
 
+    def player_set_variables_from_config(self):
+        """Set configuration variables."""
+        pass
+
     def player_construct_file_search(self, filename, restrictions=None):
         """Construct a search that looks for songs with this artist
         and title.
 
=== modified file 'rhythmbox_autoqueue/__init__.py'
--- rhythmbox_autoqueue/__init__.py	2010-08-12 12:20:37 +0000
+++ rhythmbox_autoqueue/__init__.py	2011-05-06 15:33:27 +0000
@@ -1,3 +1,5 @@
+"""Rhythmbox version of the autoqueue plugin."""
+
 # Copyright (C) 2007-2008 - Eric Casteleijn, Alexandre Rosenfeld
 #
 # This program is free software; you can redistribute it and/or modify
@@ -16,24 +18,29 @@
 
 import urllib
 from time import time
-import gconf, gobject
+import gconf
+import gobject
 from gtk import gdk
-import rb, rhythmdb
+import rb
+import rhythmdb
 from collections import deque
 from autoqueue import AutoQueueBase, SongBase
 
 GCONFPATH = '/apps/rhythmbox/plugins/autoqueue/'
 
+
 class Song(SongBase):
     """A wrapper object around rhythmbox song objects."""
-    def __init__(self, song, db):
+
+    def __init__(self, song, db):       # pylint: disable=W0231
         self.song = song
         self.db = db
 
     def get_artist(self):
         """return lowercase UNICODE name of artist"""
         return unicode(
-            self.db.entry_get(self.song, rhythmdb.PROP_ARTIST).lower(), 'utf-8')
+            self.db.entry_get(self.song, rhythmdb.PROP_ARTIST).lower(),
+            'utf-8')
 
     def get_artists(self):
         return [self.get_artist()]
@@ -59,8 +66,18 @@
     def get_last_started(self):
         return self.db.entry_get(self.song, rhythmdb.PROP_LAST_PLAYED)
 
+    def get_rating(self):
+        """Return the rating of the song."""
+        return 5.0 / self.db.entry_get(self.song, rhythmdb.PROP_RATING)
+
+    def get_playcount(self):
+        """Return the playcount of the song."""
+        return self.db.entry_get(self.song, rhythmdb.PROP_PLAY_COUNT)
+
 
 class AutoQueuePlugin(rb.Plugin, AutoQueueBase):
+    """Plugin implementation."""
+
     def __init__(self):
         rb.Plugin.__init__(self)
         AutoQueueBase.__init__(self)
@@ -69,21 +86,27 @@
         self.by_mirage = True
         self.log("initialized")
         self._generators = deque()
+        self.pec_id = None
+        self.rdb = None
+        self.shell = None
 
     def activate(self, shell):
+        """Called on activation of the plugin."""
         self.shell = shell
         self.rdb = shell.get_property('db')
-        sp = shell.get_player ()
+        sp = shell.get_player()
         self.pec_id = sp.connect(
             'playing-song-changed', self.playing_entry_changed)
 
     def deactivate(self, shell):
+        """Called on deactivation of the plugin."""
         self.rdb = None
         self.shell = None
         sp = shell.get_player()
         sp.disconnect(self.pec_id)
 
     def _idle_callback(self):
+        """Callback that performs task asynchronously."""
         gdk.threads_enter()
         while self._generators:
             if self._generators[0] is None:
@@ -97,24 +120,23 @@
         return False
 
     def player_execute_async(self, method, *args, **kwargs):
-        """Override this if the player has a way to execute methods
-        asynchronously, like the copooling in autoqueue.
-
-        """
+        """Execute method asynchronously."""
         add_callback = False
         if not self._generators:
-           add_callback = True
+            add_callback = True
         self._generators.append(method(*args, **kwargs))
         if add_callback:
             gobject.idle_add(self._idle_callback)
 
     def log(self, msg):
-        """print debug messages"""
+        """Print debug messages."""
+        # TODO: replace with real logging
         if not self.verbose:
             return
         print msg
 
     def playing_entry_changed(self, sp, entry):
+        """Handler for song change."""
         if entry:
             self.on_song_started(Song(entry, self.rdb))