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

[Eric Casteleijn]

Should fix mpd support

Should fix mpd support

=== modified file 'autoqueue/__init__.py'
--- autoqueue/__init__.py	2011-05-06 15:30:42 +0000
+++ autoqueue/__init__.py	2011-05-06 17:48:32 +0000
@@ -75,10 +75,6 @@
         """Return filename for the song."""
 
     @abstractmethod
-    def get_length(self):
-        """Return length in seconds."""
-
-    @abstractmethod
     def get_last_started(self):
         """Return the datetime the song was last played."""
 
@@ -162,7 +158,7 @@
         self.running = False
         self.log('Error handler received: %r, %r' % (args, kwargs))
 
-    def player_get_cache_dir(self):
+    def get_cache_dir(self):
         """Get the directory to store temporary data.
 
         Defaults to $XDG_CACHE_HOME/autoqueue on Gnome.
@@ -180,7 +176,7 @@
     def get_blocked_artists_pickle(self):
         """Read the list of blocked artists from disk."""
         dump = os.path.join(
-            self.player_get_cache_dir(), "autoqueue_block_cache")
+            self.get_cache_dir(), "autoqueue_block_cache")
         try:
             pickle = open(dump, 'r')
             try:
@@ -206,7 +202,7 @@
             artist_name,
             len(self._blocked_artists)))
         dump = os.path.join(
-            self.player_get_cache_dir(), "autoqueue_block_cache")
+            self.get_cache_dir(), "autoqueue_block_cache")
         try:
             os.remove(dump)
         except OSError:

=== modified file 'mpd_autoqueue.py'
--- mpd_autoqueue.py	2010-02-28 02:04:38 +0000
+++ mpd_autoqueue.py	2011-05-06 17:48:32 +0000
@@ -1,161 +1,136 @@
 #!/usr/bin/env python
-'''
-Copyright (c) 2008, Rick van Hattem
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-
-    * Redistributions in binary form must reproduce the above
-      copyright notice, this list of conditions and the following
-      disclaimer in the documentation and/or other materials provided
-      with the distribution.
-
-    * The names of the contributors may not be used to endorse or
-      promote products derived from this software without specific
-      prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-'AS IS' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-'''
+"""mpd implementation of autoqueue.
+
+Copyright (c) 2008-2011 Rick van Hattem, Eric Casteleijn
+"""
 
 import os
 import sys
 import mpd
 import time
 import errno
-import atexit
 import socket
 import signal
 import optparse
 import autoqueue
 
+
 def expand_path(path):
     path = os.path.expandvars(os.path.expanduser(path))
     if not os.path.isdir(path):
         os.mkdir(path)
     return path
 
+
 def expand_file(path):
     path, file_ = os.path.split(path)
     return os.path.join(expand_path(path), file_)
 
-'''The settings path automatically expands ~ to the user home directory
-and $VAR to environment variables
-On most *n?x systems ~/.autoqueue will be expanded to /home/username/.autoqueue/
-Setting the path to $HOME/.autoqueue/ will usually yield the same result
-'''
+# The settings path automatically expands ~ to the user home directory
+# and $VAR to environment variables On most *n?x systems ~/.autoqueue
+# will be expanded to /home/username/.autoqueue/ Setting the path to
+# $HOME/.autoqueue/ will usually yield the same result
+
 SETTINGS_PATH = '~/.autoqueue/'
 
-'''These settings will be overwritten by the MPD_HOST/MPD_PORT environment
-variables and/or by the commandline arguments'''
+# These settings will be overwritten by the MPD_HOST/MPD_PORT
+# environment variables and/or by the commandline arguments
+
 MPD_PORT = 6600
 MPD_HOST = 'localhost'
 
 # The PID file to see if there are no other instances running
+
 PID_FILE = os.path.join(expand_path(SETTINGS_PATH), 'mpd.pid')
 
 # Send a KILL signal if the process didn't end KILL_TIMEOUT seconds
 # after the TERM signal, check every KILL_CHECK_DELAY seconds if it's
 # still alive after sending the TERM signal
+
 KILL_TIMEOUT = 10
 KILL_CHECK_DELAY = 0.1
 
-'''The targets for stdin, stdout and stderr when daemonizing'''
+# The targets for stdin, stdout and stderr when daemonizing
+
 STDIN = '/dev/null'
 STDOUT = SETTINGS_PATH + 'stdout'
 STDERR = SETTINGS_PATH + 'stderr'
 
-'''The interval to refresh the MPD status, the faster this is set, the faster
-the MPD server will be polled to see if the queue is empty'''
+# The interval to refresh the MPD status, the faster this is set, the
+# faster the MPD server will be polled to see if the queue is empty
+
 REFRESH_INTERVAL = 10
 
-'''The desired length for the queue, set this to 0 to add a song for every
-finished song or to any other number for the number of seconds to keep the
-queue filled'''
+# The desired length for the queue, set this to 0 to add a song for
+# every finished song or to any other number for the number of seconds
+# to keep the queue filled
+
 DESIRED_QUEUE_LENGTH = 0
 
-'''Make sure we have a little margin before changing the song so the queue
-won't run empty, keeping this at 15 seconds should be safe
-Do note that when DESIRED_QUEUE_LENGTH = 0 than this would probably work
-better with a value of 0'''
+# Make sure we have a little margin before changing the song so the
+# queue won't run empty, keeping this at 15 seconds should be safe Do
+# note that when DESIRED_QUEUE_LENGTH = 0 than this would probably
+# work better with a value of 0
+
 QUEUE_MARGIN = 0
 
-'''When MPD is not running, should we launch?
-And if MPD exits, should we exit?'''
+# When MPD is not running, should we launch? And if MPD exits, should
+# we exit?
+
 EXIT_WITH_MPD = False
 
+
 class Song(autoqueue.SongBase):
-    '''A MPD song object'''
-    def __init__(self, file=None, time=0, **kwargs):
+    """An MPD song object."""
+
+    # pylint: disable=W0231
+    def __init__(self, song_file=None, song_length=0, **kwargs):
         self.title = self.artist = self.album = ''
-        self._file = file
-        self.time = time
+        self.file = song_file
+        self.time = song_length
         self.__dict__.update(**kwargs)
+    # pylint: enable=W0231
 
     def get_artist(self):
-        '''return lowercase UNICODE name of artist'''
+        """Return lowercase UNICODE name of artist."""
         return unicode(self.artist.lower(), 'utf-8')
 
+    def get_artists(self):
+        """Get list of artists and performers for the song."""
+        return [self.get_artist()]
+
     def get_title(self):
-        '''return lowercase UNICODE title of song'''
+        """Return lowercase UNICODE title of song."""
         return unicode(self.title.lower(), 'utf-8')
 
-    def get_album(self):
-        '''return lowercase UNICODE album of song'''
-        return unicode(self.album.lower(), 'utf-8')
-
     def get_tags(self):
-        '''return a list of tags for the songs'''
+        """Return a list of tags for the song."""
         return []
 
     def get_filename(self):
+        """Return filename for the song."""
         return '/var/lib/mpd/music/' + self.file
 
-    @property
-    def file(self):
-        '''file is an immutable attribute that's used for the hash method'''
-        return self._file
+    def get_last_started(self):
+        """Return the datetime the song was last played."""
+        return 0
+
+    def get_rating(self):
+        """Return the rating of the song."""
+        return 0
+
+    def get_playcount(self):
+        """Return the playcount of the song."""
+        return 0
 
     def __repr__(self):
-        return '<%s: %s - %s - %s (%s)>' % (
+        return '<%s: %s - %s - %s>' % (
             self.__class__.__name__,
             self.album,
             self.artist,
             self.title,
-            self.duration,
         )
 
-    def get_time(self):
-        return self._time
-
-    def set_time(self, value):
-        self._time = int(value)
-
-    time = property(get_time, set_time, doc='song duration in seconds')
-
-    @property
-    def duration(self):
-        t = time.gmtime(int(self.time))
-        if t.tm_hour:
-            fmt = '%H:%M:%S'
-        else:
-            fmt = '%M:%S'
-        return time.strftime(fmt, t)
-
     def __int__(self):
         return self.time
 
@@ -177,9 +152,10 @@
     def __ne__(self, other):
         return hash(self) != hash(other)
 
+
 class Search(object):
-    '''
-    Search object which keeps track of all search parameters
+    """
+    Search object which keeps track of all search parameters.
 
     ALLOWED_FIELDS - list of allowed search fields
 
@@ -192,13 +168,13 @@
     >>> search.add_parameters(any='test3', album='test4')
     >>> search.get_parameters()
     ['album', 'test4', 'title', 'test2', 'any', 'test3', 'artist', 'test']
-    '''
+    """
     ALLOWED_FIELDS = ('artist', 'album', 'title', 'track', 'name', 'genre',
         'date', 'composer', 'performer', 'comment', 'disc', 'filename', 'any')
 
     def __init__(self, field=None, value=None, **parameters):
-        '''
-        Create a search object
+        """
+        Create a search object.
 
         >>> search = Search(artist='test')
         >>> search.parameters
@@ -211,15 +187,15 @@
         >>> search = Search('artist', 'test')
         >>> search.parameters
         {'artist': set(['test'])}
-        '''
+        """
         self.parameters = {}
         if field and value:
             self.add_parameter(field, value)
         self.add_parameters(**parameters)
 
     def add_parameters(self, **parameters):
-        '''
-        Add one or more parameters to the search query
+        """
+        Add one or more parameters to the search query.
 
         Use with named arguments, the key must be in ALLOWED_FIELDS
 
@@ -227,12 +203,12 @@
         >>> search.add_parameters(artist='test1', title='test2')
         >>> search.parameters
         {'artist': set(['test1']), 'title': set(['test2'])}
-        '''
+        """
         [self.add_parameter(k, v) for k, v in parameters.iteritems()]
 
     def add_parameter(self, field, value):
-        '''
-        Add a parameter to the search query
+        """
+        Add a parameter to the search query.
 
         field - must be in ALLOWED_FIELDS
         value - a literal string to be searched for
@@ -247,7 +223,7 @@
         Traceback (most recent call last):
         ...
         TypeError: "spam" is not a valid field, please choose on from ALLOWED_FIELDS
-        '''
+        """
         if field in self.ALLOWED_FIELDS:
             self.parameters.setdefault(field, set()).add(value.lower().strip())
         else:
@@ -255,8 +231,8 @@
                 'on from ALLOWED_FIELDS' % field
 
     def get_parameters(self):
-        '''
-        Return a list of parameters for the MPDClient.search method
+        """
+        Return a list of parameters for the MPDClient.search method.
 
         >>> search = Search(artist='test1', title='test2')
         >>> search.get_parameters()
@@ -268,7 +244,7 @@
         Traceback (most recent call last):
         ...
         ValueError: Empty search queries are not allowed
-        '''
+        """
         ret = []
         for k, vs in self.parameters.iteritems():
             ret += [[k, v.encode('utf-8')] for v in vs]
@@ -277,47 +253,56 @@
             raise ValueError, 'Empty search queries are not allowed'
         return sum(ret, [])
 
+
 class Daemon(object):
-    '''Class to easily create a daemon which transparently handles the saving
-    and removing of the PID file'''
+    """
+    Class to easily create a daemon which transparently handles the
+    saving and removing of the PID file.
+
+    """
 
     def __init__(self, pid_file):
-        '''Create a new Daemon
+        """Create a new Daemon.
 
         pid_file -- The file to save the PID in
-        '''
+        """
+        self._pid_file = None
         self.pid_file = pid_file
         signal.signal(signal.SIGTERM, lambda *args: self.exit())
         signal.signal(signal.SIGINT, lambda *args: self.exit())
         signal.signal(signal.SIGQUIT, lambda *args: self.exit())
 
     def set_pid_file(self, pid_file):
+        """Set pid file."""
         self._pid_file = pid_file
         open(pid_file, 'w').write('%d' % os.getpid())
 
     def get_pid_file(self):
+        """Get pid file."""
         return self._pid_file
 
     def del_pid_file(self):
+        """Delete pid file."""
         try:
             os.unlink(self._pid_file)
-            print >>sys.stderr, 'Removed PID file'
+            print >> sys.stderr, 'Removed PID file'
         except OSError:
-            print >>sys.stderr, 'Trying to remove non-existing PID file'
+            print >> sys.stderr, 'Trying to remove non-existing PID file'
 
     pid_file = property(get_pid_file, set_pid_file, del_pid_file,
         'The PID file will be written when set and deleted when unset')
 
     def exit(self):
-        '''Kill the daemon and remove the PID file
+        """Kill the daemon and remove the PID file
 
         This method will be called automatically when the process is
-        terminated'''
+        terminated"""
         del self.pid_file
         raise SystemExit
 
     @classmethod
     def is_running(cls, pid):
+        """Check whether we're already running.'"""
         if not pid:
             return False
         try:
@@ -328,13 +313,14 @@
 
     @classmethod
     def kill(cls, pid, pid_file=None):
+        """Kill process."""
         try:
             pid = int(pid)
         except (TypeError, ValueError):
             pid = None
 
         if cls.is_running(pid):
-            print >>sys.stderr, 'Sending TERM signal to process %d' % pid
+            print >> sys.stderr, 'Sending TERM signal to process %d' % pid
             os.kill(pid, signal.SIGTERM)
             i = KILL_TIMEOUT
             while i > 0 and cls.is_running(pid):
@@ -342,23 +328,26 @@
                 time.sleep(KILL_CHECK_DELAY)
 
             if cls.is_running(pid):
-                print >>sys.stderr, 'Sending KILL signal to process %d' % pid
+                print >> sys.stderr, 'Sending KILL signal to process %d' % pid
                 os.kill(pid, signal.SIGKILL)
 
             time.sleep(1)
             if cls.is_running(pid):
-                print >>sys.stderr, 'Unable to kill process %d, still running'
+                print >> sys.stderr, 'Unable to kill process %d, still running'
         else:
             if isinstance(pid, int):
-                print >>sys.stderr, 'Process %d not running' % pid
+                print >> sys.stderr, 'Process %d not running' % pid
             if pid_file:
-                print >>sys.stderr, 'Removing stale PID file'
+                print >> sys.stderr, 'Removing stale PID file'
                 os.unlink(pid_file)
 
     @classmethod
     def daemonize(cls):
-        '''Daemonize using the double fork method so the process keeps running
-        Even after the original shell exits'''
+        """
+        Daemonize using the double fork method so the process keeps
+        running Even after the original shell exits.
+
+        """
         stdin_file = expand_file(STDIN)
         stdout_file = expand_file(STDOUT)
         stderr_file = expand_file(STDERR)
@@ -367,7 +356,7 @@
             if pid > 0:
                 sys.exit(0)
         except OSError, e:
-            print >>sys.stderr, 'Unable to fork: %s' % e
+            print >> sys.stderr, 'Unable to fork: %s' % e
             sys.exit(1)
 
         os.chdir('/')
@@ -379,10 +368,10 @@
             if pid > 0:
                 sys.exit(0)
         except OSError, e:
-            print >>sys.stderr, 'Unable to fork: %s' % e
+            print >> sys.stderr, 'Unable to fork: %s' % e
             sys.exit(1)
 
-        '''Redirect stdout, stderr and stdin'''
+        # Redirect stdout, stderr and stdin
         stdin = file(stdin_file, 'r')
         stdout = file(stdout_file, 'a+')
         stderr = file(stderr_file, 'a+', 0)
@@ -390,20 +379,23 @@
         os.dup2(stdout.fileno(), sys.stdout.fileno())
         os.dup2(stderr.fileno(), sys.stderr.fileno())
 
+
 class AutoQueuePlugin(autoqueue.AutoQueueBase, Daemon):
+    """Mpd implementation of autoqueue."""
+
     def __init__(self, host, port, pid_file):
         self.host, self.port = host, port
         self.client = mpd.MPDClient()
         self.connect()
         autoqueue.AutoQueueBase.__init__(self)
-        self.random = True
         self.verbose = True
-        self.by_mirage = True
         self.desired_queue_length = DESIRED_QUEUE_LENGTH
         Daemon.__init__(self, pid_file)
         self._current_song = None
+        self._host = None
 
     def run(self):
+        """Run."""
         running = True
         while running or not EXIT_WITH_MPD:
             interval = REFRESH_INTERVAL
@@ -416,8 +408,7 @@
 
                     interval = min(
                         REFRESH_INTERVAL,
-                        int(self.player_get_queue_length()) - QUEUE_MARGIN
-                    )
+                        int(self.player_get_queue_length()) - QUEUE_MARGIN)
                     running = True
                 except mpd.ConnectionError:
                     print "disconnecting"
@@ -432,6 +423,7 @@
         self.exit()
 
     def connect(self):
+        """Connect."""
         try:
             self.client.connect(self.host, self.port)
             return True
@@ -439,6 +431,7 @@
             return False
 
     def disconnect(self):
+        """Disconnect."""
         try:
             self.client.disconnect()
             return True
@@ -446,56 +439,61 @@
             return False
 
     def get_host(self):
+        """Get host."""
         return self._host
 
     def set_host(self, host):
+        """Set host."""
         self._host = socket.gethostbyname(host)
 
-    host = property(get_host, set_host, doc='MPD ip (can be set by ip and hostname)')
+    host = property(
+        get_host, set_host, doc='MPD ip (can be set by ip and hostname)')
 
-    def player_construct_track_search(self, artist, title, restrictions):
-        '''construct a search that looks for songs with this artist
-        and title'''
+    def player_construct_track_search(self, artist, title, restrictions=None):
+        """Construct a search that looks for songs with this artist
+        and title."""
         return Search(artist=artist, title=title)
 
-    def player_construct_tag_search(self, tags, exclude_artists, restrictions):
-        '''construct a search that looks for songs with these tags'''
+    def player_construct_tag_search(self, tags, exclude_artists,
+                                    restrictions=None):
+        """Construct a search that looks for songs with these tags."""
         return None
 
-    def player_construct_artist_search(self, artist, restrictions):
-        '''construct a search that looks for songs with this artist'''
+    def player_construct_artist_search(self, artist, restrictions=None):
+        """Construct a search that looks for songs with this artist."""
         return Search(artist=artist)
 
-    def player_construct_restrictions(
-        self, track_block_time, relaxors, restrictors):
-        '''construct a search to further modify the searches'''
-        return None
+    def player_set_variables_from_config(self):
+        """Initialize user settings from the configuration storage."""
+        pass
 
     def player_search(self, search):
-        '''perform a player search'''
+        """perform a player search"""
 
         results = self.client.search(*search.get_parameters())
 
-        '''Make all search results lowercase and strip whitespace'''
-        for r in results:
-            for k, v in r.items():
-                if isinstance(v, basestring):
-                    r['%s_search' % k] = unicode(v, 'utf-8').strip().lower()
-
-        '''Filter all non-exact matches'''
-        for k, vs in search.parameters.iteritems():
-            for v in vs:
-                results = [r for r in results if r.get('%s_search' % k) == v]
-
-        '''Convert all rows to song objects'''
+        # Make all search results lowercase and strip whitespace
+        for result in results:
+            for key, value in result.items():
+                if isinstance(value, basestring):
+                    result['%s_search' % key] = unicode(
+                        value, 'utf-8').strip().lower()
+
+        # Filter all non-exact matches
+        for key, values in search.parameters.iteritems():
+            for value in values:
+                results = [
+                    r for r in results if r.get('%s_search' % key) == value]
+
+        # Convert all rows to song objects
         return [Song(**x) for x in results]
 
     def player_enqueue(self, song):
-        '''Put the song at the end of the queue'''
+        """Put the song at the end of the queue"""
         self.client.add(song.file)
 
     def player_get_userdir(self):
-        '''get the application user directory to store files'''
+        """get the application user directory to store files"""
         return expand_path(SETTINGS_PATH)
 
     def player_current_song(self):
@@ -511,7 +509,7 @@
         return (Song(**x) for x in self.client.playlistid())
 
     def player_get_songs_in_queue(self):
-        '''return (wrapped) song objects for the songs in the queue'''
+        """return (wrapped) song objects for the songs in the queue"""
         id = self.player_current_song_id()
         return [s for i, s in enumerate(self.player_playlist()) if i >= id]