X-Git-Url: https://git.kaliko.me/?a=blobdiff_plain;f=sima%2Fclient.py;h=c04f560aece84c749a839e0aade0823f47493af4;hb=80162143f725cbe604f7241e4dfc4929833470e5;hp=9eae523bd574e209d5e0c7ff8459e532b90d9370;hpb=5adf0b495521a6f15f208474a026c088476e5018;p=mpd-sima.git

diff --git a/sima/client.py b/sima/client.py
index 9eae523..c04f560 100644
--- a/sima/client.py
+++ b/sima/client.py
@@ -25,7 +25,6 @@ This client is built above python-musicpd a fork of python-mpd
 
 # standard library import
 from difflib import get_close_matches
-from itertools import dropwhile
 from select import select
 
 # third parties components
@@ -37,10 +36,10 @@ except ImportError as err:
     sexit(1)
 
 # local import
-from .lib.player import Player
-from .lib.track import Track
-from .lib.meta import Album
 from .lib.simastr import SimaStr
+from .lib.player import Player, blacklist
+from .lib.track import Track
+from .lib.meta import Album, Artist
 from .utils.leven import levenshtein_ratio
 
 
@@ -52,34 +51,28 @@ class PlayerCommandError(PlayerError):
 
 PlayerUnHandledError = MPDError  # pylint: disable=C0103
 
+def bl_artist(func):
+    def wrapper(*args, **kwargs):
+        cls = args[0]
+        if not args[0].database:
+            return func(*args, **kwargs)
+        result = func(*args, **kwargs)
+        if not result:
+            return
+        names = list()
+        for art in result.names:
+            if cls.database.get_bl_artist(art, add_not=True):
+                cls.log.debug('Blacklisted "%s"', art)
+                continue
+            names.append(art)
+        if not names:
+            return
+        resp = Artist(name=names.pop(), mbid=result.mbid)
+        for name in names:
+            resp.add_alias(name)
+        return resp
+    return wrapper
 
-def blacklist(artist=False, album=False, track=False):
-    #pylint: disable=C0111,W0212
-    field = (artist, album, track)
-    def decorated(func):
-        def wrapper(*args, **kwargs):
-            cls = args[0]
-            boolgen = (bl for bl in field)
-            bl_fun = (cls.database.get_bl_artist,
-                      cls.database.get_bl_album,
-                      cls.database.get_bl_track,)
-            #bl_getter = next(fn for fn, bl in zip(bl_fun, boolgen) if bl is True)
-            bl_getter = next(dropwhile(lambda _: not next(boolgen), bl_fun))
-            #cls.log.debug('using {0} as bl filter'.format(bl_getter.__name__))
-            results = list()
-            for elem in func(*args, **kwargs):
-                if bl_getter(elem, add_not=True):
-                    cls.log.debug('Blacklisted "{0}"'.format(elem))
-                    continue
-                if track and cls.database.get_bl_album(elem, add_not=True):
-                    # filter album as well in track mode
-                    # (artist have already been)
-                    cls.log.debug('Blacklisted alb. "{0.album}"'.format(elem))
-                    continue
-                results.append(elem)
-            return results
-        return wrapper
-    return decorated
 
 class PlayerClient(Player):
     """MPD Client
@@ -139,11 +132,10 @@ class PlayerClient(Player):
         """
         # TODO: ain't working for "sticker find" and "sticker list"
         tracks_listing = ["playlistfind", "playlistid", "playlistinfo",
-                "playlistsearch", "plchanges", "listplaylistinfo", "find",
-                "search", "sticker find",]
+                          "playlistsearch", "plchanges", "listplaylistinfo", "find",
+                          "search", "sticker find",]
         track_obj = ['currentsong']
         if self._comm in tracks_listing + track_obj:
-            #  pylint: disable=w0142
             if isinstance(ans, list):
                 return [Track(**track) for track in ans]
             elif isinstance(ans, dict):
@@ -152,8 +144,8 @@ class PlayerClient(Player):
 
     def __skipped_track(self, old_curr):
         if (self.state == 'stop'
-            or not hasattr(old_curr, 'id')
-            or not hasattr(self.current, 'id')):
+                or not hasattr(old_curr, 'id')
+                or not hasattr(self.current, 'id')):
             return False
         return self.current.id != old_curr.id  # pylint: disable=no-member
 
@@ -165,22 +157,92 @@ class PlayerClient(Player):
             self.log.info('Player: Flushing cache!')
         else:
             self.log.info('Player: Initialising cache!')
-        self._cache = {
-                'artists': None,
-                }
-        self._cache['artists'] = frozenset(self._client.list('artist'))
+        self._cache = {'artists': frozenset(),
+                       'nombid_artists': frozenset(),}
+        self._cache['artists'] = frozenset(filter(None, self._execute('list', ['artist'])))
+        if Artist.use_mbid:
+            self._cache['nombid_artists'] = frozenset(filter(None, self._execute('list', ['artist', 'musicbrainz_artistid', ''])))
 
     @blacklist(track=True)
     def find_track(self, artist, title=None):
-        #return getattr(self, 'find')('artist', artist, 'title', title)
-        if title:
-            return self.find('artist', artist, 'title', title)
-        return self.find('artist', artist)
+        tracks = set()
+        if artist.mbid:
+            if title:
+                tracks |= set(self.find('musicbrainz_artistid', artist.mbid,
+                                        'title', title))
+            else:
+                tracks |= set(self.find('musicbrainz_artistid', artist.mbid))
+        else:
+            for name in artist.names:
+                if title:
+                    tracks |= set(self.find('artist', name, 'title', title))
+                else:
+                    tracks |= set(self.find('artist', name))
+        return list(tracks)
+
+    @bl_artist
+    def search_artist(self, artist):
+        """
+        Search artists based on a fuzzy search in the media library
+            >>> art = Artist(name='the beatles', mbid=<UUID4>) # mbid optional
+            >>> bea = player.search_artist(art)
+            >>> print(bea.names)
+            >>> ['The Beatles', 'Beatles', 'the beatles']
+
+        Returns an Artist object
+        """
+        found = False
+        if artist.mbid:
+            # look for exact search w/ musicbrainz_artistid
+            exact_m = self._execute('list', ['artist', 'musicbrainz_artistid', artist.mbid])
+            if exact_m:
+                _ = [artist.add_alias(name) for name in exact_m]
+                found = True
+        else:
+            artist = Artist(name=artist.name)
+        # then complete with fuzzy search on artist with no musicbrainz_artistid
+        if artist.mbid:
+            # we already performed a lookup on artists with mbid set
+            # search through remaining artists
+            artists = self._cache.get('nombid_artists')
+        else:
+            artists = self._cache.get('artists')
+        match = get_close_matches(artist.name, artists, 50, 0.73)
+        if not match and not found:
+            return
+        if len(match) > 1:
+            self.log.debug('found close match for "%s": %s', artist, '/'.join(match))
+        # Does not perform fuzzy matching on short and single word strings
+        # Only lowercased comparison
+        if ' ' not in artist.name and len(artist.name) < 8:
+            for fuzz_art in match:
+                # Regular lowered string comparison
+                if artist.name.lower() == fuzz_art.lower():
+                    artist.add_alias(fuzz_art)
+                    return artist
+        fzartist = SimaStr(artist.name)
+        for fuzz_art in match:
+            # Regular lowered string comparison
+            if artist.name.lower() == fuzz_art.lower():
+                found = True
+                artist.add_alias(fuzz_art)
+                if artist.name != fuzz_art:
+                    self.log.debug('"%s" matches "%s".', fuzz_art, artist)
+                continue
+            # SimaStr string __eq__ (not regular string comparison here)
+            if fzartist == fuzz_art:
+                found = True
+                artist.add_alias(fuzz_art)
+                self.log.info('"%s" quite probably matches "%s" (SimaStr)',
+                              fuzz_art, artist)
+        if found:
+            if artist.aliases:
+                self.log.debug('Found: %s', '/'.join(list(artist.names)[:4]))
+            return artist
 
-    @blacklist(track=True)
     def fuzzy_find_track(self, artist, title):
         # Retrieve all tracks from artist
-        all_tracks = self.find('artist', artist)
+        all_tracks = self.find_track(artist, title)
         # Get all titles (filter missing titles set to 'None')
         all_artist_titles = frozenset([tr.title for tr in all_tracks
                                        if tr.title is not None])
@@ -192,63 +254,14 @@ class PlayerClient(Player):
             if leven == 1:
                 pass
             elif leven >= 0.79:  # PARAM
-                self.log.debug('title: "%s" should match "%s" (lr=%1.3f)' %
-                               (title_, title, leven))
+                self.log.debug('title: "%s" should match "%s" (lr=%1.3f)',
+                               title_, title, leven)
             else:
-                self.log.debug('title: "%s" does not match "%s" (lr=%1.3f)' %
-                               (title_, title, leven))
+                self.log.debug('title: "%s" does not match "%s" (lr=%1.3f)',
+                               title_, title, leven)
                 return []
             return self.find('artist', artist, 'title', title_)
 
-    @blacklist(artist=True)
-    def fuzzy_find_artist(self, art):
-        """
-        Controls presence of artist in music library.
-        Crosschecking artist names with SimaStr objects / difflib / levenshtein
-
-        TODO: proceed crosschecking even when an artist matched !!!
-              Not because we found "The Doors" as "The Doors" that there is no
-              remaining entries as "Doors" :/
-              not straight forward, need probably heavy refactoring.
-        """
-        matching_artists = list()
-        artist = SimaStr(art)
-
-        # Check against the actual string in artist list
-        if artist.orig in self.artists:
-            self.log.debug('found exact match for "%s"' % artist)
-            return [artist]
-        # Then proceed with fuzzy matching if got nothing
-        match = get_close_matches(artist.orig, self.artists, 50, 0.73)
-        if not match:
-            return []
-        self.log.debug('found close match for "%s": %s' %
-                       (artist, '/'.join(match)))
-        # Does not perform fuzzy matching on short and single word strings
-        # Only lowercased comparison
-        if ' ' not in artist.orig and len(artist) < 8:
-            for fuzz_art in match:
-                # Regular string comparison SimaStr().lower is regular string
-                if artist.lower() == fuzz_art.lower():
-                    matching_artists.append(fuzz_art)
-                    self.log.debug('"%s" matches "%s".' % (fuzz_art, artist))
-            return matching_artists
-        for fuzz_art in match:
-            # Regular string comparison SimaStr().lower is regular string
-            if artist.lower() == fuzz_art.lower():
-                matching_artists.append(fuzz_art)
-                self.log.debug('"%s" matches "%s".' % (fuzz_art, artist))
-                return matching_artists
-            # SimaStr string __eq__ (not regular string comparison here)
-            if artist == fuzz_art:
-                matching_artists.append(fuzz_art)
-                self.log.info('"%s" quite probably matches "%s" (SimaStr)' %
-                              (fuzz_art, artist))
-            else:
-                self.log.debug('FZZZ: "%s" does not match "%s"' %
-                               (fuzz_art, artist))
-        return matching_artists
-
     def find_album(self, artist, album):
         """
         Special wrapper around album search:
@@ -260,29 +273,32 @@ class PlayerClient(Player):
         return self.find('artist', artist, 'album', album)
 
     @blacklist(album=True)
-    def find_albums(self, artist):
+    def search_albums(self, artist):
         """
         Fetch all albums for "AlbumArtist"  == artist
         Filter albums returned for "artist" == artist since MPD returns any
                album containing at least a single track for artist
         """
         albums = []
-        kwalbart = {'albumartist':artist, 'artist':artist}
-        for album in self.list('album', 'albumartist', artist):
-            if album not in albums:
-                albums.append(Album(name=album, **kwalbart))
-        for album in self.list('album', 'artist', artist):
-            album_trks = [trk for trk in self.find('album', album)]
-            if 'Various Artists' in [tr.albumartist for tr in album_trks]:
-                self.log.debug('Discarding {0} ("Various Artists" set)'.format(album))
-                continue
-            arts = set([trk.artist for trk in album_trks])
-            if len(set(arts)) < 2:  # TODO: better heuristic, use a ratio instead
-                if album not in albums:
-                    albums.append(Album(name=album, albumartist=artist))
-            elif album and album not in albums:
-                self.log.debug('"{0}" probably not an album of "{1}"'.format(
-                               album, artist) + '({0})'.format('/'.join(arts)))
+        for name in artist.names:
+            if len(artist.names) > 1:
+                self.log.debug('Searching album for aliase: "%s"', name)
+            kwalbart = {'albumartist':name, 'artist':name}
+            for album in self.list('album', 'albumartist', artist):
+                if album and album not in albums:
+                    albums.append(Album(name=album, **kwalbart))
+            for album in self.list('album', 'artist', artist):
+                album_trks = [trk for trk in self.find('album', album)]
+                if 'Various Artists' in [tr.albumartist for tr in album_trks]:
+                    self.log.debug('Discarding %s ("Various Artists" set)', album)
+                    continue
+                arts = set([trk.artist for trk in album_trks])
+                if len(set(arts)) < 2:  # TODO: better heuristic, use a ratio instead
+                    if album not in albums:
+                        albums.append(Album(name=album, **kwalbart))
+                elif album and album not in albums:
+                    self.log.debug('"{0}" probably not an album of "{1}"'.format(
+                        album, artist) + '({0})'.format('/'.join(arts)))
         return albums
 
     def monitor(self):
@@ -305,7 +321,7 @@ class PlayerClient(Player):
         if 'idle' in self._client._pending:
             self._client.noidle()
         elif self._client._pending:
-            self.log.warning('pending commands: {}'.format(self._client._pending))
+            self.log.warning('pending commands: %s', self._client._pending)
 
     def remove(self, position=0):
         self.delete(position)
@@ -313,7 +329,7 @@ class PlayerClient(Player):
     def add(self, track):
         """Overriding MPD's add method to accept add signature with a Track
         object"""
-        self._client.add(track.file)
+        self._execute('add', [track.file])
 
     @property
     def artists(self):
@@ -323,6 +339,18 @@ class PlayerClient(Player):
     def state(self):
         return str(self.status().get('state'))
 
+    @property
+    def playmode(self):
+        plm = {'repeat': None,
+               'single': None,
+               'random': None,
+               'consume': None,
+              }
+        for key, val in self.status().items():
+            if key in plm.keys():
+                plm.update({key:bool(int(val))})
+        return plm
+
     @property
     def current(self):
         return self.currentsong()
@@ -362,18 +390,8 @@ class PlayerClient(Player):
         if password:
             try:
                 self._client.password(password)
-
-            # Catch errors with the password command (e.g., wrong password)
-            except CommandError as err:
-                raise PlayerError("Could not connect to '%s': "
-                                  "password command failed: %s" %
-                                  (host, err))
-
-            # Catch all other possible errors
             except (MPDError, IOError) as err:
-                raise PlayerError("Could not connect to '%s': "
-                                  "error with password command: %s" %
-                                  (host, err))
+                raise PlayerError("Could not connect to '%s': %s", (host, err))
         # Controls we have sufficient rights
         needed_cmds = ['status', 'stats', 'add', 'find', \
                        'search', 'currentsong', 'ping']
@@ -385,6 +403,20 @@ class PlayerClient(Player):
                 raise PlayerError('Could connect to "%s", '
                                   'but command "%s" not available' %
                                   (host, nddcmd))
+
+        #  Controls use of MusicBrainzIdentifier
+        if Artist.use_mbid:
+            if 'MUSICBRAINZ_ARTISTID' not in self._client.tagtypes():
+                self.log.warning('Use of MusicBrainzIdentifier is set but MPD is '
+                                 'not providing related metadata')
+                self.log.info(self._client.tagtypes())
+                self.log.warning('Disabling MusicBrainzIdentifier')
+                Artist.use_mbid = False
+            else:
+                self.log.trace('Available metadata: %s', self._client.tagtypes())  # pylint: disable=no-member
+        else:
+            self.log.warning('Use of MusicBrainzIdentifier disabled!')
+            self.log.info('Consider using MusicBrainzIdentifier for your music library')
         self._flush_cache()
 
     def disconnect(self):