sima/lib/webserv.py

   1 # -*- coding: utf-8 -*-
   2 # Copyright (c) 2009, 2010, 2011, 2012, 2013, 2014 Jack Kaliko <kaliko@azylum.org>
   3 #
   4 #  This file is part of sima
   5 #
   6 #  sima is free software: you can redistribute it and/or modify
   7 #  it under the terms of the GNU General Public License as published by
   8 #  the Free Software Foundation, either version 3 of the License, or
   9 #  (at your option) any later version.
  10 #
  11 #  sima is distributed in the hope that it will be useful,
  12 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 #  GNU General Public License for more details.
  15 #
  16 #  You should have received a copy of the GNU General Public License
  17 #  along with sima.  If not, see <http://www.gnu.org/licenses/>.
  18 #
  19 #
  20 """
  21 Fetching similar artists from last.fm web services
  22 """
  23
  24 # standard library import
  25 import random
  26
  27 from collections import deque
  28 from hashlib import md5
  29
  30 # third parties components
  31
  32 # local import
  33 from .plugin import Plugin
  34 from .track import Track
  35 from .meta import Artist
  36 from ..utils.utils import WSError
  37
  38 def cache(func):
  39     """Caching decorator"""
  40     def wrapper(*args, **kwargs):
  41         #pylint: disable=W0212,C0111
  42         cls = args[0]
  43         similarities = [art for art in args[1]]
  44         hashedlst = md5(''.join(similarities).encode('utf-8')).hexdigest()
  45         if hashedlst in cls._cache.get('asearch'):
  46             cls.log.debug('cached request')
  47             results = cls._cache.get('asearch').get(hashedlst)
  48         else:
  49             results = func(*args, **kwargs)
  50             cls.log.debug('caching request')
  51             cls._cache.get('asearch').update({hashedlst:list(results)})
  52         random.shuffle(results)
  53         return results
  54     return wrapper
  55
  56
  57 class WebService(Plugin):
  58     """similar artists webservice
  59     """
  60
  61     def __init__(self, daemon):
  62         Plugin.__init__(self, daemon)
  63         self.daemon_conf = daemon.config
  64         self.sdb = daemon.sdb
  65         self.history = daemon.short_history
  66         ##
  67         self.to_add = list()
  68         self._cache = None
  69         self._flush_cache()
  70         wrapper = {
  71                 'track': self._track,
  72                 'top': self._top,
  73                 'album': self._album,
  74                 }
  75         self.queue_mode = wrapper.get(self.plugin_conf.get('queue_mode'))
  76         self.ws = None
  77
  78     def _flush_cache(self):
  79         """
  80         Both flushes and instanciates _cache
  81         """
  82         name = self.__class__.__name__
  83         if isinstance(self._cache, dict):
  84             self.log.info('{0}: Flushing cache!'.format(name))
  85         else:
  86             self.log.info('{0}: Initialising cache!'.format(name))
  87         self._cache = {
  88                 'asearch': dict(),
  89                 'tsearch': dict(),
  90                 }
  91
  92     def _cleanup_cache(self):
  93         """Avoid bloated cache
  94         """
  95         for _ , val in self._cache.items():
  96             if isinstance(val, dict):
  97                 while len(val) > 150:
  98                     val.popitem()
  99
 100     def get_history(self, artist):
 101         """Constructs list of Track for already played titles for an artist.
 102         """
 103         duration = self.daemon_conf.getint('sima', 'history_duration')
 104         tracks_from_db = self.sdb.get_history(duration=duration, artist=artist)
 105         # Construct Track() objects list from database history
 106         played_tracks = [Track(artist=tr[-1], album=tr[1], title=tr[2],
 107                                file=tr[3]) for tr in tracks_from_db]
 108         return played_tracks
 109
 110     def filter_track(self, tracks):
 111         """
 112         Extract one unplayed track from a Track object list.
 113             * not in history
 114             * not already in the queue
 115             * not blacklisted
 116         """
 117         artist = tracks[0].artist
 118         black_list = self.player.queue + self.to_add
 119         not_in_hist = list(set(tracks) - set(self.get_history(artist=artist)))
 120         if not not_in_hist:
 121             self.log.debug('All tracks already played for "{}"'.format(artist))
 122         random.shuffle(not_in_hist)
 123         #candidate = [ trk for trk in not_in_hist if trk not in black_list
 124                       #if not self.sdb.get_bl_track(trk, add_not=True)]
 125         candidate = []
 126         for trk in [_ for _ in not_in_hist if _ not in black_list]:
 127             if self.sdb.get_bl_track(trk, add_not=True):
 128                 self.log.info('Blacklisted: {0}: '.format(trk))
 129                 continue
 130             if self.sdb.get_bl_album(trk, add_not=True):
 131                 self.log.info('Blacklisted album: {0}: '.format(trk))
 132                 continue
 133             # Should use albumartist heuristic as well
 134             if self.plugin_conf.getboolean('single_album'):
 135                 if (trk.album == self.player.current.album or
 136                     trk.album in [tr.album for tr in self.to_add]):
 137                     self.log.debug('Found unplayed track ' +
 138                                'but from an album already queued: %s' % (trk))
 139                     continue
 140             candidate.append(trk)
 141         if not candidate:
 142             self.log.debug('Unable to find title to add' +
 143                            ' for "%s".' % artist)
 144             return None
 145         self.to_add.append(random.choice(candidate))
 146
 147     def _get_artists_list_reorg(self, alist):
 148         """
 149         Move around items in artists_list in order to play first not recently
 150         played artists
 151         """
 152         # TODO: move to utils as a decorator
 153         duration = self.daemon_conf.getint('sima', 'history_duration')
 154         art_in_hist = list()
 155         for trk in self.sdb.get_history(duration=duration,
 156                                         artists=alist):
 157             if trk[0] not in art_in_hist:
 158                 art_in_hist.append(trk[0])
 159         art_in_hist.reverse()
 160         art_not_in_hist = [ ar for ar in alist if ar not in art_in_hist ]
 161         random.shuffle(art_not_in_hist)
 162         art_not_in_hist.extend(art_in_hist)
 163         self.log.debug('history ordered: {}'.format(
 164                        ' / '.join(art_not_in_hist)))
 165         return art_not_in_hist
 166
 167     @cache
 168     def get_artists_from_player(self, similarities):
 169         """
 170         Look in player library for availability of similar artists in
 171         similarities
 172         """
 173         dynamic = self.plugin_conf.getint('max_art')
 174         if dynamic <= 0:
 175             dynamic = 100
 176         results = list()
 177         similarities.reverse()
 178         while (len(results) < dynamic
 179             and len(similarities) > 0):
 180             art_pop = similarities.pop()
 181             results.extend(self.player.fuzzy_find_artist(art_pop))
 182         return results
 183
 184     def lfm_similar_artists(self, artist=None):
 185         """
 186         Retrieve similar artists from WebServive.
 187         """
 188         if artist is None:
 189             curr = self.player.current.__dict__
 190             name = curr.get('artist')
 191             mbid = curr.get('musicbrainz_artistid', None)
 192             current = Artist(name=name, mbid=mbid)
 193         else:
 194             current = artist
 195         # initialize artists deque list to construct from DB
 196         as_art = deque()
 197         as_artists = self.ws().get_similar(artist=current)
 198         self.log.debug('Requesting {1} for "{0}"'.format(current,
 199                         self.ws.name))
 200         try:
 201             # TODO: let's propagate Artist type
 202             [as_art.append(str(art)) for art in as_artists]
 203         except WSError as err:
 204             self.log.warning('{0}: {1}'.format(self.ws.name, err))
 205         if as_art:
 206             self.log.debug('Fetched {0} artist(s)'.format(len(as_art)))
 207         if self.ws.ratelimit:
 208             self.log.info('{0.name} ratelimit: {0.ratelimit}'.format(self.ws))
 209         return as_art
 210
 211     def get_recursive_similar_artist(self):
 212         ret_extra = list()
 213         history = deque(self.history)
 214         history.popleft()
 215         depth = 0
 216         current = self.player.current
 217         extra_arts = list()
 218         while depth < self.plugin_conf.getint('depth'):
 219             if len(history) == 0:
 220                 break
 221             trk = history.popleft()
 222             if (trk.artist in [trk.artist for trk in extra_arts]
 223                 or trk.artist == current.artist):
 224                 continue
 225             extra_arts.append(trk)
 226             depth += 1
 227         self.log.info('EXTRA ARTS: {}'.format(
 228             '/'.join([trk.artist for trk in extra_arts])))
 229         for artist in extra_arts:
 230             self.log.debug('Looking for artist similar to "{0.artist}" as well'.format(artist))
 231             similar = self.lfm_similar_artists(artist=artist)
 232             if not similar:
 233                 return ret_extra
 234             ret_extra.extend(self.get_artists_from_player(similar))
 235             if current.artist in ret_extra:
 236                 ret_extra.remove(current.artist)
 237         return ret_extra
 238
 239     def get_local_similar_artists(self):
 240         """Check against local player for similar artists
 241         """
 242         current = self.player.current
 243         self.log.info('Looking for artist similar to "{0.artist}"'.format(current))
 244         similar = self.lfm_similar_artists()
 245         if not similar:
 246             self.log.info('Got nothing from {0}!'.format(self.ws.name))
 247             return []
 248         self.log.info('First five similar artist(s): {}...'.format(
 249                       ' / '.join([a for a in list(similar)[0:5]])))
 250         self.log.info('Looking availability in music library')
 251         ret = self.get_artists_from_player(similar)
 252         ret_extra = None
 253         if len(self.history) >= 2:
 254             if self.plugin_conf.getint('depth') > 1:
 255                 ret_extra = self.get_recursive_similar_artist()
 256         if ret_extra:
 257             ret = list(set(ret) | set(ret_extra))
 258         if not ret:
 259             self.log.warning('Got nothing from music library.')
 260             self.log.warning('Try running in debug mode to guess why...')
 261             return []
 262         self.log.info('Got {} artists in library'.format(len(ret)))
 263         self.log.info(' / '.join(ret))
 264         # Move around similars items to get in unplayed|not recently played
 265         # artist first.
 266         return self._get_artists_list_reorg(ret)
 267
 268     def _get_album_history(self, artist=None):
 269         """Retrieve album history"""
 270         duration = self.daemon_conf.getint('sima', 'history_duration')
 271         albums_list = set()
 272         for trk in self.sdb.get_history(artist=artist, duration=duration):
 273             albums_list.add(trk[1])
 274         return albums_list
 275
 276     def find_album(self, artists):
 277         """Find albums to queue.
 278         """
 279         self.to_add = list()
 280         nb_album_add = 0
 281         target_album_to_add = self.plugin_conf.getint('album_to_add')
 282         for artist in artists:
 283             self.log.info('Looking for an album to add for "%s"...' % artist)
 284             albums = self.player.find_albums(artist)
 285             # str conversion while Album type is not propagated
 286             albums = [ str(album) for album in albums]
 287             if albums:
 288                 self.log.debug('Albums candidate: {0:s}'.format(' / '.join(albums)))
 289             else: continue
 290             # albums yet in history for this artist
 291             albums = set(albums)
 292             albums_yet_in_hist = albums & self._get_album_history(artist=artist)
 293             albums_not_in_hist = list(albums - albums_yet_in_hist)
 294             # Get to next artist if there are no unplayed albums
 295             if not albums_not_in_hist:
 296                 self.log.info('No album found for "%s"' % artist)
 297                 continue
 298             album_to_queue = str()
 299             random.shuffle(albums_not_in_hist)
 300             for album in albums_not_in_hist:
 301                 tracks = self.player.find_album(artist, album)
 302                 # Look if one track of the album is already queued
 303                 # Good heuristic, at least enough to guess if the whole album is
 304                 # already queued.
 305                 if tracks[0] in self.player.queue:
 306                     self.log.debug('"%s" already queued, skipping!' %
 307                             tracks[0].album)
 308                     continue
 309                 album_to_queue = album
 310             if not album_to_queue:
 311                 self.log.info('No album found for "%s"' % artist)
 312                 continue
 313             self.log.info('{2} album candidate: {0} - {1}'.format(
 314                            artist, album_to_queue, self.ws.name))
 315             nb_album_add += 1
 316             self.to_add.extend(self.player.find_album(artist, album_to_queue))
 317             if nb_album_add == target_album_to_add:
 318                 return True
 319
 320     def _track(self):
 321         """Get some tracks for track queue mode
 322         """
 323         artists = self.get_local_similar_artists()
 324         nbtracks_target = self.plugin_conf.getint('track_to_add')
 325         for artist in artists:
 326             self.log.debug('Trying to find titles to add for "{}"'.format(
 327                            artist))
 328             found = self.player.find_track(artist)
 329             # find tracks not in history for artist
 330             self.filter_track(found)
 331             if len(self.to_add) == nbtracks_target:
 332                 break
 333         if not self.to_add:
 334             self.log.debug('Found no tracks to queue, is your ' +
 335                             'history getting too large?')
 336             return None
 337         for track in self.to_add:
 338             self.log.info('{1} candidates: {0!s}'.format(track, self.ws.name))
 339
 340     def _album(self):
 341         """Get albums for album queue mode
 342         """
 343         artists = self.get_local_similar_artists()
 344         self.find_album(artists)
 345
 346     def _top(self):
 347         """Get some tracks for top track queue mode
 348         """
 349         #artists = self.get_local_similar_artists()
 350         pass
 351
 352     def callback_need_track(self):
 353         self._cleanup_cache()
 354         if not self.player.current:
 355             self.log.info('No current track, cannot queue')
 356             return None
 357         if not self.player.current.artist:
 358             self.log.warning('No artist set for the current track')
 359             self.log.debug(repr(self.player.current))
 360             return None
 361         self.queue_mode()
 362         candidates = self.to_add
 363         self.to_add = list()
 364         if self.plugin_conf.get('queue_mode') != 'album':
 365             random.shuffle(candidates)
 366         return candidates
 367
 368     def callback_player_database(self):
 369         self._flush_cache()
 370
 371 # VIM MODLINE
 372 # vim: ai ts=4 sw=4 sts=4 expandtab