# -*- coding: utf-8 -*-
-# Copyright (c) 2009-2020 kaliko <kaliko@azylum.org>
+# Copyright (c) 2009-2021 kaliko <kaliko@azylum.org>
#
# This file is part of sima
#
from difflib import get_close_matches
from functools import wraps
from itertools import dropwhile
+from logging import getLogger
# external module
from musicpd import MPDClient, MPDError
class PlayerError(Exception):
- """Fatal error in poller."""
+ """Fatal error in the player."""
# Some decorators
return None
names = list()
for art in result.names:
- if cls.database.get_bl_artist(art, add_not=True):
- cls.log.debug('Blacklisted "%s"', art)
+ artist = Artist(name=art, mbid=result.mbid)
+ if cls.database.get_bl_artist(artist, add=False):
+ cls.log.debug('Artist "%s" in blocklist!', artist)
continue
names.append(art)
if not names:
# / decorators
-def blacklist(artist=False, album=False, track=False):
+def blocklist(album=False, track=False):
# pylint: disable=C0111,W0212
field = (album, track)
#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):
+ if bl_getter(elem, add=False):
#cls.log.debug('Blacklisted "{0}"'.format(elem))
continue
- if track and cls.database.get_bl_album(elem, add_not=True):
+ if track and cls.database.get_bl_album(elem, add=False):
# filter album as well in track mode
# (artist have already been)
- cls.log.debug('Blacklisted alb. "%s"', elem)
+ cls.log.debug('Album "%s" in blocklist', elem)
continue
results.append(elem)
return results
"""
needed_cmds = ['status', 'stats', 'add', 'find',
'search', 'currentsong', 'ping']
- needed_mbid_tags = {'Artist', 'Album', 'AlbumArtist',
- 'Title', 'Track', 'Genre',
- 'MUSICBRAINZ_ARTISTID', 'MUSICBRAINZ_ALBUMID',
+ needed_tags = {'Artist', 'Album', 'AlbumArtist', 'Title', 'Track'}
+ needed_mbid_tags = {'MUSICBRAINZ_ARTISTID', 'MUSICBRAINZ_ALBUMID',
'MUSICBRAINZ_ALBUMARTISTID', 'MUSICBRAINZ_TRACKID'}
+ MPD_supported_tags = {'Artist', 'ArtistSort', 'Album', 'AlbumSort', 'AlbumArtist',
+ 'AlbumArtistSort', 'Title', 'Track', 'Name', 'Genre',
+ 'Date', 'OriginalDate', 'Composer', 'Performer',
+ 'Conductor', 'Work', 'Grouping', 'Disc', 'Label',
+ 'MUSICBRAINZ_ARTISTID', 'MUSICBRAINZ_ALBUMID',
+ 'MUSICBRAINZ_ALBUMARTISTID', 'MUSICBRAINZ_TRACKID',
+ 'MUSICBRAINZ_RELEASETRACKID', 'MUSICBRAINZ_WORKID'}
database = None
- def __init__(self, daemon):
+ def __init__(self, config):
super().__init__()
self.use_mbid = True
- self.daemon = daemon
- self.log = daemon.log
- self.config = self.daemon.config['MPD']
+ self.log = getLogger('sima')
+ self.config = config
self._cache = None
# ######### Overriding MPDClient ###########
def connect(self):
"""Overriding explicitly MPDClient.connect()"""
+ mpd_config = self.config['MPD']
# host, port, password
- host = self.config.get('host')
- port = self.config.get('port')
- password = self.config.get('password', fallback=None)
+ host = mpd_config.get('host')
+ port = mpd_config.get('port')
+ password = mpd_config.get('password', fallback=None)
self.disconnect()
try:
super().connect(host, port)
raise PlayerError('Could connect to "%s", '
'but command "%s" not available' %
(host, cmd))
- # Controls use of MusicBrainzIdentifier
self.tagtypes('clear')
+ for tag in MPD.needed_tags:
+ self.tagtypes('enable', tag)
+ tt = set(map(str.lower, self.tagtypes()))
+ needed_tags = set(map(str.lower, MPD.needed_tags))
+ if len(needed_tags & tt) != len(MPD.needed_tags):
+ self.log.warning('MPD exposes: %s', tt)
+ self.log.warning('Tags needed: %s', needed_tags)
+ raise PlayerError('Missing mandatory metadata!')
for tag in MPD.needed_mbid_tags:
self.tagtypes('enable', tag)
- if self.daemon.config.get('sima', 'musicbrainzid'):
+ # Controls use of MusicBrainzIdentifier
+ if self.config.getboolean('sima', 'musicbrainzid'):
tt = set(self.tagtypes())
if len(MPD.needed_mbid_tags & tt) != len(MPD.needed_mbid_tags):
self.log.warning('Use of MusicBrainzIdentifier is set but MPD '
def _reset_cache(self):
"""
Both flushes and instantiates _cache
+
+ * artists: all artists
+ * nombid_artists: artists with no mbid (set only when self.use_mbid is True)
+ * artist_tracks: caching last artist tracks, used in search_track
"""
if isinstance(self._cache, dict):
self.log.info('Player: Flushing cache!')
else:
self.log.info('Player: Initialising cache!')
self._cache = {'artists': frozenset(),
- 'nombid_artists': frozenset()}
- self._cache['artist_tracks'] = {}
+ 'nombid_artists': frozenset(),
+ 'artist_tracks': {}}
+ self._cache['artists'] = frozenset(filter(None, self.list('artist')))
if self.use_mbid:
artists = self.list('artist', "(MUSICBRAINZ_ARTISTID == '')")
self._cache['nombid_artists'] = frozenset(filter(None, artists))
- else:
- self._cache['artists'] = frozenset(filter(None, self.list('artist')))
def _skipped_track(self, previous):
if (self.state == 'stop'
tracks = set()
if artist.mbid:
tracks |= set(self.find('musicbrainz_artistid', artist.mbid))
- for name in artist.names_sz:
+ for name in artist.names:
tracks |= set(self.find('artist', name))
return list(tracks)
if not hasattr(album, 'artist'):
raise PlayerError('Album object have no artist attribute')
albums = []
- if self.use_mbid and album.mbid:
+ if album.mbid:
filt = f"(MUSICBRAINZ_ALBUMID == '{album.mbid}')"
albums = self.find(filt)
# Now look for album with no MusicBrainzIdentifier
- if not albums and album.artist.mbid and self.use_mbid: # Use album artist MBID if possible
+ if not albums and album.artist.mbid: # Use album artist MBID if possible
filt = f"((MUSICBRAINZ_ALBUMARTISTID == '{album.artist.mbid}') AND (album == '{album.name_sz}'))"
albums = self.find(filt)
if not albums: # Falls back to (album)?artist/album name
Returns an Artist object
"""
found = False
- if self.use_mbid and artist.mbid:
+ if artist.mbid:
# look for exact search w/ musicbrainz_artistid
library = self.list('artist', f"(MUSICBRAINZ_ARTISTID == '{artist.mbid}')")
if library:
if len(library) > 1:
self.log.debug('I got "%s" searching for %r', library, artist)
elif len(library) == 1 and library[0] != artist.name:
+ new_alias = artist.name
self.log.info('Update artist name %s->%s', artist, library[0])
+ self.log.debug('Also add alias for %s: %s', artist, new_alias)
artist = Artist(name=library[0], mbid=artist.mbid)
+ artist.add_alias(new_alias)
# Fetches remaining artists for potential match
artists = self._cache['nombid_artists']
else: # not using MusicBrainzIDs
if SimaStr(artist.name) == fuzz:
found = True
artist.add_alias(fuzz)
- self.log.info('"%s" quite probably matches "%s" (SimaStr)',
- fuzz, artist)
+ self.log.debug('"%s" quite probably matches "%s" (SimaStr)',
+ fuzz, artist)
if found:
if artist.aliases:
- self.log.debug('Found aliases: %s', '/'.join(artist.names))
+ self.log.info('Found aliases: %s', '/'.join(artist.names))
return artist
return None
- @blacklist(track=True)
+ @blocklist(track=True)
def search_track(self, artist, title):
"""Fuzzy search of title by an artist
"""
mtitle, title, leven)
return tracks
- @blacklist(album=True)
+ @blocklist(album=True)
def search_albums(self, artist):
"""Find potential albums for "artist"
looking for albums for Artist_B returns wrongly this album.
"""
# First, look for all potential albums
- self.log.debug('Searching album for "%s"', artist)
+ self.log.debug('Searching album for "%r"', artist)
if artist.aliases:
self.log.debug('Searching album for %s aliases: "%s"',
artist, artist.aliases)
for name_sz in artist.names_sz:
- raw_albums = self.list('album', f"( albumartist == '{name_sz}')")
- albums = [Album(a, albumartist=artist.name, artist=artist) for a in raw_albums if a]
+ mpd_filter = f"((albumartist == '{name_sz}') AND ( album != ''))"
+ raw_albums = self.list('album', mpd_filter)
+ albums = [Album(a, albumartist=artist.name, artist=artist) for a in raw_albums]
candidates = []
for album in albums:
album_trks = self.find_tracks(album)
home / dev / repositories / mpd-sima.git / blobdiff