def getDictionaryOfArtistsIDs(maxArtists): limit = 100 offset = 0 artists = [] page = 1 #print("fetching page number %d.." % page) result = musicbrainzngs.search_artists(ended="false", country="US", limit=limit) page_artists = result['artist-list'] artists += page_artists if "artist-count" in result: count = result['artist-count'] ##while len(page_artists) >= limit: while len(artists) < maxArtists: offset += limit page += 1 #print("fetching page number %d.." % page) result = musicbrainzngs.search_artists(ended="false", country="US", limit=limit, offset=offset) page_artists = result['artist-list'] artists += page_artists #print("") #for artist in artists: #print(u"{id}: {name}".format(id=artist['id'], name=artist["name"])) return artists
def main(*argv): m.set_useragent("applicatiason", "0.201", "http://recabal.com") m.set_hostname("localhost:8080") m.auth("vm", "musicbrainz") f = open(sys.argv[1], 'r') for line in f.xreadlines(): line = line.strip() lifeSpanString = "false,false" art_dict = m.search_artists(artist=line, limit=1, strict=True, tag="jazz") if art_dict['artist-count'] != 0: lifeSpanString = getLifeSpan(art_dict) else: art_dict = m.search_artists(artist=line, limit=1, strict=True) if art_dict['artist-count'] != 0: lifeSpanString = getLifeSpan(art_dict) print line + "," + lifeSpanString f.close()
def getArtistInfo(artist, topGenres=3): srch = mb.search_artists(artist=artist).get('artist-list') if len(srch) > 0: info = mb.search_artists(artist=artist).get('artist-list')[0] (id, name, country, city, genre) = (info.get('id'), info.get('name'), info.get('country'), getArea(info), getTopGenres(info, topGenres=topGenres)) tmp = [name, country, city, id] tmp.extend(genre) return tmp else: tmp = [artist, None, None, None] tmp.extend(topGenres * [None]) return tmp
def artistID(artistName): result = musicbrainzngs.search_artists(artist=artistName, type="group", country="US") artistDetails = result['artist-list'] return artistDetails[0]['id']
def obtener_artistas(): musicbrainzngs.set_useragent('musicbrainzngs', '2.0') results = musicbrainzngs.search_artists(area='Los Angeles', country="us", tag=['rock', 'metal'], limit=100) # q = musicbrainzngs.search_works(query='artist.name:Ozzy Osbourne',type='album') # q = musicbrainzngs.search_releases(artist='Ozzy Osbourne', country="us", limit=3) # pprint.pprint(q) # pprint.pprint(results) # i=0 for artist in results['artist-list']: if 'type' in artist: tipo = artist['type'] else: tipo = 'Group' bolillo = artista.artist(artist['id'], artist["name"], 'atun', artist['area']['name'], artist['ext:score'], tipo) # print('-------------------------------') # print(bolillo) # print(i,'===',artist['id'], artist["name"], artist['area']['name'], artist['ext:score'],artist['type']) # i+=1 DataBase.Agregar_Elemento_Artista(bolillo)
def artist_search(name, country=""): """ Poišče glasbenika z imenom `name`, iz države `country`. seznam slovarjev s ključi: 'name': (artist_name, artist_type, artist_mb_id) 'area': (area_name, area_type, area_mb_id) 'life-span': [date_started, date_ended] 'genre': [list of genres preformed] """ out = list() artists = mb.search_artists(name)["artist-list"] # iskanje glasbenikov print("-----------\n", artists) for selected in artists: print(selected[""]) # ni iz prave države if country and country != selected["area"]["name"]: continue area = selected["area"] l_s = selected["life-span"] genre = selected["tag-list"] data = dict() data["name"] = (selected["name"], selected["type"], selected["id"]) data["area"] = (area["name"], area["type"], area["id"]) data["life-span"] = [l_s["begin"], l_s["ended"]] data["genre"] = [g["name"] for g in genre] out.append(data) return out
def validate_artist(artist_name): ''' Makes sure we have the artist in the DB, otherwise it downloads the relevant information about them and stores it in the DB ''' artist_id = artist_in_db(artist_name) if artist_id: return artist_id logger.debug("Getting MusicBrainz info for %s", artist_name) response = try_mb_request(lambda: mb.search_artists(artist=artist_name)) if 0 == response['artist-count']: logger.warning('Got 0 possible artists for "%s", skipping', artist_name) country_code = -1 is_solo = True mb_id = None name = artist_name else: artist_json = response['artist-list'][0] # Currently we take the first, maybe we should take others? if 'area' in artist_json and 'name' in artist_json['area']: country = artist_json['area']['name'] else: country = -1 name = artist_json['name'] if 'type' in artist_json: is_solo = 'Person' == artist_json['type'] else: is_solo = True # We just assume this for now country_code = validate_country(country) mb_id = artist_json['id'] # This is needed because sometimes the name in artist_name doesn't match the name # in the json, and in those cases we might need the extra check artist_id = artist_in_db_by_mbid(mb_id) if artist_id: return artist_id return insert_artist(name, is_solo=is_solo, country_code=country_code, mb_id=mb_id)
def get_artist_tags(artist, limit, strict=False): # not very accurate and causes problem if the limit is not set to 1 (we just get the first result) # but good enough for now for what we want to do tags_string = '' result = m.search_artists(limit=limit, artist=artist, strict=strict) for artist in result['artist-list']: # print(u"\n{id}: {name}".format(id=artist['id'], name=artist["name"])) print(u"|______\t{name} ({score}%)".format(score=artist['ext:score'], name=artist["name"])) tags = artist.get("tag-list", "") # add 000 in front of the counter for tag in tags: tag['count'] = '{:0>4}'.format(tag.get("count", "")) # sort by number of tags (ascending) import operator sorted_tags = sorted(tags, key=operator.itemgetter('count'), reverse=True) # print and add to returned string for tag in sorted_tags: name = tag.get("name", "") count = tag.get("count", "") print("|\t" + name + "(" + count + ")") tags_string += name + ', ' return tags_string
def fetch_artist(artist_mbid, **kwarg): """fetch artist info from musicBrainz """ result = musicbrainzngs.search_artists(query='', limit=1, offset=None, strict=False, arid = artist_mbid) artist_info = {}; if 'artist-list' in result: if 'type' in result['artist-list'][0]: artist_info['artist_type'] = result['artist-list'][0]['type'] else: artist_info['artist_type'] = '' if 'gender' in result['artist-list'][0]: artist_info['artist_gender'] = result['artist-list'][0]['gender'] else: artist_info['artist_gender'] = '' if 'begin-area' in result['artist-list'][0]: artist_info['artist_begin_area'] = result['artist-list'][0]['begin-area']['name'] else: artist_info['artist_begin_area'] = '' if 'country' in result['artist-list'][0]: artist_info['artist_country'] = result['artist-list'][0]['country'] else: artist_info['artist_country'] = '' if 'life-span' in result['artist-list'][0] and 'begin' in result['artist-list'][0]['life-span']: artist_info['artist_begin_date'] = result['artist-list'][0]['life-span']['begin'] else: artist_info['artist_begin_date'] = '' if 'tag-list' in result['artist-list'][0]: tag_list = result['artist-list'][0]['tag-list'] artist_info['artist_tags'] = ';'.join([tag['name'] for tag in tag_list]) else: artist_info['artist_tags'] = '' return artist_info
def get_artist_tracks_from_musicbrainz(artist): """ Create Album, Track, and Solo records for artists we find in the MusicBrainzNGS API :param artist: an artist's name as a string to search for :return: Queryset of Solos """ search_results = mb.search_artists(artist) best_result = search_results['artist-list'][0] if 'jazz' not in [d['name'] for d in best_result['tag-list']]: return Solo.objects.none() instrument = Solo.get_instrument_from_musicbrainz_tags(best_result['tag-list']) for album_dict in mb.browse_releases(best_result['id'], includes=['recordings'])['release-list']: album = Album.objects.create(name=album_dict['title'], artist=artist, slug=slugify(album_dict['title'])) for track_dict in album_dict['medium-list'][0]['track-list']: track = Track.objects.create(album=album, name=track_dict['recording']['title'], track_number=track_dict['position'], slug=slugify(track_dict['recording']['title'])) Solo.objects.create(track=track, artist=artist, instrument=instrument, slug=slugify(artist)) return Solo.objects.filter(artist=artist)
def get_artist_tracks_from_musicbrianz_api(artist): search_results = mb.search_artists(artist) result = search_results['artist-list'][0] genre = Artist.get_genre_from_musicbrainz_tag_list(result['tag-list']) for album_dict in mb.browse_releases(result['id'], includes=['recordings' ])['release-list']: album = Album.objects.create(name=album_dict['title'], artist=artist, slug=slugify(album_dict['title'])) for track_dict in album_dict['medium-list'][0]['track-list']: track = Track.objects.create(album=album, name=track_dict['recording']['title'], track_number=track_dict['position'], slug=slugify( track_dict['recording']['title'])) Artist.objects.create(track=track, artist=artist, genre=genre, slug=slugify(artist)) return Artist.objects.filter(artist=artist)
def main(s): result = m.search_artists(artist=s) best_ratio = -1 name = '' artist_id = '' for artist in result['artist-list']: ratio = fuzz.token_set_ratio(s, artist['name']) if ratio > best_ratio: best_ratio = ratio artist_id = artist['id'] name = artist['name'] if ratio == 100: break if (artist_id == ''): print("No artist by name ", s) return result = m.search_releases(arid=artist_id, limit=15) artist = m.get_artist_by_id(artist_id) print(json.dumps(artist, sort_keys=True, indent=4)) print("\n::::::::::::\n") print(json.dumps(result, sort_keys=True, indent=4))
def get_artist_tracks_from_musicbrainz(cls, artist): """ Create Album, Track, and Solo records for artists we find in the MusicBrainzNGS API :param artist: an artist's name as a string to search for :return: Queryset of Solos """ search_results = mb.search_artists(artist) best_result = search_results['artist-list'][0] instrument = Solo.get_instrument_from_musicbrainz_tags( best_result['tag-list']) for album_dict in mb.browse_releases(best_result['id'], includes=['recordings' ])['release-list']: album = Album.objects.create(name=album_dict['title'], artist=artist, slug=slugify(album_dict['title'])) for track_dict in album_dict['medium-list'][0]['track-list']: track = Track.objects.create( album=album, name=track_dict['recording']['title'], track_number=track_dict['position'], slug=slugify(track_dict['recording']['title'])) Solo.objects.create(track=track, artist=artist, instrument=instrument, slug=slugify(artist)) return Solo.objects.filter(artist=artist)
def get_release_list(artist_str): """ Gets a release list from musicbrains API. """ username = '******' password = '******' musicbrainzngs.set_useragent(username, password) artist_list = musicbrainzngs.search_artists( artist=artist_str)['artist-list'] artist = sorted(artist_list, reverse=True, key=lambda artist: int(artist['ext:score']))[0] artist_id = artist['id'] limit = 100 offset = 0 release_list = [] release_count = 1 while offset < release_count: print 'Requesting tracks {0} - {1}'.format(str(offset), str(offset + limit)) result = musicbrainzngs.browse_releases(artist=artist_id, release_status=['official'], release_type=['album'], includes=['recordings'], limit=limit, offset=offset) release_count = result['release-count'] release_list += result['release-list'] offset += limit return release_list
def searach_Artist_in_Area(self, area, country, tag, limit): #tag=['rock','metal'] result = musicbrainzngs.search_artists(area=area, country=country, tag=tag, limit=limit) return result
def get_artists_from_freemuse(region, country): artists = set() # TODO: parse through all pages not just first one url = "https://freemuse.org/regions" + "/" + region + "/" + country page = requests.get(url) soup = BeautifulSoup(page.content, 'html.parser') items = soup.find_all(class_="item-list") for item in items: entry = item.find(class_="entry") article = entry.find('p').getText() doc = nlp(article) # keep only persons # TODO: sometimes actually ORG is relevant too entities = [x.text for x in doc.ents if (x.label_ == 'PERSON')] if entities: for entity in entities: # cross check person with musicbrainz so we make sure the artist exists in the specified country # TODO: not very robust. find some way to double check artist_in_musicbrainz = musicbrainzngs.search_artists( artist=entity, country=pycountry.countries.get( name=country).alpha_2)['artist-list'][0]['name'] artists.add(artist_in_musicbrainz) return (artists)
def assign_songs(self, cleaned_tweets): print "Matching songs to tweets" cleaner_tweets = [] tweets_used = 0 for cleaned_tweet in cleaned_tweets: if " by " in cleaned_tweet['text']: split_text = cleaned_tweet['text'].split(' by ') artists_list = mbz.search_artists(split_text[0]) try: mbID = artists_list['artist-list'][0]['id'] works = mbz.search_recordings(query=split_text[0], arid=mbID) tweet = dict() tweet['song'] = works['recording-list'][0]['title'] tweet['text'] = cleaned_tweet['text'] tweet['artist'] = artists_list['artist-list'][0]['name'] tweet['musicbrainzID'] = works['recording-list'][0]['id'] tweet['userID'] = cleaned_tweet['userID'] cleaner_tweets.append(tweet) tweets_used += 1 except (UnicodeEncodeError, IndexError): print "Unable to find song/artist" print "Tweets used: %s" % (tweets_used) return cleaner_tweets
def search(request, query_type, query): artist_results = [] album_results = [] if query_type == 'artist': data = musicbrainzngs.search_artists(query) for artist in data['artist-list']: artist_results.append( [artist['name'], artist['id'], artist.get('disambiguation')]) elif query_type == 'album': data = musicbrainzngs.search_release_groups(query) #def get_album_artists(credits): #if len(credits) > 1: #artists = [] #for item in credits: # artists.append(item['artist']['name']) #return artists #else: #return credits[0]['artist']['name'] for album in data['release-group-list']: album_results.append([ album['title'], album['id'], album['artist-credit'][0]['artist']['name'] ]) return render(request, 'home/home.html', { 'artist_list': artist_results, 'album_list': album_results })
def _search_artist(self, provider, known): logger.info('In _search_artist(provider={}, {})'.format(provider, known)) RESULTS_TO_REVIEW = 3 search = [lambda: self.lastfm.search_for_artist(known).get_next_page(), lambda: brainz.search_artists(known)['artist-list']][provider] Artist = [LastArtist, BrainzArtist][provider] output = None try: output = search() except Exception as exc: logger.critical('Exception in search') logger.exception(exc) return None if output: logger.debug('got output') for i, result in zip(range(RESULTS_TO_REVIEW), output): artist = Artist(result) logger.info('Got artist result ' + str(artist.name)) if (diff(artist.name, known) < 0.3 or (provider == BRAINZ and 'alias-list' in result and any(diff(alist, known) < 0.25 for alist in result['alias-list']))): return artist else: logger.info(artist.name + ' differs from ' + known) else: logger.debug('no output') return None
def artist_info( current_file): #name/type(Group/Person)/country/Begin/Begin area data = [] key = ['name', 'type', 'country', 'life-span', 'begin-area'] mbz.set_useragent("AIudio", "0.1") song = info(current_file) result = mbz.search_artists(artist=song['artist']) describe = result['artist-list'][0] for par in key: if par == 'life-span': try: data.append(describe[par]['begin']) except KeyError: data.append('None') elif par == 'begin-area': try: data.append(describe[par]['name']) except KeyError: data.append('None') else: try: data.append(describe[par]) except KeyError: data.append('None') return data
def add_musicbrainz_artist(cache, item): artist_name = item['artist'] found, entry = cache.lookup('artist:{}'.format(artist_name)) if found: log.debug("Found artist:{} in cache".format(artist_name)) else: log.debug("Didn't find artist:{} in cache, running remote query".format(artist_name)) result = musicbrainzngs.search_artists(artist=artist_name)['artist-list'] if result: entry = result[0] else: entry = None cache.store('artist:{}'.format(artist_name), entry) if entry is None: warnings = item.get('musicbrainz.warnings', []) warnings += ["Unable to find artist on musicbrainz"] item['musicbrainz.warnings'] = warnings else: item['musicbrainz.artist'] = entry['id'] if 'country' in entry: item['musicbrainz.artist.country'] = entry['country'] return item
def query_artist(self, query: str, selector: Callable[[artist.Artist], bool], country=None, qtype: str = None) -> List[artist.Artist]: field = {} if country is not None: field['country'] = country.alpha_2 if qtype is not None: field['type'] = qtype # search fields result = filter( selector, map( lambda artist: artist.Artist( None, name=artist.get("name", ""), artist_type=Musicbrainz.parse_artist_type(artist.get("type")), gender=Musicbrainz.parse_gender(artist.get("gender")), country=Musicbrainz.parse_country(artist.get("country")), birth=Musicbrainz.parse_birth(artist.get("life-span", {}).get("begin")), death=Musicbrainz.parse_death(artist.get("life-span", {}).get("end")), mbid=artist.get("id"), ), musicbrainzngs.search_artists(query, **field)['artist-list'] ) ) # more infomation searching return list(result)
def find_artist_by_name(name, limit=10, wanted_keys=('name', 'id', 'country', 'ext:score', 'type')): with musicbrainz_lock: params = {'artist': name.lower(), 'alias': name.lower()} search_results = musicbrainzngs.search_artists(limit=limit, **params)['artist-list'] sorted_by_score = sorted(search_results, cmp=lambda x, y: max(x, y), key=lambda d: int(d['ext:score'])) # return a list of dicts containing only the wanted values return [{k: v for k, v in d.items() if k in wanted_keys} for d in sorted_by_score]
def findArtist(name, limit=1): artistlist = [] artistResults = None chars = set('!?*-') if any((c in chars) for c in name): name = '"' + name + '"' criteria = {'artist': name.lower()} with mb_lock: try: artistResults = musicbrainzngs.search_artists(limit=limit, **criteria)['artist-list'] except ValueError as e: if "at least one query term is required" in e.message: logger.error( "Tried to search without a term, or an empty one. Provided artist (probably emtpy): %s", name) return False else: raise except musicbrainzngs.WebServiceError as e: logger.warn('Attempt to query MusicBrainz for %s failed (%s)' % (name, str(e))) mb_lock.snooze(5) if not artistResults: return False for result in artistResults: if 'disambiguation' in result: uniquename = unicode(result['sort-name'] + " (" + result['disambiguation'] + ")") else: uniquename = unicode(result['sort-name']) if result['name'] != uniquename and limit == 1: logger.info( 'Found an artist with a disambiguation: %s - doing an album based search' % name) artistdict = findArtistbyAlbum(name) if not artistdict: logger.info( 'Cannot determine the best match from an artist/album search. Using top match instead') artistlist.append({ # Just need the artist id if the limit is 1 # 'name': unicode(result['sort-name']), # 'uniquename': uniquename, 'id': unicode(result['id']), # 'url': unicode("http://musicbrainz.org/artist/" + result['id']),#probably needs to be changed # 'score': int(result['ext:score']) }) else: artistlist.append(artistdict) else: artistlist.append({ 'name': unicode(result['sort-name']), 'uniquename': uniquename, 'id': unicode(result['id']), 'url': unicode("http://musicbrainz.org/artist/" + result['id']), # probably needs to be changed 'score': int(result['ext:score']) }) return artistlist
def search_artists(query='', limit=None, offset=None): """Search for artists.""" api_resp = musicbrainzngs.search_artists(query=query, sortname=query, alias=query, limit=limit, offset=offset) return api_resp.get('artist-count'), api_resp.get('artist-list')
def get_artist_id(name): """Find the ID of an artist by their name.""" try: return next( filter(lambda a: a["name"].lower() == name.lower(), musicbrainzngs.search_artists(name)["artist-list"]))["id"] except StopIteration: raise ValueError(f"Artist {name} not literally found")
def __init__(self, artist): self.artist = artist self.artist_id = musicbrainzngs.search_artists( artist=artist)['artist-list'][0][ 'id'] # TODO apply checking in case match is partial works = musicbrainzngs.get_artist_by_id(self.artist_id, includes=["works"]) self.tracks = [work['title'] for work in works['artist']['work-list']]
def searchForArtistByName(name): initializeConnection() searchResults = mb.search_artists(artist=name) artists = [] for artist in searchResults['artist-list']: artists.append(MusicBrainzArtist(artist['id'], artist['name'])) return artists
def _retrieve_data(self, artist_name) -> dict: try: result = musicbrainzngs.search_artists(artist_name) return result except (HTTPError, musicbrainzngs.musicbrainz.ResponseError, TypeError) as e: print(e) return {}
def get_artist_place_of_origin(artist_name): artist = musicbrainzngs.search_artists(artist_name) try: origin_country = artist['artist-list'][0]['area']['name'] except: print('Either the artist or their origin cannot be found!') exit() return origin_country
def go(self): query = self.query.lower() + '*' return { 'results' : map(lambda artist: { 'id' : artist['id'], 'name' : artist['sort-name'] }, musicbrainzngs.search_artists(query.encode('utf-8'), limit=10).get('artist-list', [])) }
def search_artist(evt): result = m.search_artists(artist=mainwin['searchfield'].value) resultList = [] print("steeb found %s artists" % colored.cyan(len(result["artist-list"]))) for idx, artist in enumerate(result["artist-list"]): resultList.append([artist["name"], artist["id"]]) lv = mainwin['artistslist'] lv.items = resultList
def search_artist(query): r = mbz.search_artists(query, limit=5) artists = [{ k: artist[k] for k in ('name', 'disambiguation', 'id') if k in artist } for artist in r['artist-list']] return {'query': query, 'artists': artists}
def artist_data(artistname): try: data = musicbrainzngs.search_artists(query=artistname, limit=1, strict=False) if len(data["artist-list"]) >= 1: return data["artist-list"][0] except Exception as e: logging.warning("error while loading musicbrainz data for %s: %s", artistname, e)
def mbz_query(self, artist, recording): query_dict = {'recordings': None, 'artists': None} if recording: query_dict['recordings'] = mbz.search_recordings(recording, artist) return query_dict elif artist: query_dict['artists'] = mbz.search_artists(artist) return query_dict else: return None
def search_artist(queryArtistname): listArtists = mb.search_artists(artist=queryArtistname)['artist-list'] # check that artists have correct name listArtistsRelevantNames = [] for artist in listArtists: # check relevance of artist. TODO: break do offset and limit, not to miss artist if artist['name'] == queryArtistname: listArtistsRelevantNames.append(artist) return listArtistsRelevantNames
def get_artist_id(artist): '''Get the musicbrainz artist id for feeding into `musicbrainzngs.browse_releases`''' possible_ids = mb.search_artists(artist=artist, strict=True)['artist-list'] try: artist = [ res['id'] for res in possible_ids if int(res['ext:score']) == 100 ][0] except IndexError: raise ArtistNotFoundError(f'Artist {artist} not found') return artist
def _request(query, artist, album=None, track=None): results = None if track: results = musicbrainzngs.search_recordings(query=query) elif album: results = musicbrainzngs.search_releases(query=query) elif artist: results = musicbrainzngs.search_artists(query=query) return results
def api_search_artist(name): try: mbz.set_useragent("Artistics", "v1.0", "*****@*****.**") result = mbz.search_artists(artist=name) except mbz.WebServiceError as exc: result = {} if "artist-list" in result: return result["artist-list"] return None
def RetrieveArtistsList(outLoc,oset=0,query="type:person"): outDoc = open(outLoc,"a") art_list = "artist-list" art_count = "artist-count" alias_list = "alias-list" name = "name" artists = mb.search_artists(query=query,limit=100) offset = oset print artists[art_count] while offset < artists[art_count]: for artist in artists[art_list]: outDoc.write(artist[name].encode('UTF-8') + "\n") if alias_list in artist: for alias in artist[alias_list]: if "alias" in alias: outDoc.write(alias["alias"].encode('UTF-8') + "\n") time.sleep(3) offset += 100 print offset artists = mb.search_artists(query="type:person",limit=100,offset=offset) outDoc.close() print "finished"
def GetMusicBrainz(self): mbrainz.set_useragent("Example music app", "0.1", "http://example.com/music") result = mbrainz.search_artists(self.name)['artist-list'][0] # for result in results: # if int(result['ext:score']) > 75: # break #print result self.musicbrainz_id = result['id'] self.mbrainz_cache = mbrainz.get_artist_by_id(self.musicbrainz_id, ['artist-rels', 'url-rels'])['artist'] if 'url-relation-list' in self.mbrainz_cache: self.social_media = self.mbrainz_cache.pop('url-relation-list') if 'artist-relation-list' in self.mbrainz_cache: self.aliases = self.mbrainz_cache.pop('artist-relation-list')
def artist_mbid_find(artist_name): """ Returns an artist MBID """ artist_name = artist_name.decode('latin-1').encode('ascii', 'asciify') mb_artist_list = m.search_artists(artist_name)['artist-list'][0] mb_artist_name = mb_artist_list['name'].strip().encode('ascii', 'asciify') try: mb_artist_alias = mb_artist_list['alias-list'] except: mb_artist_alias = '' mb_artist_id = mb_artist_list['id'] if mb_artist_name and ((artist_name.lower() == mb_artist_name.lower()) or (artist_name in mb_artist_alias)): return mb_artist_id
def get_artists_by_name(name): artists = dict() result = musicbrainzngs.search_artists(artist=name) for artist in result['artist-list']: artist_name = artist['name'] artist_mbid = artist['id'] if artist['ext:score'] == "100": artists.update({artist_mbid:artist_name}) return artists
def main(*argv): m.set_useragent("applicatiason", "0.201", "http://recabal.com") m.set_hostname("localhost:8080") m.auth("vm", "musicbrainz") f = open(sys.argv[1],'r') for line in f.xreadlines(): line = line.strip(); lifeSpanString = "false,false" art_dict = m.search_artists(artist=line,limit=1,strict=True,tag="jazz") if art_dict['artist-count']!=0: lifeSpanString = getLifeSpan(art_dict) else: art_dict = m.search_artists(artist=line,limit=1,strict=True) if art_dict['artist-count']!=0: lifeSpanString = getLifeSpan(art_dict) print line+","+lifeSpanString f.close()
def searchMusicBrainzArtist(artist): """searchMusicBrainzArtist takes an artist name as a string and returns a list of artists that match the searched name.""" result = musicbrainzngs.search_artists(artist=artist, limit=5) # On success, result is a dictionary with a single key: # "artist-list", which is a list of dictionaries. results = [] if not result['artist-list']: return results for artist in result['artist-list']: # If we haven't seen this artist name yet, add it to the return list if artist['name'] not in results: results.append(artist['name']) return results
def bulk_import_artist(): terms = [ # 'bb king', # 'elvis', # 'black sabbath', # 'fugazi', # 'minor threat', # 'converge', # '\'68', # 'old man gloom', # 'citizen', # 'blues brothers', # 'cult of luna', # 'our lady', # 'so long forgotten', # 'cash', # 'z', # 'ramones', # 'kesha', # 'nine inch nails', # 'bill nye', # 'my bloody valentine', # 'ride', # 'slabdragger', # 'slowdive', # 'oasis', # 'reo', # 'cloakroom', # 'underoath', # 'brand new', # 'taking back sunday', # 'the cure', # 'jesu', # 'jesus and the mary chain', # 'zozobra', # 'cave in', # 'led zeppelin', 'pity sex', 'looming', 'our lady', ] for search in terms: print 'searching {}'.format(search) result = mb.search_artists(artist=search, type="group", country="US") for artist in result['artist-list']: import_artist(artist)
def get_artists_for_city(location): #TODO add celery here city = location.name musicbrainzngs.set_useragent("CultureRadio", 1) response = musicbrainzngs.search_artists(area=city, beginarea=city, endarea=city) response_artist_list = response.get('artist-list') for artist in response_artist_list: spotify_artists = get_spotify_artists_for_name(artist.get('name')) if len(spotify_artists) == 0: continue for spotify_artist in spotify_artists: uri, created = SpotifyData.objects.get_or_create(uri=spotify_artist.get('uri')) uri.save() a, created = Artist.objects.get_or_create(name=spotify_artist.get('name'), spotifyUri=uri) a.location.add(location) a.save() get_tracks_for_artist(a)
def test_search_artists(self): musicbrainzngs.search_artists("Dynamo Go") self.assertEqual("http://musicbrainz.org/ws/2/artist/?query=Dynamo+Go", self.opener.get_url()) musicbrainzngs.search_artists(artist="Dynamo Go") expected_query = 'artist:(dynamo go)' expected = 'http://musicbrainz.org/ws/2/artist/?query=%s' % musicbrainzngs.compat.quote_plus(expected_query) self.assertEquals(expected, self.opener.get_url()) # Invalid query field with self.assertRaises(musicbrainzngs.InvalidSearchFieldError): musicbrainzngs.search_artists(foo="value")
def artist_name_checker_mb(input_file, column_no): """ Checks if the name of a BDMC artist is on MB. Returns on_MB list non_MB list """ on_MB = [] non_MB = [] un_elem, all_elem = unique_elements(input_file, int(column_no)) for j, artist in enumerate(un_elem[0:]): print j artist_mb_name = '' artist_mb_name_ascii = '' artist_mb_type = '' artist_mb_country = '' artist_mb_alias = '' time.sleep(1) # musicbrainz TOS artist_dec = artist.decode('latin-1') artist_ascii = artist_dec.encode('ascii', 'asciify') try: artist_mb = m.search_artists(artist_dec)['artist-list'][0] except: artist_mb = '' try: artist_mb_name = artist_mb['name'] except: pass try: artist_mb_name_ascii = artist_mb_name.encode('ascii', 'asciify') except: artist_mb_name_ascii = '' try: artist_mb_type = artist_mb['type'] except: pass try: artist_mb_country = artist_mb['country'] except: pass try: artist_mb_alias = artist_mb['alias-list'] except: artist_mb_alias = '' if artist_mb_name and ((artist_ascii.upper() == artist_mb_name_ascii.upper()) or (artist_ascii in artist_mb_alias)): on_MB.append(artist) else: non_MB.append(artist) return on_MB, non_MB
def resolve_title_as_artist_musicbrainz(artist_name, sim_threshold=0.5): try: logging.info("Resolving %s as artist using MusicBrainz" % artist_name) mb.set_useragent("Juggle Mobile", "0.1", "http://juggle.fe.up.pt") res = mb.search_artists(artist=artist_name)['artist-list'] res = sorted(res, key=lambda artist: int(artist['ext:score']), reverse=True) if len(res) > 0 and sentence_similarity(artist_name, res[0]['name']) > sim_threshold: html = urllib2.urlopen('http://musicbrainz.org/artist/%s' % res[0]['id']).read() soup = BeautifulSoup(html, 'lxml') wikipedia = soup.select('li.wikipedia a[href]') if len(wikipedia) > 0: return (artist_name, wikipedia[0]['href'][wikipedia[0]['href'].rfind('/')+1:].replace('_', ' ')) except: logging.warning("Request to MusicBrainz failed for %s, skipping resolution" % artist_name) pass return (artist_name, None)
def getArtist(artist,apihandle): mbArtists = [ (x['name'],x['score']) for x in mb.search_artists(query=mbquote(artist),limit=int(50*mbMultiplier))['artist-list'] if 'name' in x and 'score' in x] mbDict = { } for mbAr in mbArtists: if mbAr[0] not in mbDict: vals = [x[1]**2 for x in mbArtists if x==mbAr[0]] mbDict[mbAr[0]] = [sqrt(mean(vals))/100] maxWhatcdScore = 0 for mbAr,mbScores in mbDict.items(): whatcd_artist = apihandle.request("artist", artistname=whatquote(mbAr))["response"] artist = unescape(whatcd_artist['name']) mbScores.append(log(mean(3*whatcd_artist["statistics"]["numSeeders"],2*whatcd_artist["statistics"]["numSnatches"]))) if mbScores[-1]>maxWhatcdScore: maxWhatcdScore = mbScores[-1] mbScores.append(2*Levenshtein.ratio(artist.lower(),mbAr.lower())) for mbScores in mbDict.values(): mbScores[1] /= maxWhatcdScore return max([(sum(scores),name) for name, scores in mbDict.items()] +[(1.5,artist)])[1]
def search_artists(artist, limit): from lxml import etree root = etree.XML(u'<artists></artists>') result = musicbrainzngs.search_artists(artist=artist, limit=limit) if debug: pprint.pprint(result) if result['artist-list']: for (idx, artist) in enumerate(result['artist-list']): artistNode = etree.SubElement(root, "id") etree.SubElement(artistNode, "id").text = artist['id'] etree.SubElement(artistNode, "name").text = artist['name'] etree.SubElement(artistNode, "sort-name").text = artist['sort-name'] else: etree.SubElement(root, "error").text = "No Artists found" log(True, etree.tostring(root, encoding='UTF-8', pretty_print=True, xml_declaration=True)) sys.exit(1) log(True, etree.tostring(root, encoding='UTF-8', pretty_print=True, xml_declaration=True)) sys.exit(0)
def get_release_list(artist_str): """ Gets a release list from musicbrains API. """ username = '******' password = '******' musicbrainzngs.set_useragent(username, password) artist_list = musicbrainzngs.search_artists(artist=artist_str)['artist-list'] artist = sorted(artist_list, reverse=True, key=lambda artist:int(artist['ext:score']))[0] artist_id = artist['id'] limit = 100 offset = 0 release_list = [] release_count = 1 while offset < release_count: print 'Requesting tracks {0} - {1}'.format(str(offset), str(offset+limit)) result = musicbrainzngs.browse_releases(artist=artist_id, release_status=['official'], release_type=['album'], includes=['recordings'], limit=limit, offset=offset) release_count = result['release-count'] release_list += result['release-list'] offset += limit return release_list
def getArtistID(self, known_data): ''' Match the given 'artist' entry to a MBrainz Artist ID Returns Artist MB-ID ''' # Blocking Call to MBrainz Server result = musicbrainzngs.search_artists(known_data['artist']) for x, r in enumerate(result['artist-list']): # Added attempt to make a match if search is ambiguous # eg. (more than 1 artist called "X") try: if 'genre' in known_data: if known_data['genre'].lower() in \ r['disambiguation'].lower(): self.Logger.msg('Returning Artist ID - {}'.format( result['artist-list'][x]['id']) ) return result['artist-list'][x]['id'] except: continue self.Logger.msg('Returning Fallback Artist ID - {}'.format( result['artist-list'][0]['id']) ) # Return a default result if no other match is made return result['artist-list'][0]['id']
def search_artist(name): results = musicbrainzngs.search_artists(name) return results
def getAlbumArtistNames(album,artist, apihandle, song=None): ''' Given a supposed album and artist, determine the real ones ''' def searchWhatAlbums(args): if len(args)==0: return [] whatResponse = apihandle.request(action='browse',searchstr=args[0]) if whatResponse['status']=='success': args.pop(0) return searchWhatAlbums(args)+[x for x in whatResponse['response']['results'] if 'artist' in x and 'groupName' in x] return [] mbAlbums = [] parens = re.compile('[\(\[].*[\)\]]') if song is not None: includes = ['recordings'] artists = set(re.split(' &|and|ft\.?|featuring|feat\.? ',artist)) if len(artists) > 1: artists.add(artist) for ar in artists: mbAlbums += [dict(list(x.items())+[("artist-credit-phrase", releases['artist-credit-phrase'])]) for releases in mb.search_recordings(query=song, limit=int(50*mbMultiplier), artistname=mbquote(ar), release=mbquote(album))['recording-list'] for x in releases['release-list']] mbAlbums += mb.search_releases(artist=mbquote(ar),query=mbquote(album),limit=int(25*mbMultiplier))['release-list'] lastfmres = [x['mbid'] for x in lookup('lastfm','songsearch',{'artist':ar, 'song':song})['results']['trackmatches']['track'] if 'mbid' in x and len(x['mbid'])>0] if len(lastfmres)>0: for lastfmRecId in set(lastfmres): try: lastfmAlbum = mb.get_recording_by_id(id=lastfmRecId,includes=['releases','artist-credits']) for alb in lastfmAlbum['recording'].pop('release-list'): alb['medium-list'] = [{}] alb['medium-list'][0]['track-list'] = [] alb['medium-list'][0]['track-list'].append(lastfmAlbum) alb['artist-credit-phrase'] = lastfmAlbum['recording']['artist-credit-phrase'] mbAlbums.append(alb) except Exception as e: print(e) else: includes = [] mbArtists = mb.search_artists(query=mbquote(artist),limit=int(40*mbMultiplier))['artist-list'] mbAlbums += mb.search_releases(artist=mbquote(artist),query=mbquote(album),limit=int(50*mbMultiplier))['release-list'] for mbArtist in mbArtists: if Levenshtein.ratio(artist.lower(),mbArtist['name'].lower()) > 0.75: mbAlbums+=[ dict(list(x.items())+[('artist-credit-phrase',mbArtist['name'])]) for x in mb.browse_releases(artist=mbArtist['id'],includes=includes,limit=25)['release-list']] if (len(album)<7 and ('/' in album or ' & ' in album) and 's' in album.lower() and 't' in album.lower()) or ('self' in album.lower() and 'titled' in album.lower()): mbAlbums += mb.search_releases(artist=mbquote(artist),query=mbquote(artist),limit=int(25*mbMultiplier))['release-list'] temp = [] for x in mbAlbums[:]: if x["id"] in temp and not ('medium-list' in x and len(x['medium-list'])>0 and all('track-list' in z and len(z['track-list'])>0 for z in x['medium-list'])): mbAlbums.remove(x) else: temp.append(x['id']) print("Done searching musicbrainz for album suggestions, have "+str(len(mbAlbums))+" to rank") ranks = {} for x in mbAlbums: ranks[x['id']] = Levenshtein.ratio(album.lower(),x['title'].lower()) if song is not None: x['song'] = {} temp = ([(y['recording']['title'] if 'recording' in y else y['title'], int(float( y['recording']['length'] if 'recording' in y and 'length' in y['recording'] else (y['track_or_recording_length'] if 'track_or_recording_length' in x else y['length'] if 'length' in x else 0) )/1000.)) for tracklist in x['medium-list'] for y in tracklist['track-list']] if 'medium-list' in x and len(x['medium-list'])>0 and all('track-list' in z and len(z['track-list'])>0 for z in x['medium-list']) else getSongs( {"artist":x['artist-credit-phrase'], "groupName":x['title']})) x['song']['name'], x['song']['duration'] = (max(temp, key=lambda y: Levenshtein.ratio(y[0].lower(),song.lower())) if len(temp)>0 else ("",-1)) if ranks[x['id']] < Levenshtein.ratio(x['song']['name'].lower(),song.lower()): ranks[x['id']] /= 6 ranks[x['id']] += (Levenshtein.ratio(x['song']['name'].lower(),song.lower()) + Levenshtein.ratio(parens.sub('',x['song']['name'].lower()),parens.sub('',song.lower())) )*5/12 else: ranks[x['id']] /= 3 ranks[x['id']] += (Levenshtein.ratio(x['song']['name'].lower(),song.lower()) + Levenshtein.ratio(parens.sub('',x['song']['name'].lower()),parens.sub('',song.lower())) )/3 ranks[x['id']] += Levenshtein.ratio(artist.lower(),x['artist-credit-phrase'].lower())*7/6 if len(ranks) == 0: return None mbAlbumId, mbAlbumRank = max(ranks.items(),key=(lambda x:x[1])) mbAlbum = [x for x in mbAlbums if x['id']==mbAlbumId][0] print("For the artist and album derived from the provided dir ("+artist+" and "+album+" respectively),\nthe following artist and album was matched on musicbrains:") print("Artist: "+mbAlbum['artist-credit-phrase']) print("Album: "+mbAlbum['title']) whatAlbums = searchWhatAlbums([mbAlbum['title']+' '+mbAlbum['artist-credit-phrase'], artist+' '+album]) if len(whatAlbums) == 0: whatAlbums = searchWhatAlbums([artist,album,mbAlbum['title'],mbAlbum['artist-credit-phrase']]) if len(whatAlbums) == 0: return None whatAlbums = sorted(whatAlbums, key=(lambda x: Levenshtein.ratio(x['groupName'],mbAlbum['title']) +Levenshtein.ratio(x['groupName'].lower(),album.lower())*3/8 +Levenshtein.ratio(x['artist'],mbAlbum['artist-credit-phrase']) +Levenshtein.ratio(x['artist'].lower(),artist.lower())*5/8), reverse=True)#[:min(10,len(whatAlbums))] whatAlbum = whatAlbums[0] whatAlbum['artist-credit-phrase'] = mbAlbum['artist-credit-phrase'] if song is not None: whatAlbum['song'] = mbAlbum['song'] print("For the album and artist found on musicbrainz, the following torrent group was found on what:") print("Artist: "+whatAlbum['artist']) print("Album: "+whatAlbum['groupName']) return whatAlbum
def testSearchArtist(self): musicbrainzngs.search_artists("Dynamo Go") self.assertEqual("http://musicbrainz.org/ws/2/artist/?query=Dynamo+Go", self.opener.get_url())