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']: