def get_album(keyword, id=False, artist=False):
if id == True:
result = query.getReleaseById(keyword, release_inc)
else:
if artist == True:
f = ws.ReleaseFilter(artistName=keyword)
else:
f = ws.ReleaseFilter(title=keyword)
result = query.getReleases(f)
return result
def musicbrainz(discid):
"""
Based on a MusicBrainz disc id, get a list of DiscMetadata objects
for the given disc id.
Example disc id: Mj48G109whzEmAbPBoGvd4KyCS4-
@type discid: str
@rtype: list of L{DiscMetadata}
"""
log.debug('musicbrainz', 'looking up results for discid %r', discid)
#import musicbrainz2.disc as mbdisc
import musicbrainz2.webservice as mbws
results = []
# Setup a Query object.
service = mbws.WebService()
query = mbws.Query(service)
# Query for all discs matching the given DiscID.
# FIXME: let mbws.WebServiceError go through for now
try:
rfilter = mbws.ReleaseFilter(discId=discid)
results = query.getReleases(rfilter)
except mbws.WebServiceError, e:
raise MusicBrainzException(e)
def get_mb_release_id(self):
q = ws.Query()
filter = ws.ReleaseFilter(discId=self.disc_id)
try: results = q.getReleases(filter=filter)
except: return None
else:
if len(results) > 0:
return results[0].release.getId()
return None
def __do_query(self, *args):
"""Search for album using the query text."""
query = self.search_query.get_text()
if not query:
self.result_label.set_markup("<b>Please enter a query.</b>")
self.search_button.set_sensitive(True)
return
self.result_label.set_markup("<i>Searching...</i>")
filt = ws.ReleaseFilter(query=query)
self._qthread.add(self.__process_results, self._query.getReleases,
filt)
def searchMbByDiscId(discId):
q = ws.Query()
rf = ws.ReleaseFilter(discId=cdid)
releases = [result.getRelease() for result in q.getReleases(rf)]
numFound = len(releases)
if numFound == 0:
print "*** DISC ID NO LONGER VALID ***"
return None
else:
return releases
def mbzQuery(self):
query = CachedMBZQuery()
debug(' - Trying to guess an ID for track \"' + str(self.title) +
'\", artist \"' + str(self.artist) + '\", release \"' +
str(self.album) + '\"')
artist_filter = ws.ArtistFilter(name=str(self.artist))
try:
artists = query.getArtists(filter=artist_filter)
artist_mapping = []
release_mapping = []
track_mapping = []
if (self.album == None):
debug("No release information, dropping release lookup")
for artist in artists:
artist_id = (MbzURIConverter(artist.artist.id)).getId()
artist_mapping.append((artist.score, artist))
if (self.album != None):
release_filter = ws.ReleaseFilter(query='(release:' +
str(self.album) + ') ' +
' AND arid:' + artist_id)
releases = query.getReleases(release_filter)
for release in releases:
release_id = (MbzURIConverter(
release.release.id)).getId()
release_mapping.append(
((release.score + artist.score) / 2, release))
track_filter = ws.TrackFilter(
query='(track:' + str(self.title) + ') ' +
' AND reid:' + release_id)
tracks = query.getTracks(track_filter)
for track in tracks:
track_mapping.append(
((track.score + release.score + artist.score) /
3, track))
else:
track_filter = ws.TrackFilter(query='(track:' +
str(self.title) + ') ' +
' AND arid:' + artist_id)
tracks = query.getTracks(track_filter)
for track in tracks:
track_mapping.append(
((track.score + artist.score) / 2, track))
except ResponseError, e:
raise MbzLookupException('Musicbrainz response error')
def get_releases_by_cdtext(title, performer, num_tracks):
""" Given the performer, title and number of tracks on a disc, lookup
the release in musicbrainz. This method returns a list of possible results, or
the empty list if there were no matches. """
if title == "" or performer == "":
return []
q = ws.Query(clientId=CLIENTID)
filter = ws.ReleaseFilter(title=title, artistName=performer)
rels = q.getReleases(filter=filter)
# Filter out of the list releases with a different number of tracks to
# the Disc.
return [
r for r in rels if len(
get_release_by_releaseid(r.release.id).getTracks()) == num_tracks
]
def musicbrainz(discid):
metadata = DiscMetadata()
import musicbrainz2.disc as mbdisc
import musicbrainz2.webservice as mbws
# Setup a Query object.
service = mbws.WebService()
query = mbws.Query(service)
# Query for all discs matching the given DiscID.
try:
filter = mbws.ReleaseFilter(discId=discid)
results = query.getReleases(filter)
except mbws.WebServiceError, e:
print "Error:", e
return
def get_releases(**params):
"""Given a list of parameters to ReleaseFilter, executes the
query and yields release dicts (complete with tracks).
"""
# Replace special cases.
if 'artistName' in params:
artist = params['artistName']
if artist in SPECIAL_CASE_ARTISTS:
del params['artistName']
params['artistId'] = SPECIAL_CASE_ARTISTS[artist]
# Issue query.
filt = mbws.ReleaseFilter(**params)
results = _query_wrap(mbws.Query().getReleases, filter=filt)
# Construct results.
for result in results:
release = result.release
tracks, _ = release_info(release.id)
yield release_dict(release, tracks)
def _lookup_mb(self):
"""
throws an exception if the CD can't be read, returns None if the CD
is ok but musicbrainz has nothing for us.
"""
disc = mbdisc.readDisc(self.cddevice) # exception here if no cd
try:
# search by disc ID
svc = mbws.WebService()
q = mbws.Query(svc)
matches = q.getReleases(mbws.ReleaseFilter(discId=disc.getId()))
if len(matches) == 0:
wx.LogMessage('no results from musicbrains')
return None
# go back for full details on the first match
wx.LogMessage('musicbrains found %d matches' % len(matches))
release = matches[0].release
#inc = mbws.ReleaseIncludes(artist=True, tracks=True,
# releaseEvents=True)
#release = q.getReleaseById(release.getId(), inc)
isOneArtist = release.isSingleArtistRelease()
ret = cdinfo()
ret.artist = release.artist.getUniqueName()
ret.album = release.title
# using the dictionary is gratuitous for musicbrainz, which
# returns the titles in order, but cddb does not.
i = 1
for t in release.tracks:
if isOneArtist or t.artist is None:
ret.titles[i] = t.title
else:
ret.titles[i] = '%s-%s' % (t.artist.name, t.title)
i += 1
except mbws.WebServiceError, e:
wx.LogMessage('musicbrainz error: %s' % e)
return None
def searchMbForDisc(device):
d = disc.readDisc(device)
cdid = d.id
numTracks = d.getLastTrackNum()
toc = {}
toc["first_track"] = 1
toc["num_tracks"] = numTracks
toc["length"] = d.sectors
toc["offsets"] = [x for (x, y) in d.getTracks()]
logging.debug("toc: %s" % str(toc))
logging.info("querying musicbrainz.org to see if this cd is on there...")
q = ws.Query()
rf = ws.ReleaseFilter(discId=cdid)
releases = [result.getRelease() for result in q.getReleases(rf)]
numFound = len(releases)
if numFound == 0:
return (toc, numFound, (disc.getSubmissionUrl(d), ), None)
else:
return (toc, numFound, (cdid, numTracks), releases)
warn('You need python-musicbrainz2 (or python-cddb) to convert cds. Please install it. Trying cddb.')
raise self.MBError, err
service = mbws.WebService()
query = mbws.Query(service)
# Read the disc in the drive
try:
disc = mbdisc.readDisc(self.dev)
except mbdisc.DiscError, err:
warn(err)
raise self.MBError
discId = disc.getId()
try:
myfilter = mbws.ReleaseFilter(discId=discId)
results = query.getReleases(myfilter)
except mbws.WebServiceError, err:
warn(err)
raise self.MBError
if len(results) == 0:
print "Disc is not yet in the MusicBrainz database."
print "Consider adding it via", mbdisc.getSubmissionUrl(disc)
raise self.MBError
try:
inc = mbws.ReleaseIncludes(artist=True, tracks=True, releaseEvents=True)
release = query.getReleaseById(results[0].release.getId(), inc)
except mbws.WebServiceError, err:
warn(err)
raise self.MBError
def get_mb(self):
try:
import musicbrainz2.disc as mbdisc
import musicbrainz2.webservice as mbws
except ImportError as err:
warn(
'You need python-musicbrainz2 (or python-cddb) to convert cds. Please install it. Trying cddb.'
)
raise self.MBError(err)
service = mbws.WebService()
query = mbws.Query(service)
# Read the disc in the drive
try:
disc = mbdisc.readDisc(self.dev)
except mbdisc.DiscError as err:
warn(err)
raise self.MBError
discId = disc.getId()
try:
myfilter = mbws.ReleaseFilter(discId=discId)
results = query.getReleases(myfilter)
except mbws.WebServiceError as err:
warn(err)
raise self.MBError
if len(results) == 0:
print("Disc is not yet in the MusicBrainz database.")
print("Consider adding it via", mbdisc.getSubmissionUrl(disc))
raise self.MBError
try:
inc = mbws.ReleaseIncludes(artist=True,
tracks=True,
releaseEvents=True)
release = query.getReleaseById(results[0].release.getId(), inc)
except mbws.WebServiceError as err:
warn(err)
raise self.MBError
isSingleArtist = release.isSingleArtistRelease()
try:
# try to get the CDDB ID
import DiscID
cddb_id = '%08lx' % int(DiscID.disc_id(DiscID.open(self.dev))[0])
except:
cddb_id = False
trackn = 1
for track in release.tracks:
title = {}
title[
'artist'] = isSingleArtist and release.artist.name or track.artist
if cddb_id:
title['discid'] = cddb_id
title['album'] = release.title
title['date'] = release.getEarliestReleaseDate()
title['musicbrainz_albumartistid'] = release.artist.id.split(
"/")[-1]
title['musicbrainz_albumid'] = release.id.split("/")[-1]
title['musicbrainz_discid'] = discId
title['musicbrainz_sortname'] = release.artist.sortName
title['musicbrainz_trackid'] = track.id.split("/")[-1]
title['title'] = track.title
title['tracktotal'] = str(len(release.tracks))
title['ntracknumber'] = "%02d" % trackn
title['tracknumber'] = str(trackn)
ConvertTrack(self.dev, self.conf, trackn, title)
trackn += 1
def get_releases_by_discid(discid):
""" Given a musicbrainz disc-id, fetch a list of possible releases. """
q = ws.Query(clientId=CLIENTID)
filter = ws.ReleaseFilter(discId=discid)
return q.getReleases(filter=filter)
