def testGetRelease(self): musicbrainzngs.get_release_by_id("5e3524ca-b4a1-4e51-9ba5-63ea2de8f49b") self.assertEqual("http://musicbrainz.org/ws/2/release/5e3524ca-b4a1-4e51-9ba5-63ea2de8f49b", _common.opener.get_url()) # one include musicbrainzngs.get_release_by_id("5e3524ca-b4a1-4e51-9ba5-63ea2de8f49b", includes=["artists"]) self.assertEqual("http://musicbrainz.org/ws/2/release/5e3524ca-b4a1-4e51-9ba5-63ea2de8f49b?inc=artists", _common.opener.get_url())
def getRelease(releaseid, include_artist_info=True): """ Deep release search to get track info """ with mb_lock: release = {} results = None try: if include_artist_info: results = musicbrainzngs.get_release_by_id(releaseid, ["artists", "release-groups", "media", "recordings"]).get('release') else: results = musicbrainzngs.get_release_by_id(releaseid, ["media", "recordings"]).get('release') except musicbrainzngs.WebServiceError as e: logger.warn('Attempt to retrieve information from MusicBrainz for release "%s" failed (%s)' % (releaseid, str(e))) time.sleep(5) if not results: return False release['title'] = unicode(results['title']) release['id'] = unicode(results['id']) release['asin'] = unicode(results['asin']) if 'asin' in results else None release['date'] = unicode(results['date']) if 'date' in results else None try: release['format'] = unicode(results['medium-list'][0]['format']) except: release['format'] = u'Unknown' try: release['country'] = unicode(results['country']) except: release['country'] = u'Unknown' if include_artist_info: if 'release-group' in results: release['rgid'] = unicode(results['release-group']['id']) release['rg_title'] = unicode(results['release-group']['title']) try: release['rg_type'] = unicode(results['release-group']['type']) if release['rg_type'] == 'Album' and 'secondary-type-list' in results['release-group']: secondary_type = unicode(results['release-group']['secondary-type-list'][0]) if secondary_type != release['rg_type']: release['rg_type'] = secondary_type except KeyError: release['rg_type'] = u'Unknown' else: logger.warn("Release " + releaseid + "had no ReleaseGroup associated") release['artist_name'] = unicode(results['artist-credit'][0]['artist']['name']) release['artist_id'] = unicode(results['artist-credit'][0]['artist']['id']) release['tracks'] = getTracksFromRelease(results) return release
def test_set_https(self): musicbrainzngs.set_hostname("mbmirror.org", use_https=True) musicbrainzngs.get_release_by_id( "5e3524ca-b4a1-4e51-9ba5-63ea2de8f49b") self.assertEqual( "https://mbmirror.org/ws/2/release/5e3524ca-b4a1-4e51-9ba5-63ea2de8f49b", self.opener.get_url())
def test_set_port(self): musicbrainzngs.set_hostname("localhost:8000", use_https=False) musicbrainzngs.get_release_by_id( "5e3524ca-b4a1-4e51-9ba5-63ea2de8f49b") self.assertEqual( "http://localhost:8000/ws/2/release/5e3524ca-b4a1-4e51-9ba5-63ea2de8f49b", self.opener.get_url())
def test_set_http(self): musicbrainzngs.set_hostname("beta.musicbrainz.org") musicbrainzngs.get_release_by_id( "5e3524ca-b4a1-4e51-9ba5-63ea2de8f49b") self.assertEqual( "http://beta.musicbrainz.org/ws/2/release/5e3524ca-b4a1-4e51-9ba5-63ea2de8f49b", self.opener.get_url())
def make_query(self, params): if params["type"] == "artist": return musicbrainzngs.get_artist_by_id(params["mbid"]) elif params["type"] == "album": return musicbrainzngs.get_release_by_id(params["mbid"]) elif params["type"] == "tracklist": return musicbrainzngs.get_release_by_id(params["mbid"], includes=["recordings"])["release"]["medium-list"][0]["track-list"] elif params["type"] == "track": return musicbrainzngs.get_recording_by_id(params["mbid"], includes=["artists"])
def testGetRelease(self): musicbrainzngs.get_release_by_id( "5e3524ca-b4a1-4e51-9ba5-63ea2de8f49b") self.assertEqual( "http://musicbrainz.org/ws/2/release/5e3524ca-b4a1-4e51-9ba5-63ea2de8f49b", _common.opener.get_url()) # one include musicbrainzngs.get_release_by_id( "5e3524ca-b4a1-4e51-9ba5-63ea2de8f49b", includes=["artists"]) self.assertEqual( "http://musicbrainz.org/ws/2/release/5e3524ca-b4a1-4e51-9ba5-63ea2de8f49b?inc=artists", _common.opener.get_url())
def get_musicbrainz_release(record_id): track_count = 0 album_length = 0 medium_types_arr = [] try: release = musicbrainzngs.get_release_by_id(record_id, includes=[ 'recordings', ]) release = release['release'] except: release = musicbrainzngs.get_release_by_id(record_id) for recording in release['medium-list']: try: medium_types_arr.append(recording['format']) except KeyError: pass track_count += int(recording['track-count']) for track in recording['track-list']: try: album_length += int(track['track_or_recording_length']) except: album_length += 0 try: date = release['date'] except KeyError: date = 'unknown' try: country = release['country'] except KeyError: country = 'unknown' medium_types = ",".join(medium_types_arr) album_length = album_length / 1000 release_dict = { 'date': date, 'id': release['id'], 'medium_count': release['medium-count'], 'medium_type': medium_types, 'country': country, 'track_count': track_count, 'album_length': album_length } return release_dict
def release_by_id(self, mbid, cuesheet=None): """Return a release by MusicBrainz ID, or None. If cuesheet is present, return only the medium with a disc ID or TOC match. Includes track information. """ release = None try: response = mb_client.get_release_by_id(mbid, includes=[ 'artist-credits', 'discids', 'recordings', 'release-groups', ]) release = response['release'] except mb_client.ResponseError as e: if isinstance(e.cause, HTTPError) and e.cause.code == 404: pass # no matches else: raise MusicBrainzError from e if release is not None: if cuesheet is not None: disc = MusicBrainzDisc(cuesheet) else: disc = None return _parse_release(release, disc) else: return None
def fetch_release(release_id, refresh=False): if not os.path.isfile("{0}.data".format(release_id[0])) or refresh: logger.debug("Hard refreshing data for {0}".format(release_id[0])) try: release = musicbrainzngs.get_release_by_id( release_id[0], includes=["artists", "labels"])['release'] except musicbrainzngs.WebServiceError as exc: logger.error("Error fetching data for {0}".format(release_id[0])) logger.error(exc) logger.info('Shutting down') return False try: with open("{0}.data".format(release_id[0]), "w") as out_file: artist = release["artist-credit"][0]["artist"] try: label = release["label-info-list"][0]["label"]["name"] catno = release["label-info-list"][0]["catalog-number"] except IndexError: label = '' catno = '' out_file.writelines('\n'.join([ artist["name"], release["title"], release["date"], label, catno, release_id[1], release_id[2] ])) except EnvironmentError: logger.error('Cannot write data for {0} to file'.format( release_id[0])) logger.info('Shutting down') return False else: logger.debug("Using pre-fetched data for {0}".format(release_id[0])) return True
def get_release_info(album_title): """Return release info given an id.""" release_id = __search_for_release(album_title) release_info = musicbrainzngs.get_release_by_id( id=release_id, includes=['tags', 'recordings']) return release_info
def clickevt_album(evt): window_name = mainwin['artistslist'].get_selected_items()[0]["artist"] + " - " + mainwin['albumslist'].get_selected_items()[0]["albums"]; with gui.Window(name='downwin', title=u'' + window_name, height=down_win_height, width=down_win_width, left='323', top='137', bgcolor=u'#F0F0F0', fgcolor=u'#555555', ): gui.TextBox(name='downloadpath', value=pref.download_dir, height=form_height, left='5', top='0', width=down_input_width, parent='downwin', ) gui.Button(label=u'Download all!', name='btn_down_all', height='35px', width=down_btn_width, left=down_input_width, top='5', default=True, fgcolor=u'#EEEEEE', bgcolor=u'#C0392B', parent='downwin', ) gui.Button(label=u'Download selected!', name='button_down', height='35px', width=down_btn_width, left=down_btn_left, top='5', default=True, fgcolor=u'#EEEEEE', bgcolor=u'#C0392B', parent='downwin', ) with gui.ListView(name='downloadlist', height=down_lv_songs_height, width=down_win_width, left='0', top=form_height, item_count=10, sort_column=0, onitemselected="print ('sel %s' % event.target.get_selected_items())", ): gui.ListColumn(name='trackposition', text='Nr.', width=50) gui.ListColumn(name='tracks', text='Tracks', width=300) gui.ListColumn(name='tracksfound', text='Tracks found', width=150) gui.ListColumn(name='id', text='', width=0) gui.Gauge(name='progressbar', height=down_gauge_height, left=0, top=down_gauge_top, width=down_win_width, value=0, ) downwin = gui.get("downwin") downwin['btn_down_all'].onclick = download_all_songs plr = pleer.Pleer() # print(pleer.Pleer()) tracksList = [] (oldtracks_position, oldtracks_json) = mainwin["trackslist"].items()[0] tracks = m.get_release_by_id(oldtracks_json["id"], includes=["artists", "recordings"]) print(tracks) for idx, track in enumerate(tracks["release"]["medium-list"][0]["track-list"]): print(idx) tracksList.append(plr.search(mainwin['artistslist'].get_selected_items()[0]["artist"] + " " + track["recording"]["title"], track)) lv = downwin["downloadlist"] lv.items = tracksList
def music_brainz_get_release_tracklist(release_id: str): """get release group info by it id :param release_group_id (str): release group id from Music Brainz :return: (list) a list of tracks (track titles) for the current release (album) """ try: release_info = musicbrainzngs.get_release_by_id( release_id, includes=['media', 'recordings']) except (HTTPError, ResponseError) as e: print(f'a response error occurred for {release_id}', e) return None if not release_info: print(f'no release info returned for {release_id}') return None try: tracklist = [] for album_cd in release_info['release']['medium-list']: tracklist += album_cd['track-list'] except (IndexError, TypeError, KeyError, ValueError) as e: print(e, f'could not find tracklist for {release_id}') return None tracklist = [track_info['recording']['title'] for track_info in tracklist] return tracklist
def find_release(release_title, artist=None): release_group = find_release_group(release_title, artist=artist) results = musicbrainzngs.search_releases( 'rgid:' + release_group['id'])['release-list'] table_data = [ ('Index', 'Title', '# Tracks', 'Date', 'CC', 'Label', 'Status', 'Format'), ] for i, r in enumerate(results): try: label = r['label-info-list'][0]['label']['name'] except KeyError: label = '?' table_data.append((i, r['title'], r['medium-list'][0]['track-count'], r.get('date', '?'), r.get('country', '?'), label, r.get('status', '?'), r['medium-list'][0].get('format', '?'))) print(terminaltables.SingleTable(table_data).table) while True: choice = input("Select the exact release, if known (Enter to skip): ") try: choice = results[int(choice)] except (IndexError, ValueError): if choice == '': return None, release_group else: release = musicbrainzngs.get_release_by_id( choice['id'], includes=['release-groups', 'media', 'recordings', 'url-rels'])['release'] return release, release_group
def gather(artist, title): result = musicbrainzngs.search_releases(artist=artist, release=title) for item in result['release-list']: print artist, title print json.dumps(item, sort_keys=True, indent=4, separators=(',', ': ')) if (re.search(artist, item['artist-credit'][0]['artist']['name'], flags=re.IGNORECASE) and re.search( artist, item['artist-credit-phrase'], flags=re.IGNORECASE) and re.search(title, item['title'], flags=re.IGNORECASE) and re.search('Album', item['release-group']['primary-type'])): #if (item['artist-credit'][0]['artist']['name'] == artist and item['title'] == title): actual.append(item['id']) print actual[0] foo = musicbrainzngs.get_release_by_id( actual[0], includes=['recordings', 'release-groups']) #elif (item['title'] == title): # actual = item['id'] # foo = musicbrainzngs.get_release_by_id(actual,includes=['recordings','release-groups']) #print "Positions: ",foo['release']['medium-list'][0]['track-list'][-1]['position'], "Tracks: ",foo['release']['medium-list'][0]['track-list'][-1]['number'] return foo['release']['medium-list'][0]['track-list'][-1]['number']
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 match_tracks_to_release(title, tracks, mbid, name): ''' Given a list of tracks, a candidate release mbid and name this function should return a score (0.0-1.0) of how well this list of tracks compares to the MB release. ''' try: musicbrainzngs.set_useragent(config.USER_AGENT_STRING, config.USER_AGENT_VERSION, config.USER_AGENT_USER) rel = musicbrainzngs.get_release_by_id(mbid, includes=['recordings']) except musicbrainzngs.WebServiceError as exc: print "Something went wrong with the request: %s" % exc return -1 # print "--- %-40s %s" % (title.encode('utf-8'), name.encode('utf-8')) matches = [] total = 0.0 print for i, t in enumerate(rel["release"]["medium-list"][0]["track-list"]): try: d = Levenshtein.ratio(clean_string(t['recording']['title']), tracks[i]['clean']) print "%.3f %2d %-40s | %s" % ( d, i + 1, clean_string( t['recording']['title']), tracks[i]['clean']) total += d except IndexError: return -1 return total / len(tracks)
def strip_result(id,make_key,disc_index): try: result = musicbrainzngs.get_releases_by_discid(id,includes=["labels","recordings","artist-credits"]) root=result['disc']['release-list'][0] discid=result['disc']['id'] except musicbrainzngs.ResponseError: result = musicbrainzngs.get_release_by_id(id,includes=["labels","recordings","artist-credits"]) root=result['release'] discid=None disc_count=root['medium-count'] track_list=root['medium-list'][disc_index]['track-list'] track_count=root['medium-list'][disc_index]['track-count'] disc_title=root['title'] release=root['id'] out=[] for track in track_list: title=track['recording']['title'] item=dict(artists=track['artist-credit-phrase'], num=track['number'], title=title, key=make_key(track=track)) out.append(item) out_dict=dict(title=disc_title,track_count=track_count,path=the_album,track_list=out,discid=discid, disc_count=disc_count,release=release) return out_dict
def get_release(mbid): try: rel = musicbrainzngs.get_release_by_id(mbid, includes=["release-groups"]) return rel["release"] except musicbrainzngs.ResponseError: return {}
def getReleaseMetadata(release_id, discid=None, country=None, record=False): """ Return a DiscMetadata object based on MusicBrainz Release ID and Disc ID. If the disc id is not specified, it will match with any disc that is on the release disc-list. Otherwise only returns metadata of one disc in release disc-list. :param release_id: MusicBrainz Release ID :type release_id: str :param discid: MusicBrainz Disc ID :type discid: str or None :param country: the country the release was issued in :type country: str or None :param record: whether to record to disc as a JSON serialization :type record: bool :returns: a DiscMetadata object based on MusicBrainz Release ID & Disc ID :rtype: `DiscMetadata` """ # to get titles of recordings, we need to query the release with # artist-credits res = musicbrainzngs.get_release_by_id( release_id, includes=[ "artists", "artist-credits", "recordings", "discids", "labels", "recording-level-rels", "work-rels", "release-groups", "work-level-rels", "artist-rels" ]) _record(record, 'release', release_id, res) releaseDetail = res['release'] formatted = json.dumps(releaseDetail, sort_keys=False, indent=4) logger.debug('release %s', formatted) return _getMetadata(releaseDetail, discid, country)
def get_recordings_from_release(release): rel = mb.get_release_by_id(release, includes=["recordings"])["release"] recordings = [] for m in rel.get("medium-list", []): for t in m.get("track-list", []): recordings.append(t["recording"]["id"]) return recordings
def get_taggable_information(album_ids): """Find the songs, release year, and coverartarchive.org URL of an album by its ID. """ album_dict = musicbrainzngs.get_release_by_id(id=album_ids[0], includes="recordings") image_dict = musicbrainzngs.get_image_list(album_ids[1]) taggable_information = {} taggable_information["year"] = re.sub(r"([0-9]{4})(-[0-9]{2}){2}", r"\1", album_dict["release"]["date"]) discs = album_dict["release"]["medium-list"] taggable_information["tracks"] = [] for disc in sorted(discs, key=lambda disc: int(disc["position"])): for song in sorted(disc["track-list"], key=lambda song: int(song["position"])): if "title" in song: title = song["title"] else: title = song["recording"]["title"] taggable_information["tracks"].append(custom_replace_title(title)) for image in image_dict["images"]: if "Front" in image["types"]: taggable_information["image_url"] = image["image"] return taggable_information
def match_tracks_to_release(title, tracks, mbid, name): ''' Given a list of tracks, a candidate release mbid and name this function should return a score (0.0-1.0) of how well this list of tracks compares to the MB release. ''' try: musicbrainzngs.set_useragent(config.USER_AGENT_STRING, config.USER_AGENT_VERSION, config.USER_AGENT_USER) rel = musicbrainzngs.get_release_by_id(mbid, includes=['recordings']) except musicbrainzngs.WebServiceError as exc: print "Something went wrong with the request: %s" % exc return -1 # print "--- %-40s %s" % (title.encode('utf-8'), name.encode('utf-8')) matches = [] total = 0.0 print for i, t in enumerate(rel["release"]["medium-list"][0]["track-list"]): try: d = Levenshtein.ratio(clean_string(t['recording']['title']), tracks[i]['clean']) print "%.3f %2d %-40s | %s" % (d, i+1, clean_string(t['recording']['title']), tracks[i]['clean']) total += d except IndexError: return -1 return total / len(tracks)
def music_brainz_get_release_tracklist_b_sides(release_id: str): """extra function: GET ONLY B-SIDES, CD2, etc, skipping CD1 in medium-list :param release_group_id (str): release group id from Music Brainz :return: (list) a list of tracks (track titles) for the current release (album) """ try: release_info = musicbrainzngs.get_release_by_id( release_id, includes=['media', 'recordings']) except (HTTPError, ResponseError) as e: print(f'a response error occurred for {release_id}', e) return None if not release_info: print(f'no release info returned for {release_id}') return None try: tracklist = [] if len(release_info['release']['medium-list']) > 1: for album_cd in release_info['release']['medium-list'][1:]: tracklist += album_cd['track-list'] else: print("ONLY 1 CD FOUND") return None except (IndexError, TypeError, KeyError, ValueError) as e: print(e, f'could not find tracklist for {release_id}') return None tracklist = [track_info['recording']['title'] for track_info in tracklist] return tracklist
def get_release_by_id(self, release_id, includes=[]): try: return musicbrainzngs.get_release_by_id(release_id, includes=includes) except WebServiceError as err: print_error("Couldn't fetch release: %s" % err) sys.exit(1)
def main(collectionid): # work -> list recordings mapping = collections.defaultdict(list) # map from an id to a name recordingnames = {} worknames = {} for i, releaseid in enumerate(compmusic.musicbrainz.get_releases_in_collection(collectionid)): print i, releaseid try: rel = mb.get_release_by_id(releaseid, includes=["recordings"]) except: continue rel = rel["release"] for medium in rel.get("medium-list", []): for track in medium.get("track-list", []): recid = track["recording"]["id"] recordingnames[recid] = track["recording"]["title"] recording = mb.get_recording_by_id(recid, includes=["work-rels"]) recording = recording["recording"] for work in recording.get("work-relation-list", []): workid = work["work"]["id"] worknames[workid] = work["work"]["title"] mapping[workid].append(recid) data = [] for k, v in mapping.items(): data.append((k, v)) data = sorted(data, key=lambda x: len(x[1]), reverse=True) all_d = {"recordingnames": recordingnames, "worknames": worknames, "data": data } json.dump(all_d, open("works_by_recording.json", "w"))
def Fetch( self, options ): if not self.valid: return self.fetch_attempts += 1 # Get the song metadata from MB Web Service - invalid release if this fails try: self.data = ws.get_release_by_id( self.id, ["artist-credits", "recordings", "labels", "release-groups", "media"] )["release"] except ws.musicbrainz.ResponseError: utils.safeprint ( u"Connection Error!" ) self.data = None return except ws.musicbrainz.NetworkError: utils.safeprint ( u"Connection Error!" ) self.data = None return self.__ProcessData( options ) # Get cover art for release - no CA if this fails try: cover = urllib2.urlopen( "http://coverartarchive.org/release/" + self.id + "/front-500", None, 10 ) except urllib2.HTTPError: utils.safeprint( u"No cover art in CAA for \"{}\".".format( self.processed_data["album"] ) ) self.art = None except ( urllib2.URLError, socket.timeout ): utils.safeprint( u"Connection Error!" ) self.art = None else: self.art = self.__PackageCoverArt( cover.read() ) # Successfully retrieved data self.fetched = True return self.id
def get_release_group_by_release_id(release_id): with musicbrainz_lock: results = musicbrainzngs.get_release_by_id(release_id, includes='release-groups') if results: return results['release']['release-group']['id'] return None
def get_mb_data(id): id, disc_id = re.search('^(?:http://.+/)?(.+?)(?:#disc(\d+))?$', id).groups() try: release = m.get_release_by_id(id, ['artists','recordings','artist-credits'])['release'] except m.MusicBrainzError, exceptions.e: print 'Error:', exceptions.e sys.exit(1)
def music_get_album(album_id: str, locale: str): album = musicbrainzngs.get_release_by_id( album_id, includes=["artists", "recordings"])["release"] album_name: str = album["title"] artist = album["artist-credit"][0]["artist"] artist_id: str = artist["id"] artist_name: str = artist["name"] tracks = album["medium-list"][0]["track-list"] doc: Document = minidom.Document() feed: Element = create_feed(doc, album_name, album_id, request.endpoint) if bool(album["cover-art-archive"]["front"]): # Add front cover image_elem: Element = doc.createElement("image") image_id_elem: Element = create_id(doc, album_id) image_elem.appendChild(image_id_elem) feed.appendChild(image_elem) for track in tracks: recording = track["recording"] track_id: str = recording["id"] track_title: str = recording["title"] entry: Element = create_entry(doc, track_title, track_id, f"/v3.2/{locale}/") # Create primaryArtist element primary_artist_elem: Element = doc.createElement("primaryArtist") artist_id_element: Element = doc.createElement("id") set_element_value(artist_id_element, artist_id) primary_artist_elem.appendChild(artist_id_element) artist_name_element: Element = doc.createElement("name") set_element_value(artist_name_element, artist_name) primary_artist_elem.appendChild(artist_name_element) entry.appendChild(primary_artist_elem) try: length_ms: str = track["track_or_recording_length"] # FIXME: Add duration element length_elem: Element = doc.createElement("duration") set_element_value(length_elem, length_ms) except: pass try: track_position: str = track["position"] # FIXME: Add index element index_elem: Element = doc.createElement("index") set_element_value(index_elem, track_position) except: pass feed.appendChild(entry) # doc.appendChild(feed) xml_str = doc.toprettyxml(indent="\t") return Response(xml_str, mimetype=MIME_XML)
def album_for_id(albumid): """Fetches an album by its MusicBrainz ID and returns an AlbumInfo object or None if the album is not found. """ try: res = musicbrainzngs.get_release_by_id(albumid, RELEASE_INCLUDES) except musicbrainzngs.ResponseError: log.debug('Album ID match failed.') return None return album_info(res['release'])
def _get_release(release_id): """Returns a release containing all recordings and artists or raises MusicBrainzError """ assert is_mbid(release_id) return musicbrainzngs.get_release_by_id( release_id, includes=["recordings", "artists", "artist-credits"])["release"]
def getReleaseFromMB(releaseId): """Retrieves release info from MusicBrainz by releaseId.""" if not _initialised: _initialise() release = m.get_release_by_id( releaseId, includes=["recordings", "artists", "artist-credits", "artist-rels"] ) return release
def stats_for_release(self, releaseid): self.releases.add(releaseid) rel = mb.get_release_by_id(releaseid, includes=["recordings", "artist-rels"]) rel = rel["release"] for disc in rel["medium-list"]: for track in disc["track-list"]: recording = track["recording"]["id"] self.stats_for_recording(recording) for relation in rel.get("artist-relation-list", []): artist = relation.get("artist", {}).get("id") if artist: self.artists.add(artist)
def get_release_by_id(release_id): attempt = 0; # Set attempt number for album art while attempt < maxAttempt: try: result = MB.get_release_by_id( release_id )['release']; # Get information about the relase except: attempt+=1; # Increment the attempt counter by one time.sleep(2); # Sleep 10 seconds else: break; if attempt == maxAttempt: return None; # If MusicBrainz search fails three times, return 2 return result;
def tracks(self): if not self._tracks: data = brainz.get_release_by_id(self.id, includes='recordings')['release'] assert(self.name == data['title']) tracks = [] for i in data['medium-list']: tracks += i['track-list'] self._tracks = [BrainzSong(i) for i in tracks] for track in self._tracks: track.artist = self.artist track.album = self.name return self._tracks
def release_info(self, release_list): ##Need to clean up data list to include only necessary data data = [ 'artists', 'labels', 'recordings', 'release-groups', 'media', 'artist-credits', 'discids', 'isrcs', 'recording-level-rels', 'work-level-rels', 'annotation', 'aliases', 'area-rels', 'artist-rels', 'label-rels', 'place-rels', 'recording-rels', 'release-rels', 'release-group-rels', 'url-rels', 'work-rels' ] # data = ['artists', 'labels', 'recordings', 'media', 'release-groups', 'release-rels', 'artist-rels'] image = False formats = '' release_date = '' labels = '' release_display_list = [] ######## #Shortening Release list because long release lists cause timeout ####### release_list = release_list[0:5] for release in release_list: album_data = mbz.get_release_by_id(release, includes=data) labels = [ label['label']['name'] for label in album_data['release']['label-info-list'] ] try: formats = [ medium['format'] for medium in album_data['release']['medium-list'] ] except KeyError: pass tracks = album_data['release']['medium-list'][0]['track-list'] if album_data['release']['cover-art-archive']['artwork'] == 'true': r = requests.get('{0}/release/{1}'.format(caa, release)).json() image = r['images'][0]['image'] try: release_date = datetime.datetime.strptime( album_data['release']['release-group'] ['first-release-date'], '%Y-%m-%d').strftime("%B %d, %Y") except ValueError: release_date = album_data['release']['release-group'][ 'first-release-date'] release_display_list.append({ 'image': image, 'tracks': tracks, 'labels': labels, 'formats': formats, 'release_date': release_date, 'title': album_data['release']['title'] }) return release_display_list
def lookup_info(release): info = musicbrainzngs.get_release_by_id( str(release), includes=['artists', 'artist-credits'])['release'] title = info.get('title') year = int(info['date'][:4]) if 'date' in info else None artists = [] for a in info['artist-credit']: if isinstance(a, dict) and 'name' in a['artist']: artists.append(a['artist']['name']) else: print(a) return title, year, artists
def getAlbumYearFromMusicBrainz(albumMbid): global datesAfterYear musicbrainzngs.set_useragent("BARRISS_BillboardChartAnalyzer","1","*****@*****.**") album = musicbrainzngs.get_release_by_id(albumMbid) if 'release' in album and 'date' in album['release']: albumYear = album['release']['date'][0:4] if int(albumYear) > year: datesAfterYear += 1 return albumYear else: return 0
def complete_musicbrainz__(self, results): completed_results = [] i = 0 for r in results: if i > 3: #pass break i+=1 print print 'RESULT' releases = [] recording = r['recording'] for release in recording['release-list']: #print release['id'] release = musicbrainzngs.get_release_by_id(id=release['id'], includes=['url-rels', 'release-groups']) #print 'RELEASE!:::::::::::::::::::::::::::::::::::::::::::::::::' #print release relations = [] try: for relation in release['release']['url-relation-list']: #print "Relation: target: %s - url: %s" % (relation['type'], relation['target']) relations.append(relation) except Exception, e: #print e pass release['relations'] = relations releases.append(release) # order releases by date releases = self.mb_order_by_releasedate(releases) r['release-list'] = releases completed_results.append(r)
def fetch_album_from_id(id): """Retrieves an album (aka release) from MusicBrainz, and parses the MusicBrainz data to return a dict of relevant information.""" try: release = musicbrainzngs.get_release_by_id( id, includes=['artists', 'media', 'recordings', 'release-groups', 'labels', 'artist-credits', 'aliases']) release = release["release"] except musicbrainzngs.MusicBrainzError: raise # These tags aren't hidden behind layers of data structures, # and can be fetched without doing copious error checking info = { "album" : release.get("title"), "albumartist_credit" : \ release.get("artist-credit-phrase"), "album_id" : release.get("id"), "country" : release.get("country"), "date" : release.get("date"), "status" : release.get("status"), "totaldiscs" : release.get("medium-count") } # But these all are try: artist_info = release["artist-credit"][0]["artist"] except KeyError: artist_info = {} info["albumartist"] = artist_info.get("name") info["albumartist_id"] = artist_info.get("id") info["albumartist_sort"] = artist_info.get("sort-name") try: info["label"] = release["label-info-list"][0]["label"]["name"] except KeyError: info["label"] = None try: media = release["medium-list"][0]["format"] except KeyError: media = None releasegroup_info = release.get("release-group", {}) info["releasegroup_id"] = releasegroup_info.get("id") info["originaldate"] = releasegroup_info.get("first-release-date") text_info = release.get("text-representation", {}) info["language"] = text_info.get("language") info["script"] = text_info.get("script") # Produce information about discs and tracks medium_list = release.get("medium-list") info["contents"] = sort_album_contents(medium_list) return info
def album_for_id(albumid): """Fetches an album by its MusicBrainz ID and returns an AlbumInfo object or None if the album is not found. May raise a MusicBrainzAPIError. """ try: res = musicbrainzngs.get_release_by_id(albumid, RELEASE_INCLUDES) except musicbrainzngs.ResponseError: log.debug("Album ID match failed.") return None except musicbrainzngs.MusicBrainzError as exc: raise MusicBrainzAPIError(exc, "get release by ID", albumid, traceback.format_exc()) return album_info(res["release"])
def get_performance_credit_for_recording(self, recordingid): recording = mb.get_recording_by_id(recordingid, includes=["releases"]) recording = recording["recording"] ret = [] for release in recording.get("release-list", []): relid = release["id"] mbrelease = mb.get_release_by_id(relid, includes=["artist-credits", "recordings"]) mbrelease = mbrelease["release"] for medium in mbrelease.get("medium-list", []): for track in medium.get("track-list", []): if track["recording"]["id"] == recordingid: ret.append(track["recording"]["artist-credit-phrase"]) return list(set(ret))
def complete_musicbrainz__(self, results): completed_results = [] i = 0 for r in results: if i > 3: #pass break i += 1 print print 'RESULT' releases = [] recording = r['recording'] for release in recording['release-list']: #print release['id'] release = musicbrainzngs.get_release_by_id( id=release['id'], includes=['url-rels', 'release-groups']) #print 'RELEASE!:::::::::::::::::::::::::::::::::::::::::::::::::' #print release relations = [] try: for relation in release['release']['url-relation-list']: #print "Relation: target: %s - url: %s" % (relation['type'], relation['target']) relations.append(relation) except Exception, e: #print e pass release['relations'] = relations releases.append(release) # order releases by date releases = self.mb_order_by_releasedate(releases) r['release-list'] = releases completed_results.append(r)
def get_performance_credit_for_recording(self, recordingid): recording = mb.get_recording_by_id(recordingid, includes=["releases"]) recording = recording["recording"] ret = [] for release in recording.get("release-list", []): relid = release["id"] mbrelease = mb.get_release_by_id( relid, includes=["artist-credits", "recordings"]) mbrelease = mbrelease["release"] for medium in mbrelease.get("medium-list", []): for track in medium.get("track-list", []): if track["recording"]["id"] == recordingid: ret.append(track["recording"]["artist-credit-phrase"]) return list(set(ret))
def mb_shit(self, mb_id): self.mb = mb_id import musicbrainzngs musicbrainzngs.set_useragent('a','.1','foo') r = musicbrainzngs.get_release_by_id(self.mb, includes=["artists", "recordings"])['release'] d = {} all_tracklist = [] for disc in r['medium-list']: all_tracklist += disc['track-list'] d['trackCount'], d['artistName'], d['releaseDate'], d['primaryGenreName'], d['collectionPrice'] = len(all_tracklist), r['artist-credit'][0]['artist']['name'], str(r['date'])[0:4] + '-01-01T00:00:00Z', 'MB', None d['trackDetails'] = [{'trackTimeMillis': int(rec['recording']['length'])} for rec in all_tracklist] self.mb_details = d self.title = r['title'] self.details = [{'artistName': d['artistName'], 'releaseDate': d['releaseDate']}]
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 getSongs(whatGroup): mbAlbum = mb.search_releases( artistname=mbquote(whatGroup['artist']), release= mbquote(whatGroup['groupName']), limit=1)['release-list'] return [ (x['recording']['title'], int(float( x['recording']['length'] if 'length' in x['recording'] else (x['track_or_recording_length'] if 'track_or_recording_length' in x else x['length'] if 'length' in x else 0) )/1000.)) for tracklist in mb.get_release_by_id( mbAlbum[0]['id'], includes=['recordings'])['release']['medium-list'] for x in tracklist['track-list']]
def testGetRelease(self): musicbrainzngs.get_release_by_id("5e3524ca-b4a1-4e51-9ba5-63ea2de8f49b") self.assertEqual("http://musicbrainz.org/ws/2/release/5e3524ca-b4a1-4e51-9ba5-63ea2de8f49b", self.opener.get_url()) # one include musicbrainzngs.get_release_by_id("5e3524ca-b4a1-4e51-9ba5-63ea2de8f49b", includes=["artists"]) self.assertEqual("http://musicbrainz.org/ws/2/release/5e3524ca-b4a1-4e51-9ba5-63ea2de8f49b?inc=artists", self.opener.get_url()) # more than one include musicbrainzngs.get_release_by_id("5e3524ca-b4a1-4e51-9ba5-63ea2de8f49b", includes=["artists", "recordings", "artist-credits"]) expected = "http://musicbrainz.org/ws/2/release/5e3524ca-b4a1-4e51-9ba5-63ea2de8f49b?inc=artists+recordings+artist-credits" self.assertEqual(expected, self.opener.get_url())
def get(self, mb_id): # Lookup the artist and album name from the musicbrainz ID infoDict = musicbrainzngs.get_release_by_id(mb_id, ['artists']) # The main dictionary is for the whole release releaseDict = infoDict.get('release', None) albumName = "" artist = "" # If this dictionary doesn't exist, we won't have anything to show if releaseDict == None: self.redirect("/") # Pull out the album name albumName = releaseDict.get('title', 'Unknown') # Now get the list of artists artistsDicts = releaseDict.get('artist-credit', None) if artistsDicts != None: # There can be a list of artists, so look for each one artists = [] for artistDict in artistsDicts: if artistDict == None: continue # Get this specific artist's info artistInfo = artistDict.get('artist') if artistInfo != None: # Append on the artist's name artists.append(artistInfo.get('name', '')) # Join all the artists together artist = ", ".join(artists) # Look up all the reviews with for that particular album by that particular artist reviews = Review.get_review_by_album_artist(albumName, artist) if reviews != None: self.render("albumPage.html", reviews=reviews, album=albumName, artist=artist, user=self.user, mb_id=mb_id) else: self.redirect("/")
def get_release_by_id(id): """Get release with the MusicBrainz ID. Returns: Release object with the following includes: recordings, media. """ key = cache.gen_key(id) release = cache.get(key) if not release: try: release = musicbrainzngs.get_release_by_id(id, ['recordings', 'media', 'release-groups']).get('release') except ResponseError as e: if e.cause.code == 404: return None else: raise InternalServerError(e.cause.msg) cache.set(key=key, val=release, time=DEFAULT_CACHE_EXPIRATION) return release
def _match_releases(self, result_list): """ determines which releases the items have in common. also uses number of tracks to make sure its the same release :returns release_id or None """ result_ids = chain.from_iterable([result.release_id for result in result_list if result]) top_matches = Counter(result_ids).most_common(self.MAX_RELEASES) actual_number_of_tracks = len(result_list) for release_id, _ in top_matches: r = musicbrainzngs.get_release_by_id(release_id, includes='recordings') mediums = r['release']['medium-list'] tracks = sum([medium['track-count'] for medium in mediums]) if tracks == actual_number_of_tracks: return release_id return None
def album_for_id(releaseid): """Fetches an album by its MusicBrainz ID and returns an AlbumInfo object or None if the album is not found. May raise a MusicBrainzAPIError. """ albumid = _parse_id(releaseid) if not albumid: log.debug(u'Invalid MBID ({0}).', releaseid) return try: res = musicbrainzngs.get_release_by_id(albumid, RELEASE_INCLUDES) except musicbrainzngs.ResponseError: log.debug(u'Album ID match failed.') return None except musicbrainzngs.MusicBrainzError as exc: raise MusicBrainzAPIError(exc, u'get release by ID', albumid, traceback.format_exc()) return album_info(res['release'])
def complete_release_meta(self, r, it): includes = [ "artists", "labels", "recordings", "release-groups", "media", "artist-credits", "discids", "puids", "isrcs", "artist-rels", "label-rels", "recording-rels", "release-rels", "release-group-rels", "url-rels", "work-rels", "recording-level-rels", "work-level-rels" ] mb_release = musicbrainzngs.get_release_by_id( id=it['mb_release_id'], includes=includes) mbr = mb_release['release'] print '***************************************' if 'status' in mbr: print mbr['status'] if 'title' in mbr: print mbr['title'] if 'url-relation-list' in mbr: # print mbr['url-relation-list'] for rel in mbr['url-relation-list']: print rel if rel['type'] == 'discogs': print 'DISCOGS: %s' % rel['target'] try: # pass rel = Relation(content_object=r, url=rel['target']) rel.save() except Exception, e: print 'RELATION EXCEPTION' print e try: discogs_image = discogs_image_by_url(rel['target']) img = filer_extra.url_to_file(discogs_image, r.folder) r.main_image = img except: pass
def get_release_by_id(self, id, includes=[]): """Get release with the MusicBrainz ID. Available includes: artists, labels, recordings, release-groups, media, artist-credits, discids, isrcs, recording-level-rels, work-level-rels, annotation, aliases, 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', source='api', params=includes) release = cache.get(key) if not release: try: release = get_release_by_id(id, includes).get('release') except ResponseError as e: if e.cause.code == 404: raise APIError(code=e.cause.code, desc="Sorry, we could not find a release with that MusicBrainz ID.") else: raise APIError(code=e.cause.code, desc=e.cause.msg) cache.set(key, release, DEFAULT_CACHE_EXPIRATION) return release