def testGetReleasegroup(self):
musicbrainzngs.get_release_group_by_id("9377d65d-ffd5-35d6-b64d-43f86ef9188d")
self.assertEqual("http://musicbrainz.org/ws/2/release-group/9377d65d-ffd5-35d6-b64d-43f86ef9188d", _common.opener.get_url())
# one include
musicbrainzngs.get_release_group_by_id("9377d65d-ffd5-35d6-b64d-43f86ef9188d", includes=["artists"])
self.assertEqual("http://musicbrainz.org/ws/2/release-group/9377d65d-ffd5-35d6-b64d-43f86ef9188d?inc=artists", _common.opener.get_url())
def testGetReleasegroup(self):
musicbrainzngs.get_release_group_by_id(
"9377d65d-ffd5-35d6-b64d-43f86ef9188d")
self.assertEqual(
"http://musicbrainz.org/ws/2/release-group/9377d65d-ffd5-35d6-b64d-43f86ef9188d",
_common.opener.get_url())
# one include
musicbrainzngs.get_release_group_by_id(
"9377d65d-ffd5-35d6-b64d-43f86ef9188d", includes=["artists"])
self.assertEqual(
"http://musicbrainz.org/ws/2/release-group/9377d65d-ffd5-35d6-b64d-43f86ef9188d?inc=artists",
_common.opener.get_url())
def get_data(self, data):
self.result = mbngs.search_release_groups(('%s' % data['Title']), artist=('%s'%data['Artist']), primarytype='album')
x = 0
while True:
topResult = self.result['release-group-list'][x]
topID = topResult['id']
try:
pics = mbngs.get_release_group_image_list(topID)
self.releaseGroupID = topID
break
except:
x += 1
self.url = pics['images'][0]['image']
self.filename = self.url.split('/')[-1]
# Used for testing / devlopment. Save the cover art to a local directory.
# urllib.urlretrieve(self.url, self.filename)
self.returnData['Art'] = self.url
self.releaseResult = mbngs.get_release_group_by_id(self.releaseGroupID)
self.returnData['Date'] = self.releaseResult['release-group']['first-release-date']
print self.returnData
return self.returnData
def find_release_group(release_title, artist=None):
results = musicbrainzngs.search_release_groups(
release_title, artist=artist, limit=10)['release-group-list']
table_data = [('Index', 'Artist', 'Title', 'Type')]
# max_width = table.column_max_width(2)
for i, r in enumerate(results):
# title = '\n'.join(wrap(r['title'], max_width))
table_data.append(
(i, r['artist-credit-phrase'], r['title'], r.get('type', '?')))
print(terminaltables.SingleTable(table_data).table)
while True:
choice = input(
"Select the release group (or enter a different query): ")
try:
choice = int(choice)
except ValueError:
if choice != '':
return find_release_group(choice)
continue
try:
choice = results[choice]
except IndexError:
pass
else:
return musicbrainzngs.get_release_group_by_id(
choice['id'], includes=['tags', 'artist-credits',
'url-rels'])['release-group']
def allreleases(self, lib, album):
musicbrainzngs.set_useragent("beets.io", "0.1", "beets.io")
URL = 'https://coverartarchive.org/release/'
save_path = '/Users/dilanuslan/Desktop/NewMusic/' #the constant part of the path
save_path = save_path + album.albumartist + '/' + album.album #the artist name and the album name is added to the path
message = "Checking all releases for {0}".format(album.album)
print(message)
##this block creates a list that contains the musicbrainz id's of all releases of an album
idlist = []
release_group_dict = musicbrainzngs.get_release_group_by_id(
album.mb_releasegroupid, includes=["releases"])
base_key = 'release-count'
for item in release_group_dict.values():
release_keys = item.keys()
if item[base_key] > 1:
key = 'release-list'
if key in release_keys:
release_list_items = item[key]
for dic in release_list_items:
release_list_keys = dic.keys()
key2 = 'id'
if key2 in release_list_keys:
releaseid = dic[key2]
idlist.append(releaseid)
##this block makes a query for each id in the list, if the response turns ok the cover is downloaded to a file in the album's directory.
for i in range(0, len(idlist)):
filename = "cover{}.jpg".format(i + 1)
finalname = os.path.join(save_path,
filename) #adding filename to the path
if (os.path.exists(finalname)):
return
else:
pic_url = "http://coverartarchive.org/release/{}/front".format(
idlist[i])
with open(finalname, 'wb') as cover:
response = requests.get(pic_url, stream=True)
if not response.ok:
os.remove(finalname)
for block in response.iter_content(1024):
if not block:
break
cover.write(block)
def getReleaseGroup(rgid):
"""
Returns a list of releases in a release group
"""
releaseGroup = None
try:
with mb_lock:
releaseGroup = musicbrainzngs.get_release_group_by_id(
rgid, [
"artists",
"releases",
"media",
"discids",
])
releaseGroup = releaseGroup['release-group']
except musicbrainzngs.WebServiceError as e:
logger.warn(
'Attempt to retrieve information from MusicBrainz for release group "%s" failed (%s)'
% (rgid, str(e)))
mb_lock.snooze(5)
if not releaseGroup:
return False
else:
return releaseGroup['release-list']
def main():
m.set_useragent("application", "0.01", "http://example.com")
print(m.get_artist_by_id("952a4205-023d-4235-897c-6fdb6f58dfaa", []))
print(m.get_label_by_id("aab2e720-bdd2-4565-afc2-460743585f16"))
print(m.get_release_by_id("e94757ff-2655-4690-b369-4012beba6114"))
print(m.get_release_group_by_id("9377d65d-ffd5-35d6-b64d-43f86ef9188d"))
print(m.get_recording_by_id("cb4d4d70-930c-4d1a-a157-776de18be66a"))
print(m.get_work_by_id("7e48685c-72dd-3a8b-9274-4777efb2aa75"))
print(m.get_releases_by_discid("BG.iuI50.qn1DOBAWIk8fUYoeHM-"))
print(m.get_recordings_by_puid("070359fc-8219-e62b-7bfd-5a01e742b490"))
print(m.get_recordings_by_isrc("GBAYE9300106"))
m.auth("", "")
m.submit_barcodes(
{"e94757ff-2655-4690-b369-4012beba6114": "9421021463277"})
m.submit_tags(recording_tags={
"cb4d4d70-930c-4d1a-a157-776de18be66a": ["these", "are", "my", "tags"]
})
m.submit_tags(
artist_tags={"952a4205-023d-4235-897c-6fdb6f58dfaa": ["NZ", "twee"]})
m.submit_ratings(
recording_ratings={"cb4d4d70-930c-4d1a-a157-776de18be66a": 20})
m.submit_echoprints(
{"e97f805a-ab48-4c52-855e-07049142113d": "anechoprint1234567"})
def album_details(cls, release_group):
try:
api_resp = get_release_group_by_id(release_group, includes=['artists']).get('release-group')
resp = dict(title=api_resp.get('title'),
artist=api_resp.get('artist-credit-phrase'),
release_date=api_resp.get('first-release-date')[:4])
except:
resp = dict(title=None, artist=None, release_date=None)
return resp
def query_artist(artist_id):
def check_for_official_album(album_release_list):
for release_list in album_release_list:
if release_list['status'] == 'Official':
return True
return False
artist_query = musicbrainzngs.get_artist_by_id(
artist_id, includes=['artist-rels', 'release-groups'])
artist_list = {"artist_list": []}
artist_object = {"meta": {}, "album_list": []}
artist_name = artist_query["artist"]["name"]
# Get members through artist id query
members_of_group = []
if artist_query['artist']['type'] == 'Group':
for member in artist_query['artist']['artist-relation-list']:
if member['type'] == 'member of band':
members_of_group.append(member['artist']['name'])
else:
for member in artist_query['artist']['artist-relation-list']:
if member['type'] == 'is person':
members_of_group.append(member['artist']['name'])
# Get albums through the release group relationship
releases = artist_query['artist']['release-group-list']
album_list = []
for release in releases:
if release['type'] == 'Album':
album_info = musicbrainzngs.get_release_group_by_id(
release['id'], includes=['releases'])
album_release_list = album_info['release-group']['release-list']
if check_for_official_album(album_release_list) == True: # and :
album = {
"name": release['title'],
"release_date": release['first-release-date']
}
artist_object["album_list"].append(album)
meta = {"name": artist_name, "members": members_of_group}
artist_object["meta"].update(meta)
artist_list["artist_list"].append(artist_object)
artists_file = '%s.json' % (artist_name)
f = open(artists_file, 'w')
f.write(json.dumps(artist_list, indent=4, sort_keys=False))
f.close()
def get_release(release_mbid):
try:
result = mbz.get_release_group_by_id(release_mbid,
includes=["artist-credits"])
except mbz.ResponseError as err:
status = err.cause.code
result = None
else:
status = 200
result = result["release-group"]
return {"status": status, "release": result}
def testGetReleasegroup(self):
musicbrainzngs.get_release_group_by_id("9377d65d-ffd5-35d6-b64d-43f86ef9188d")
self.assertEqual(
"http://musicbrainz.org/ws/2/release-group/9377d65d-ffd5-35d6-b64d-43f86ef9188d", self.opener.get_url()
)
# one include
release_group_id = "9377d65d-ffd5-35d6-b64d-43f86ef9188d"
musicbrainzngs.get_release_group_by_id(release_group_id, includes=["artists"])
self.assertEqual(
"http://musicbrainz.org/ws/2/release-group/9377d65d-ffd5-35d6-b64d-43f86ef9188d?inc=artists",
self.opener.get_url(),
)
# with valid filters
musicbrainzngs.get_release_group_by_id(release_group_id, release_type=["compilation", "live"])
self.assertTrue("type=compilation%7Clive" in self.opener.get_url())
# with invalid filters
self.assertRaises(
musicbrainzngs.UsageError,
musicbrainzngs.get_release_group_by_id,
release_group_id,
release_status=["official", "promotion"],
)
def testGetReleasegroup(self):
musicbrainzngs.get_release_group_by_id(
"9377d65d-ffd5-35d6-b64d-43f86ef9188d")
self.assertEqual(
"http://musicbrainz.org/ws/2/release-group/9377d65d-ffd5-35d6-b64d-43f86ef9188d",
self.opener.get_url())
# one include
release_group_id = "9377d65d-ffd5-35d6-b64d-43f86ef9188d"
musicbrainzngs.get_release_group_by_id(release_group_id,
includes=["artists"])
self.assertEqual(
"http://musicbrainz.org/ws/2/release-group/9377d65d-ffd5-35d6-b64d-43f86ef9188d?inc=artists",
self.opener.get_url())
# with valid filters
musicbrainzngs.get_release_group_by_id(
release_group_id, release_type=["compilation", "live"])
self.assertTrue("type=compilation%7Clive" in self.opener.get_url())
# with invalid filters
self.assertRaises(musicbrainzngs.UsageError,
musicbrainzngs.get_release_group_by_id,
release_group_id,
release_status=["official", "promotion"])
def get_tracks(evt):
albumslist = m.get_release_group_by_id(evt.target.get_selected_items()[0]['id'], includes="releases")
resultList = []
print("=========================")
print("=========================")
print(albumslist)
print("=========================")
print("=========================")
tracks = m.get_release_by_id(albumslist['release-group']['release-list'][0]['id'], includes=["artists", "recordings"])
album_id = tracks["release"]["id"]
for idx, track in enumerate(tracks["release"]["medium-list"][0]["track-list"]):
resultList.append([track["recording"]["title"], album_id])
lv = mainwin['trackslist']
lv.items = resultList
def getReleaseGroup(rgid):
"""
Returns a list of releases in a release group
"""
releaseGroup = None
try:
with mb_lock:
releaseGroup = musicbrainzngs.get_release_group_by_id(
rgid, ["artists", "releases", "media", "discids", ])
releaseGroup = releaseGroup['release-group']
except musicbrainzngs.WebServiceError as e:
logger.warn('Attempt to retrieve information from MusicBrainz for release group "%s" failed (%s)' % (rgid, str(e)))
mb_lock.snooze(5)
if not releaseGroup:
return False
else:
return releaseGroup['release-list']
def _tmpl_releasegroupartist(self, item):
if item.singleton:
return None
if len(item.mb_releasegroupid) == 0:
return item.albumartist
if item.mb_releasegroupid != self.mb_releasegroupid:
try:
rel = musicbrainzngs.get_release_group_by_id(
item.mb_releasegroupid, ['artist-credits'])
self.releasegroupartist = rel['release-group'][
'artist-credit'][0]['artist']['name']
except:
self.releasegroupartist = item.albumartist
finally:
self.mb_releasegroupid = item.mb_releasegroupid
return self.releasegroupartist
def __get_artist_credits(self):
datarel = self.relations
for rel in datarel:
i = rel["release-group"]["id"]
cache_file = f'{cache_dir}/release-group-{i}.json'
try:
with open(cache_file) as f:
credit = json.load(f)
except FileNotFoundError:
print('Reading artists from musicbrainz:',
rel["release-group"]["title"])
credit = musicbrainzngs.get_release_group_by_id(
i, includes=["artist-credits"])
with open(cache_file, 'w') as f:
json.dump(credit, f)
rel["release-group"]["artist-credit"] = credit["release-group"][
"artist-credit"]
rel["release-group"]["artist-credit-phrase"] = credit[
"release-group"]["artist-credit-phrase"]
def _tmpl_releasegroupartist(self, item):
if item.singleton:
return None
if item.mb_releasegroupid != self.mb_releasegroupid:
self._log.debug('Finding releasegrouparitst for ' +
item.albumartist + ' - ' + item.album)
try:
rel = musicbrainzngs.get_release_group_by_id(
item.mb_releasegroupid, ['artist-credits'])
self.releasegroupartist = rel['release-group'][
'artist-credit'][0]['artist']['name']
self.mb_releasegroupid = item.mb_releasegroupid
except:
self.releasegroupartist = item.albumartist
self.mb_releasegroupid = item.mb_releasegroupid
self._log.debug('No MB Credits found for ' + item.albumartist +
' - ' + item.album)
return self.releasegroupartist
def get_release_group_by_id(self, id, includes=[]):
"""Get release group with the MusicBrainz ID.
Available includes: artists, releases, discids, media, artist-credits, annotation, aliases, tags, user-tags,
ratings, user-ratings, area-rels, artist-rels, label-rels, place-rels, recording-rels, release-rels,
release-group-rels, url-rels, work-rels.
"""
key = generate_cache_key(id, type='release_group', source='api', params=includes)
release_group = cache.get(key)
if not release_group:
try:
release_group = get_release_group_by_id(id, includes).get('release-group')
except ResponseError as e:
if e.cause.code == 404:
raise APIError(code=e.cause.code,
desc="Sorry, we could not find a release group with that MusicBrainz ID.")
else:
raise APIError(code=e.cause.code, desc=e.cause.msg)
release_group = release_group_rel.process(release_group)
cache.set(key, release_group, DEFAULT_CACHE_EXPIRATION)
return release_group
def getArtistForReleaseGroup(rgid):
"""
Returns artist name for a release group
Used for series where we store the series instead of the artist
"""
releaseGroup = None
try:
with mb_lock:
releaseGroup = musicbrainzngs.get_release_group_by_id(
rgid, ["artists"])
releaseGroup = releaseGroup['release-group']
except musicbrainzngs.WebServiceError as e:
logger.warn(
'Attempt to retrieve information from MusicBrainz for release group "%s" failed (%s)'
% (rgid, str(e)))
mb_lock.snooze(5)
if not releaseGroup:
return False
else:
return releaseGroup['artist-credit'][0]['artist']['name']
def get_release_group(self, releases):
release_lists = [
r['release-list'] for r in releases if 'release-list' in releases
]
if len(release_lists) == 0:
return None
release_lists = list(itertools.chain(*release_lists))
release_groups = [r['release-group'] for r in release_lists]
# Songs have multiple albums, we want thme in this order.
release_preferences = ['Album', 'Single', 'EAP']
for preference in release_preferences:
release_groups = [
r for r in release_groups if r['primary-type'] == preference
]
if len(release_groups) > 0:
break
# Get the albums
release_groups = [
musicbrainzngs.get_release_group_by_id(r['id'])['release-group']
for r in release_groups
]
dates = [r['first-release-date'] for r in release_groups]
dates = [d for d in dates if d.count('-') > 0]
# We want the earlies album.
initial_date = min(dates)
# Get the earliest album.
release_groups = [
r for r in release_groups
if r['first-release-date'] == initial_date
]
return release_groups[0]
def get_release_group_by_id(id):
"""Get release group with the MusicBrainz ID.
Returns:
Release group object with the following includes: artists, releases,
release-group-rels, url-rels, work-rels.
"""
key = cache.gen_key(id)
release_group = cache.get(key)
if not release_group:
try:
release_group = musicbrainzngs.get_release_group_by_id(
id, ['artists', 'releases', 'release-group-rels', 'url-rels', 'work-rels']
).get('release-group')
except ResponseError as e:
if e.cause.code == 404:
return None
else:
raise InternalServerError(e.cause.msg)
release_group = release_group_rel.process(release_group)
cache.set(key=key, val=release_group, time=DEFAULT_CACHE_EXPIRATION)
return release_group
def album_release_date(release_group_musicbrainz_id) -> 'date':
"""Retrieves the date an album was released. It relies on the first-release-date of release-groups
Arguments:
release_group_musicbrainz_id {str} --
Returns:
Pandas datetime object -- It is the conversion done using pandas.to_datetime of a string formatted as: YYYY-MM-DD.
"""
if release_group_musicbrainz_id is not None:
release_group = musicbrainzngs.get_release_group_by_id(
release_group_musicbrainz_id['value'])['release-group']
try:
date = release_group['first-release-date']
except KeyError:
logging.getLogger('root.features').warning(
f"Release-group {release_group_musicbrainz_id['value']} has not first-release-date attribute"
)
return None
try:
datetime.datetime.strptime(date, '%Y-%m-%d')
except ValueError:
logging.getLogger('root.features').warning(
f"Incorrect first release date format for {release_group_musicbrainz_id['value']}, should be YYYY-MM-DD, but got {date}"
)
return None
try:
date_pandas = pd.to_datetime(date)
except pd.errors.OutOfBoundsDatetime:
logging.getLogger('root.features').warning(
f"Invalid artist_date for {release_group_musicbrainz_id['value']}: {date}. Skipping"
)
return None
return {'value': date_pandas}
def get_discogs_urls(release_id, release_group_id):
discogs_urls = []
try:
release = musicbrainzngs.get_release_by_id(release_id,
includes=['url-rels'])
discogs_urls += [
u['target'] for u in release['release']['url-relation-list']
if u['type'] == 'discogs'
]
except Exception as e:
pass
try:
release_group = musicbrainzngs.get_release_group_by_id(
release_group_id, includes=['url-rels'])
discogs_urls += [
u['target']
for u in release_group['release-group']['url-relation-list']
if u['type'] == 'discogs'
]
except Exception as e:
pass
return discogs_urls
def album_genres(
release_group_musicbrainz_id) -> 'musical_genre_musicbrainz_id':
"""Retrieves the genre associated to the album. In particular, it considers the genres associated with a release-group
Arguments:
album_name {str} --
artist_name {str} --
Returns:
list -- id of the music genres in musicbrainz
"""
if release_group_musicbrainz_id is not None:
release_group = musicbrainzngs.get_release_group_by_id(
release_group_musicbrainz_id['value'],
includes=['tags'])['release-group']
try:
tags = release_group['tag-list']
except KeyError:
logging.getLogger('root.features').warning(
f"Release-group {release_group_musicbrainz_id} has not tags")
return None
genres = []
for tag in tags:
try:
musicbrainz_genre_id = genres_musicbrainz(tag['name'])
genres.append(musicbrainz_genre_id)
except KeyError:
continue
if len(genres) > 0:
return [{'value': g} for g in genres]
else:
logging.getLogger('root.features').warning(
f"No genres associated with release-group {release_group_musicbrainz_id}"
)
return None
def music_brainz_get_release_id_via_release_group(release_group_id: str):
"""get release id from a release_group id
param:
release_group_id (str): release group id from Music Brainz
return:
(str): release id
"""
try:
release_group_info = musicbrainzngs.get_release_group_by_id(
release_group_id, includes=['releases'])
except (HTTPError, ResponseError) as e:
info = f"RELEASE GROUP ID ({release_group_id} ERROR({e}))"
log_missing_info(info)
print(f'a response error occurred for {release_group_id}', e)
return None
try:
release_id = release_group_info['release-group']['release-list'][0][
'id']
except (IndexError, KeyError, TypeError, ValueError) as e:
print(f"couldn't find release id for {release_group_id}", e)
return None
print(release_id)
return release_id
def complete_musicbrainz(self, results):
release_group_ids = []
rgs = []
master_releases = []
# get all release-group-ids
i = 0
for r in results:
if i > 3:
break
i+=1
for release in r['recording']['release-list']:
mb_release = musicbrainzngs.get_release_by_id(id=release['id'], includes=['release-groups'])
release_group_id = mb_release['release']['release-group']['id']
res = {}
res['release_group_id'] = release_group_id
res['recording'] = r
if release_group_id not in release_group_ids:
release_group_ids.append(release_group_id)
if res not in rgs:
rgs.append(res)
#for id in release_group_ids:
for rg in rgs:
id = rg['release_group_id']
r = rg['recording']
result = musicbrainzngs.get_release_group_by_id(id=id, includes=['releases', 'url-rels'])
releases = result['release-group']['release-list']
try:
relations = result['release-group']['url-relation-list']
print
print
print '""""""""""""""""""""""""""""""""""""""""""""""""""'
print relations
print '""""""""""""""""""""""""""""""""""""""""""""""""""'
print
print
except:
relations = None
try:
sorted_releases = sorted(releases, key=lambda k: k['date'])
except Exception, e:
print "SORTING ERROR"
sorted_releases = releases
print e
# sorted_releases.reverse()
first_release = sorted_releases[0]
print 'releases:'
print releases
print 'first release'
print first_release
# look up details for the first release
result = musicbrainzngs.get_release_by_id(id=first_release['id'], includes=['labels', 'url-rels', 'recordings'])
res = {}
res['release'] = result['release']
res['recording'] = r
res['relations'] = relations
master_releases.append(res)
def complete_musicbrainz(self, results):
release_group_ids = []
rgs = []
master_releases = []
# get all release-group-ids
i = 0
for r in results:
if i > 3:
break
i+=1
for release in r['recording']['release-list']:
mb_release = musicbrainzngs.get_release_by_id(id=release['id'], includes=['release-groups'])
release_group_id = mb_release['release']['release-group']['id']
res = {}
res['release_group_id'] = release_group_id
res['recording'] = r
if release_group_id not in release_group_ids:
release_group_ids.append(release_group_id)
if res not in rgs:
rgs.append(res)
#for id in release_group_ids:
for rg in rgs:
id = rg['release_group_id']
r = rg['recording']
result = musicbrainzngs.get_release_group_by_id(id=id, includes=['releases', 'url-rels'])
releases = result['release-group']['release-list']
try:
relations = result['release-group']['url-relation-list']
print
print relations
print
except:
relations = None
try:
sorted_releases = sorted(releases, key=lambda k: k['date'])
except Exception, e:
print "SORTING ERROR"
sorted_releases = releases
print e
# sorted_releases.reverse()
first_release = sorted_releases[0]
print 'releases:'
print releases
print 'first release'
print first_release
# look up details for the first release
result = musicbrainzngs.get_release_by_id(id=first_release['id'], includes=['labels', 'url-rels', 'recordings'])
res = {}
res['release'] = result['release']
res['recording'] = r
res['relations'] = relations
master_releases.append(res)
def get_release_group_title(id):
l = musicbrainzngs.get_release_group_by_id(id)
return l['release-group']['title']
def get_release_group_artist(id):
l = musicbrainzngs.get_release_group_by_id(id, includes=['artists'])
return l['release-group']['artist-credit'][0]['artist']['id']
def album_page(request, MBID):
album_info = {}
data = musicbrainzngs.get_release_group_by_id(
id=MBID, includes=['releases', 'media', 'artists',
'tags'])['release-group']
album_info['date'] = data['first-release-date']
artist = (data['artist-credit'][0]['artist']['id'],
data['artist-credit'][0]['artist']['name'])
data = data['release-list']
album_info['dbpedia_ID'] = None
album_info['artist_name'] = artist[1]
def get_tracklist(data):
tracklist = []
for release in data:
if release.get('date') == album_info['date']:
initial_release = musicbrainzngs.get_release_by_id(
id=release['id'],
includes=['recordings'])['release']['medium-list']
break
#elif release['medium-list'][0]['format'] == 'Digital Media':
#initial_release = musicbrainzngs.get_release_by_id(id=release['id'], includes=['recordings'])['release']['medium-list']
for track in initial_release[0]['track-list']:
tracklist.append(track['recording']['title'])
return tracklist
def get_producers(album):
global dbpedia
global prefixes
labels = []
relationships = ['dbo:producer', 'dbp:producer']
for item in relationships:
dbpedia.setQuery("""
%s
SELECT ?label WHERE {
<%s> %s ?producer.
?producer rdfs:label ?label.
filter langMatches(lang(?label),"en") }
""" % (prefixes, album, item))
dbpedia.setReturnFormat(JSON)
results = dbpedia.query().convert()
for result in results["results"]["bindings"]:
labels.append(result["label"]["value"])
return labels
def get_award(album):
global dbpedia
labels = []
dbpedia.setQuery("""
PREFIX dbp: <http://dbpedia.org/property/>
SELECT ?award WHERE {
<%s> dbp:award ?award.}
""" % (album))
dbpedia.setReturnFormat(JSON)
results = dbpedia.query().convert()
for result in results["results"]["bindings"]:
labels.append(result["award"]["value"])
return labels
def get_bbc_review(MBID):
global bbcmusic
global prefixes
reviews = []
try:
bbcmusic.setQuery("""
%s
SELECT DISTINCT ?r_name, ?rev WHERE {
<http://www.bbc.co.uk/music/artists/%s#artist> foaf:made ?r1 .
?r1 a mo:Record .
?r1 dc:title ?r_name .
?r1 rev:hasReview ?rev }
""" % (prefixes, MBID))
bbcmusic.setReturnFormat(JSON)
results = bbcmusic.query().convert()
for result in results["results"]["bindings"]:
reviews.append(
(result["r_name"]["value"], result["rev"]["value"]))
except EndPointInternalError:
pass
return reviews
album_info['name'] = data[0]['title']
album_info['MBID'] = MBID
IDs = [
"http://dbpedia.org/resource/" + album_info['name'].replace(" ", "_"),
"http://dbpedia.org/resource/" + album_info['name'].replace(" ", "_") +
"_(album)",
"http://dbpedia.org/resource/" + album_info['name'].replace(" ", "_") +
"_(" + artist[1].replace(" ", "_") + "_album)",
"http://dbpedia.org/resource/" + album_info['name'].replace(" ", "_") +
"_(" + artist[1].replace("The ", "").replace(" ", "_") + "_album)"
]
for url in IDs:
if get_description(url[28:]) is not "" and "album" in get_description(
url[28:]):
album_info['dbpedia_ID'] = url
album_info['description'] = get_description(url[28:])
try:
album_info['image'] = musicbrainzngs.get_release_group_image_list(
MBID)['images'][0]['thumbnails']['small']
except (HTTPError, musicbrainzngs.musicbrainz.ResponseError):
pass
album_info['tracklist'] = get_tracklist(data)
if album_info['dbpedia_ID'] is not None:
album_info['producers'] = get_producers(album_info['dbpedia_ID'])
album_info['genres'] = get_dbpedia_genres(album_info['dbpedia_ID'])
album_info['award'] = get_award(album_info['dbpedia_ID'])
for item in get_bbc_review(artist[0]):
if item[0] == data[0]['title']:
album_info['review'] = item[1]
if 'award' in album_info:
for item in album_info['award']:
if item not in BPI_certifications:
album_info['award'].remove(item)
create_RDF(album_info, False)
return render(request, 'home/album.html', {"info": album_info})
def complete_musicbrainz(self, results):
release_group_ids = []
rgs = []
master_releases = []
# get all release-group-ids
i = 0
for r in results:
if i > 3:
break
i += 1
for release in r['recording']['release-list']:
# TODO: refactor to plain API call (requests)
mb_release = musicbrainzngs.get_release_by_id(
id=release['id'], includes=['release-groups'])
release_group_id = mb_release['release']['release-group']['id']
res = {}
res['release_group_id'] = release_group_id
res['recording'] = r
if release_group_id not in release_group_ids:
release_group_ids.append(release_group_id)
if res not in rgs:
rgs.append(res)
#for id in release_group_ids:
for rg in rgs:
id = rg['release_group_id']
r = rg['recording']
# TODO: refactor to plain API call (requests)
result = musicbrainzngs.get_release_group_by_id(
id=id, includes=['releases', 'url-rels'])
releases = result['release-group']['release-list']
try:
relations = result['release-group']['url-relation-list']
except:
relations = None
try:
sorted_releases = sorted(releases, key=lambda k: k['date'])
except Exception as e:
sorted_releases = releases
# sorted_releases.reverse()
first_release = sorted_releases[0]
# look up details for the first release
# TODO: refactor to plain API call (requests)
result = musicbrainzngs.get_release_by_id(
id=first_release['id'],
includes=['labels', 'url-rels', 'recordings'])
res = {}
res['release'] = result['release']
res['recording'] = r
res['relations'] = relations
master_releases.append(res)
master_releases = self.format_master_releases(master_releases)
return master_releases
def query_artist(artist_id):
def check_for_official_album(album_release_list):
for release_list in album_release_list:
if release_list['status'] == 'Official':
return True
return False
artist_query = musicbrainzngs.get_artist_by_id(
artist_id,
includes=['artist-rels', 'release-groups']
)
artist_list = {
"artist_list": [
]
}
artist_object = {
"meta": {
},
"album_list": [
]
}
artist_name = artist_query["artist"]["name"]
# Get members through artist id query
members_of_group = []
if artist_query['artist']['type'] == 'Group':
for member in artist_query['artist']['artist-relation-list']:
if member['type'] == 'member of band':
members_of_group.append(member['artist']['name'])
else:
for member in artist_query['artist']['artist-relation-list']:
if member['type'] == 'is person':
members_of_group.append(member['artist']['name'])
# Get albums through the release group relationship
releases = artist_query['artist']['release-group-list']
album_list = []
for release in releases:
if release['type'] == 'Album':
album_info = musicbrainzngs.get_release_group_by_id(
release['id'],
includes=['releases']
)
album_release_list = album_info['release-group']['release-list']
if check_for_official_album(album_release_list) == True:# and :
album = {
"name": release['title'],
"release_date": release['first-release-date']
}
artist_object["album_list"].append(album)
meta = {
"name": artist_name,
"members": members_of_group
}
artist_object["meta"].update(meta)
artist_list["artist_list"].append(
artist_object
)
artists_file = '%s.json' %(artist_name)
f = open(artists_file, 'w')
f.write(json.dumps(artist_list, indent=4, sort_keys=False))
f.close()
#Coldplay (Will have to get artist id in the first place somehow)
artist_id = "cc197bad-dc9c-440d-a5b5-d52ba2e14234"
artist_query = musicbrainzngs.get_artist_by_id(artist_id,
includes=['artist-rels'])
print("ARTIST: ", artist_query)
#Eminem
single_artist_id = "b95ce3ff-3d05-4e87-9e01-c97b66af13d4"
single_artist_query = musicbrainzngs.get_artist_by_id(single_artist_id,
includes=['artist-rels'])
print("SINGLE ARTIST: ", single_artist_query)
#Can get by browsing for release_groups through artist musicbrainz artist id
release_group_id = "120c786d-a3b2-3c19-b4ff-2b7b3b4435bf"
release_group_query = musicbrainzngs.get_release_group_by_id(release_group_id)
#print("RELEASE GROUP", release_group_query)
artist_list = {"artist_list": []}
artist_object = {"meta": {}, "album_list": []}
artist_name = artist_query["artist"]["name"]
#print("Artist: {artist}".format(artist=artist_query['artist']["name"]))
# Get members through release group query
members = musicbrainzngs.browse_artists(release_group=release_group_id,
includes=["artist-rels"])
#print("MEMBERS: ", members)
members_of_group = []
def fingerprint(fn):
art_til = []
alb = []
count = 0
result = acoustid.match(acoustid_key, fn, parse=False)
album_result = acoustid.match(acoustid_key,
fn,
meta='releasegroups',
parse=False)
print(bcolors.WARNING + f'Select a Title and Artist for {fn}' +
bcolors.ENDC)
try:
for x in result['results']:
for y in x['recordings']:
artlist = [x['name'] for x in y['artists']]
if len(artlist) > 1:
temp_title = y['title'] + (' (feat. ') + ''.join(
p for p in artlist[1:]) + ')'
else:
temp_title = y['title']
art_til.append([artlist[0], temp_title])
for x in art_til:
print(str(count) + '. ' + x[0] + ' - ' + x[1])
count = count + 1
except Exception:
pass
print(str(count) + '. Manual Entry')
while True:
try:
user_choice = int(input('> '))
if user_choice in range(count + 1):
break
else:
continue
except ValueError:
continue
if user_choice == count:
artist = str(input("Enter the exact artist name: "))
title = str(input('Enter the exact title: '))
else:
artist = art_til[user_choice][0]
title = art_til[user_choice][1]
count = 0
print(bcolors.WARNING + f'Select an Album name for {fn}' + bcolors.ENDC)
try:
for x in album_result['results']:
for y in x['releasegroups']:
if 'Music From the Motion Picture' in y['title']:
alb_title = y['title'].split(':')[0] + ' (' + str(
y['title'].split(':')[1]).strip() + ')'
else:
alb_title = y['title']
print(str(count) + '. ' + alb_title + ' - ' + y['type'])
alb.append([alb_title, y['id'], y['type']])
count = count + 1
except Exception:
pass
print(str(count) + '. Manual Entry')
while True:
try:
user_choice = int(input('> '))
if user_choice in range(count + 1):
break
else:
continue
except ValueError:
continue
if user_choice == count:
album = str(input("Enter the exact album name: "))
mbid = None
atype = None
else:
album = alb[user_choice][0]
mbid = alb[user_choice][1]
atype = alb[user_choice][2]
if mbid is not None:
date = musicbrainzngs.get_release_group_by_id(
mbid)['release-group']['first-release-date'][0:5]
else:
date = None
return artist, title, album, mbid, date, atype
object_type = type_lookup[type_id[0]]
if id in mb_cache[object_type]:
print("In cache")
data[object_type][id]=copy.deepcopy(mb_cache[object_type][id])
return data[object_type][id]
print(type_id)
time.sleep(1)
try:
if object_type == 'release-group':
result = musicbrainzngs.get_release_group_by_id(id, includes=['releases','release-rels'])
elif object_type == 'release':
result = musicbrainzngs.get_release_by_id(id, includes=['discids','recordings','artists','instrument-rels'])
elif object_type == 'recording':
result = musicbrainzngs.get_recording_by_id(id, includes=['artists','instrument-rels','work-rels','artist-rels','releases'])
elif object_type == 'work':
result = musicbrainzngs.get_work_by_id(id, includes=['artist-rels','work-rels'])
except musicbrainzngs.ResponseError as err:
if err.cause.code == 404:
sys.exit("Not found")
return None
else:
sys.exit("received bad response {} from the MB server".format(err.cause.code))
return None
def complete_musicbrainz(self, results):
release_group_ids = []
rgs = []
master_releases = []
# get all release-group-ids
i = 0
for r in results:
if i > 3:
break
i+=1
for release in r['recording']['release-list']:
# TODO: refactor to plain API call (requests)
mb_release = musicbrainzngs.get_release_by_id(id=release['id'], includes=['release-groups'])
release_group_id = mb_release['release']['release-group']['id']
res = {}
res['release_group_id'] = release_group_id
res['recording'] = r
if release_group_id not in release_group_ids:
release_group_ids.append(release_group_id)
if res not in rgs:
rgs.append(res)
#for id in release_group_ids:
for rg in rgs:
id = rg['release_group_id']
r = rg['recording']
# TODO: refactor to plain API call (requests)
result = musicbrainzngs.get_release_group_by_id(id=id, includes=['releases', 'url-rels'])
releases = result['release-group']['release-list']
try:
relations = result['release-group']['url-relation-list']
except:
relations = None
try:
sorted_releases = sorted(releases, key=lambda k: k['date'])
except Exception as e:
sorted_releases = releases
# sorted_releases.reverse()
first_release = sorted_releases[0]
# look up details for the first release
# TODO: refactor to plain API call (requests)
result = musicbrainzngs.get_release_by_id(id=first_release['id'], includes=['labels', 'url-rels', 'recordings'])
res = {}
res['release'] = result['release']
res['recording'] = r
res['relations'] = relations
master_releases.append(res)
master_releases = self.format_master_releases(master_releases)
return master_releases
conn = sqlite3.connect("{}/music.db".format(self.path))
c = conn.cursor()
c.execute("SELECT * FROM albums WHERE album_id=?", (album_id, ))
if album := c.fetchone():
return {
"album_id": album[0],
"name": album[1],
"year": album[2],
"artist_id": album[3],
"artist_name": album[4],
"type": "Album"
}
try:
album_info = mbz.get_release_group_by_id(
album_id, includes=["artists"])["release-group"]
except MbzError as e:
print("MusicBrainz Error: {}".format(e), file=sys.stderr)
return None
name = album_info.get("title")
year = album_info.get("first-release-date")
if None in (name, year):
return None
year = int(year.split("-")[0])
artist = album_info.get("artist-credit")
if artist is None:
return None
def __init__(self, artistid):
artist = musicbrainzngs.get_artist_by_id(artistid,
includes=["release-groups"],
release_type=["album"
])["artist"]
self.name = artist["name"]
self.artistid = artistid
releasegroups = artist["release-group-list"]
albums = []
releasegrps = []
for release in releasegroups:
if (release["type"] == "Album"
and all(k not in release.keys()
for k in ["disambiguation", "secondary-type-list"])
and len(release["first-release-date"]) > 4):
releasegrps.append(release)
releasegrps.sort(key=lambda x: x["first-release-date"])
albumids = [release["id"] for release in releasegrps]
if len(albumids) <= 1:
raise ValueError()
for i, albumid in enumerate(albumids):
releases = musicbrainzngs.get_release_group_by_id(
albumid, includes=["releases",
"media"])["release-group"]["release-list"]
releases = [rel for rel in releases if "date" in rel.keys()]
releases.sort(key=lambda x: x["date"])
us = []
for rel in releases:
if (all(k in rel.keys() for k in ["country", "date", "status"])
and rel["status"] == "Official"):
if (rel["country"] in ["US", "GB", "XE", "XW", "AU"]
and rel["title"] == releasegrps[i]["title"]):
us.append(rel)
us.sort(key=lambda x: x["date"])
nalbums = len(albums)
for rel in us:
album = musicbrainzngs.get_release_by_id(
rel["id"], includes=["recordings", "artists"])["release"]
if len(album["artist-credit"]) == 1:
if ("format" in album["medium-list"][0].keys()
and "disambiguation" not in album.keys()
and album["cover-art-archive"]["artwork"] == "true"
and len(album["date"]) > 4):
if album["medium-list"][0]["format"] in [
"Digital Media", "CD"
]:
albums.append(album)
break
if len(albums) == nalbums:
for rel in us:
album = musicbrainzngs.get_release_by_id(
rel["id"], includes=["recordings",
"artists"])["release"]
if len(album["artist-credit"]) == 1:
if "format" in album["medium-list"][0].keys():
if album["medium-list"][0]["format"] in [
"Digital Media",
"CD",
]:
albums.append(album)
break
self.albums = [Album(album, self.name) for album in albums]
#Eminem
single_artist_id = "b95ce3ff-3d05-4e87-9e01-c97b66af13d4"
artist_query = musicbrainzngs.get_artist_by_id(
single_artist_id, includes=['artist-rels', 'release-groups'])
#print("ARTIST: ", artist_query)
#The Marshall Mathers LP (For Testing and Viewing Python Dict)
album_id = "b1fdc9cc-8680-44da-abab-59edca6b2ad3"
album2_id = "1dc4c347-a1db-32aa-b14f-bc9cc507b843"
album3_id = "73ccdc34-3877-4509-9d82-8a6fe9941957" #Whiteboy Wasted
album4_id = "715be5e7-3677-35c0-a39a-abf300ff9ba1" #Infinite
album5_id = "67e94a91-f48e-3e59-9701-38a4dba28d0b" #ReUp
album6_id = "ab7577c4-641d-49ad-ab02-cef742f7dea2" #Collision Course 3
album_query = musicbrainzngs.get_release_group_by_id(
album4_id,
includes=['label-rels', 'ratings', 'releases'] #, 'release-rels']
)
print("ALBUM: ", album_query)
artist_name = artist_query["artist"]["name"]
# Get members through artist id query
members_of_group = []
if artist_query['artist']['type'] == 'Group':
for member in artist_query['artist']['artist-relation-list']:
if member['type'] == 'member of band':
members_of_group.append(member['artist']['name'])
#print("Members of group: ", members_of_group)
else:
for member in artist_query['artist']['artist-relation-list']:
