sima/lib/plugin.py

   1 # -*- coding: utf-8 -*-
   2 # Copyright (c) 2013-2015, 2020-2021 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 Plugin object to derive from
  22 """
  23
  24 import random
  25
  26 from .meta import Artist, MetaContainer
  27
  28
  29 class Plugin:
  30     """
  31     First non-empty line of the docstring is used as description
  32     Rest of the docstring at your convenience.
  33
  34     The lowercased plugin Name MUST be the same as the module (file name),
  35     for instance Plugin → plugin.py
  36     It eases plugins discovery and simplifies the code to handle them,
  37     IMHO, it's a fair trade-off.
  38     """
  39
  40     @classmethod
  41     def info(cls):
  42         """self documenting class method
  43         """
  44         doc = 'Undocumented plugin! Fill "{}" docstring'.format(cls.__name__)
  45         if cls.__doc__:
  46             doc = cls.__doc__.strip(' \n').splitlines()[0]
  47         return {'name': cls.__name__,
  48                 'doc': doc}
  49
  50     def __init__(self, daemon):
  51         self.log = daemon.log
  52         self.player = daemon.player
  53         self.plugin_conf = None
  54         self.main_conf = daemon.config
  55         self.sdb = daemon.sdb
  56         self.__get_config()
  57
  58     def __str__(self):
  59         return self.__class__.__name__
  60
  61     def __get_config(self):
  62         """Get plugin's specific configuration from global applications's config
  63         """
  64         conf = self.main_conf
  65         for sec in conf.sections():  # Discovering plugin conf
  66             if sec == self.__class__.__name__.lower():
  67                 self.plugin_conf = conf[sec]
  68                 if 'priority' not in self.plugin_conf:
  69                     self.plugin_conf['priority'] = '80'
  70         if not self.plugin_conf:
  71             self.plugin_conf = {'priority': '80'}
  72         #if self.plugin_conf:
  73         #   self.log.debug('Got config for %s: %s', self, self.plugin_conf)
  74
  75     @property
  76     def priority(self):
  77         return self.plugin_conf.get('priority')
  78
  79     def start(self):
  80         """
  81         Called when the daemon().run() is called and
  82         right after the player has connected successfully.
  83         """
  84
  85     def callback_player(self):
  86         """
  87         Called on player changes, stopped, paused, skipped
  88         """
  89
  90     def callback_player_database(self):
  91         """
  92         Called on player music library changes
  93         """
  94
  95     def callback_playlist(self):
  96         """
  97         Called on playlist changes
  98         Not returning data
  99         """
 100
 101     def callback_next_song(self):
 102         """
 103         Could be use to scrobble, maintain an history…
 104         Not returning data,
 105         """
 106
 107     def callback_need_track(self):
 108         """
 109         Returns a list of Track objects to add
 110         """
 111
 112     def callback_need_track_fb(self):
 113         """
 114         Called when callback_need_track failled to find tracks to queue
 115         Returns a list of Track objects to add
 116         """
 117
 118     def shutdown(self):
 119         """Called on application shutdown"""
 120
 121
 122 class AdvancedPlugin(Plugin):
 123     """Object to derive from for plugins
 124     Exposes advanced music library look up with use of play history
 125     """
 126
 127     # Query History
 128     def get_history(self):
 129         """Returns a Track list of already played artists."""
 130         duration = self.main_conf.getint('sima', 'history_duration')
 131         return self.sdb.fetch_history(duration=duration)
 132
 133     def get_album_history(self, artist):
 134         """Retrieve album history"""
 135         duration = self.main_conf.getint('sima', 'history_duration')
 136         return self.sdb.fetch_albums_history(needle=artist, duration=duration)
 137
 138     def get_reorg_artists_list(self, alist):
 139         """
 140         Move around items in alist in order to have first not recently
 141         played (or about to be played) artists.
 142
 143         :param {Artist} alist: Artist objects list/container
 144         """
 145         queued_artist = MetaContainer([Artist(_.artist) for _ in
 146                                        self.player.queue if _.artist])
 147         not_queued_artist = alist - queued_artist
 148         duration = self.main_conf.getint('sima', 'history_duration')
 149         hist = []
 150         for art in self.sdb.fetch_artists_history(alist, duration=duration):
 151             if art not in hist:
 152                 if art not in queued_artist:
 153                     hist.insert(0, art)
 154                 else:
 155                     hist.append(art)
 156         # Find not recently played (not in history) & not in queue
 157         reorg = [art for art in not_queued_artist if art not in hist]
 158         reorg.extend(hist)
 159         return reorg
 160     # /Query History
 161
 162     # Find not recently played/unplayed
 163     def album_candidate(self, artist, unplayed=True):
 164         """Search an album for artist
 165
 166         :param Artist artist: Artist to fetch an album for
 167         :param bool unplayed: Fetch only unplayed album
 168         """
 169         self.log.info('Searching an album for "%s"...' % artist)
 170         albums = self.player.search_albums(artist)
 171         if not albums:
 172             return None
 173         self.log.debug('Albums candidates: %s', albums)
 174         albums_hist = self.get_album_history(artist)
 175         self.log.trace('Albums history: %s', [a.name for a in albums_hist])
 176         albums_not_in_hist = [a for a in albums if a.name not in albums_hist]
 177         # Get to next artist if there are no unplayed albums
 178         if not albums_not_in_hist:
 179             self.log.info('No unplayed album found for "%s"' % artist)
 180             if unplayed:
 181                 return None
 182         random.shuffle(albums_not_in_hist)
 183         albums_not_in_hist.extend(albums_hist)
 184         self.log.debug('Albums candidate: %s', albums_not_in_hist)
 185         album_to_queue = []
 186         for album in albums_not_in_hist:
 187             # Controls the album found is not already queued
 188             if album in {t.album for t in self.player.queue}:
 189                 self.log.debug('"%s" already queued, skipping!', album)
 190                 continue
 191             # In random play mode use complete playlist to filter
 192             if self.player.playmode.get('random'):
 193                 if album in {t.album for t in self.player.playlist}:
 194                     self.log.debug('"%s" already in playlist, skipping!',
 195                                    album)
 196                     continue
 197             album_to_queue = album
 198             break
 199         if not album_to_queue:
 200             self.log.info('No album found for "%s"', artist)
 201             return None
 202         self.log.info('%s plugin chose album: %s - %s',
 203                       self.__class__.__name__, artist, album_to_queue)
 204         return album_to_queue
 205
 206     def filter_track(self, tracks, unplayed=False):
 207         """
 208         Extract one unplayed track from a Track object list.
 209             * not in history
 210             * not already in the queue
 211         """
 212         artist = tracks[0].Artist
 213         # In random play mode use complete playlist to filter
 214         if self.player.playmode.get('random'):
 215             deny_list = self.player.playlist
 216         else:
 217             deny_list = self.player.queue
 218         not_in_hist = list(set(tracks) - set(self.sdb.fetch_history(artist=artist)))
 219         if not not_in_hist:
 220             self.log.debug('All tracks already played for "%s"', artist)
 221             if unplayed:
 222                 return None
 223         random.shuffle(not_in_hist)
 224         candidates = []
 225         for trk in [_ for _ in not_in_hist if _ not in deny_list]:
 226             # Should use albumartist heuristic as well
 227             if self.plugin_conf.getboolean('single_album', False):  # pylint: disable=no-member
 228                 albums = [tr.album for tr in deny_list]
 229                 albums += [tr.album for tr in self.to_add]
 230                 if (trk.album == self.player.current.album or
 231                         trk.album in albums):
 232                     self.log.debug('Found unplayed track ' +
 233                                    'but from an album already queued: %s', trk)
 234                     continue
 235             candidates.append(trk)
 236         if not candidates:
 237             return None
 238         return random.choice(candidates)
 239
 240 # VIM MODLINE
 241 # vim: ai ts=4 sw=4 sts=4 expandtab