def test_browse_recording(self):
        artist = "47f67b22-affe-4fe1-9d25-853d69bc0ee3"
        musicbrainzngs.browse_recordings(artist=artist)
        self.assertEqual("http://musicbrainz.org/ws/2/recording/?artist=47f67b22-affe-4fe1-9d25-853d69bc0ee3", self.opener.get_url())

        release = "438042ef-7ccc-4d03-9391-4f66427b2055"
        musicbrainzngs.browse_recordings(release=release)
        self.assertEqual("http://musicbrainz.org/ws/2/recording/?release=438042ef-7ccc-4d03-9391-4f66427b2055", self.opener.get_url())
Example #2
0
def get_all_recordings(artist, includes=['artist-credits']):
    '''
    Gets all recordings by an artist with default artist credits

    Parameters
    ----------
    artist : str
      This should be a musicbrainz id str representing the artist
    includes : [str]
      list of include parameters matching the parameters at
      https://wiki.musicbrainz.org/Development/XML_Web_Service/Version_2#Libraries_to_use_the_Web_Service

    Returns
    -------
    recs : [{...}]
    a list of dicts, where each dict is a recording done by (at least)
    the artist

    Postconditions
    --------------
    the return value does not contain any duplicate recording titles

    '''
    recs = list()  # return value
    titles = set()  # set of already seen titles to remove duplicates
    recordings = mb.browse_recordings(artist, limit=100, includes=includes)
    recs += recordings['recording-list']
    count = recordings['recording-count'] - 100  # already grabbed
    offset = 100
    print('Downloading {}...'.format(artist))
    while count >= 0:
        recordings = mb.browse_recordings(artist,
                                          limit=100,
                                          includes=includes,
                                          offset=offset)
        # have we already seen a recording of this name?
        for record in recordings['recording-list']:
            if not (record['title'] in titles):
                recs.append(record)
        # update already seen titles
        titles.update(
            [record['title'] for record in recordings['recording-list']])
        count -= 100
        offset += 100

    return recs
Example #3
0
def get_lyrics(artist_id):
    """ Browses all pages of artist's recordings by increasing the offset by the limit

    For each recording the song name is added to a list ('recordings')

 """

    print("Collecting lyrics ...")

    offset = 0
    limit = 100

    recordings_browse = musicbrainzngs.browse_recordings(
        artist=artist_id, limit=limit, offset=offset
    )  # Gets all recordings linked to artist - returns dict with keys ['recording-list', 'recording-count']
    num_recordings = recordings_browse['recording-count']  # 1746 for Beyonce
    recordings = [None] * num_recordings

    for page_num in range(num_recordings // 100):

        recordings_browse = musicbrainzngs.browse_recordings(
            artist=artist_id, limit=limit, offset=offset
        )  # Gets all recordings linked to artist - returns dict with keys ['recording-list', 'recording-count']

        for position in range(limit):
            song_name = recordings_browse['recording-list'][position]['title']
            index = (page_num * 100) + position
            recordings[index] = song_name
        offset += limit

    recordings_browse = musicbrainzngs.browse_recordings(
        artist=artist_id, limit=limit, offset=offset
    )  # Gets all recordings linked to artist - returns dict with keys ['recording-list', 'recording-count']

    max_index = num_recordings - ((num_recordings // 100) * 100)
    for position in range(max_index):
        song_name = recordings_browse['recording-list'][position]['title']
        index = ((num_recordings // 100) * 100) + position
        recordings[index] = song_name

    recordings = list(
        dict.fromkeys(recordings)
    )  # removes duplicates by converting 'recordings' list to a dictionary then back to a list
    return recordings
Example #4
0
 def loadDiscographieFromServer(self, theID, turn = 1, threshold = 5):
     # skipp the unknown 
     if theID == '125ec42a-7229-4250-afc5-e057484327fe':
         return()
     if self.v:
         print("Trying to load discographie from server:", theID)
     respond = []
     try:
         # fetch songs from sevrer
         offs = 0
         while offs != -1:
             resp = musicbrainzngs.browse_recordings(theID, includes = ["artist-credits"], offset = offs, limit = 100)    
             # save fetched songs to DB, so we have them
             for s in resp['recording-list']:
                 # save the songs
                 songID = s['id']
                 #self.saveSong(songID, theID)
                 # save related artists:
                 artists = {}
                 for art in s['artist-credit']:
                     if isinstance(art, str):
                         # skip things like 'feat' and '&'
                         continue
                     a = art['artist']
                     artists[a['name']] = a['id']
                     # also save the names, so we have them already
                     self.saveArtist(a['id'],a['name'])
                 # save the song and the artists related to it:
                 respond.append(self.storeSongData(songID, theID,  artists))
             # write data to db, as we now have many new songs of this artist
             self.db.commit()
                 
             if (resp['recording-count'] - len(resp['recording-list']) > offs ):
                 offs = len(resp['recording-list']) + offs
             else:
                 offs = -1
         
         self.db.commit()
     
     # save artist as done:
         
     except:
         print("Problem reaching the server")
         if turn < threshold:
             print("Lets try again in 5 seconds")
             sleep(5)
             turn = turn + 1
             self.loadDiscographieFromServer(theID, turn)
         else:
             print("We tried to often, skipping Artist")
             print(theID)
     
     return(respond)
Example #5
0
def MBID_recording_iterator(mbid):
    """
    Returns a dictionary with all releases in the form {title:mbid} for a given artist MBID
    """
    recordings = {}
    recording_list = m.browse_recordings(release = mbid)['recording-list']
    no_rec = len(recording_list)
    for i in xrange(no_rec):
        title = recording_list[i]['title']
        mbid_title = recording_list[i]['id']
        recordings[title] = mbid_title
    # print recordings
    return recordings
Example #6
0
def fetch_all_recordings(artist_id):
    # When you want to fetch a list of entities greater than 25, you have to use one of the browse
    # functions. Not only can you specify a limit as high as 100, but you can also specify an offset
    # to get the complete list in multiple requests.
    offset = 0
    limit = 100
    recordings = []
    page = 1
    result = musicbrainz.browse_recordings(artist=artist_id, limit=limit)
    page_recs = result['recording-list']
    recordings += page_recs

    if "release-count" in result:
        count = result['release-count']
    while len(page_recs) >= limit:
        offset += limit
        page += 1
        result = musicbrainz.browse_recordings(artist=artist_id,
                                               limit=limit,
                                               offset=offset)
        page_recs = result['recording-list']
        recordings += page_recs

    return recordings
Example #7
0
def api_get_recordings(id):
    try:
        mbz.set_useragent("Artistics", "v1.0", "*****@*****.**")
        result = mbz.browse_recordings(artist=id, limit=1000)
    except mbz.WebServiceError as exc:
        result = {}

    if "recording-list" in result:
        return [
            recording(recordings["title"],
                      recordings["length"] if "length" in recordings else None)
            for recordings in result["recording-list"]
        ]

    return None
Example #8
0
 def _get_album(self):
     random_country = random.choice(self._country_field)
     musicbrainzngs.set_useragent(
         PROJECTNAME,
         "1.a",
         CONTACT
     )
     try:
         results = musicbrainzngs.search_releases(query="", limit=10, offset=None, strict=False,
                                                  country=random_country, mediums="CD", type="Album")
         offset = random.randint(0, results["release-count"] - 100)
         result = musicbrainzngs.search_releases(query="", limit=100, offset=offset, strict=False,
                                                 country=random_country, mediums="CD", type="Album",
                                                 reid="1ec09df8-aef8-48f1-91a9-92a982bf0dfe")
     except:
         return None
     releases = result["release-list"]
     releases_with_tracks = [x for x in releases if "medium-track-count" in x and x["medium-track-count"] > 4]
     while True:
         release = random.choice(releases_with_tracks)
         release_id = release["id"]
         try:
             tracks = musicbrainzngs.browse_recordings(release=release_id)
             self._success = True
         except:
             return None
         try:
             release_length = sum([int(int(x["length"]) / 1000) for x in tracks["recording-list"]])
             break
         except:
             pass
     self._data = {
         "title": release["title"], "id": release_id, "country": countries[random_country][0], "releaseyear": None,
         "artist": release["artist-credit"][0]["name"], "tracks": tracks["recording-count"],
         "duration": release_length
     }
     if "date" in release:
         self._data["releaseyear"] = int(release["date"][:4])
def fetch_recording_list_module(artist_id, record_count):
    """
    fetch the recording list from the musicbrainz python module
    :param artist_id: musicbrainz id
    :param record_count: count of recordings want to return
    :return: an array of recordings found in the module
    """

    _offset = _OFFSET
    _recordings = []

    try:
        # set the musicbrainz api user agent
        mb.set_useragent('jw-tech-test',
                         '1',
                         contact='*****@*****.**')

        while _offset < int(record_count):
            _ret = mb.browse_recordings(artist_id,
                                        limit=_LIMIT,
                                        offset=_offset)
            _rec_json = _ret["recording-list"]
            for r in _rec_json:
                s = r["title"].upper()
                if (check_brackets_in_arr(s, _recordings)
                        and check_cases_in_arr(s, _recordings)):
                    _recordings.append(s)
            _offset += 100
        return _recordings
    except mb.UsageError as e:
        print("No access to musicbrainz API")
    except mb.ResponseError as e:
        print(f"No artist found with id {artist_id}")
    except Exception as e:
        print(f"Unexpected error: {sys.info()}")
        raise e
Example #10
0
def album_info(release):
    """Takes a MusicBrainz release result dictionary and returns a beets
    AlbumInfo object containing the interesting data about that release.
    """
    # Get artist name using join phrases.
    artist_name, artist_sort_name, artist_credit_name = \
        _flatten_artist_credit(release['artist-credit'])

    ntracks = sum(len(m['track-list']) for m in release['medium-list'])

    # The MusicBrainz API omits 'artist-relation-list' and 'work-relation-list'
    # when the release has more than 500 tracks. So we use browse_recordings
    # on chunks of tracks to recover the same information in this case.
    if ntracks > BROWSE_MAXTRACKS:
        log.debug(u'Album {} has too many tracks', release['id'])
        recording_list = []
        for i in range(0, ntracks, BROWSE_CHUNKSIZE):
            log.debug(u'Retrieving tracks starting at {}', i)
            recording_list.extend(
                musicbrainzngs.browse_recordings(release=release['id'],
                                                 limit=BROWSE_CHUNKSIZE,
                                                 includes=BROWSE_INCLUDES,
                                                 offset=i)['recording-list'])
        track_map = {r['id']: r for r in recording_list}
        for medium in release['medium-list']:
            for recording in medium['track-list']:
                recording_info = track_map[recording['recording']['id']]
                recording['recording'] = recording_info

    # Basic info.
    track_infos = []
    index = 0
    for medium in release['medium-list']:
        disctitle = medium.get('title')
        format = medium.get('format')

        if format in config['match']['ignored_media'].as_str_seq():
            continue

        all_tracks = medium['track-list']
        if ('data-track-list' in medium
                and not config['match']['ignore_data_tracks']):
            all_tracks += medium['data-track-list']
        track_count = len(all_tracks)

        if 'pregap' in medium:
            all_tracks.insert(0, medium['pregap'])

        for track in all_tracks:

            if ('title' in track['recording']
                    and track['recording']['title'] in SKIPPED_TRACKS):
                continue

            if ('video' in track['recording']
                    and track['recording']['video'] == 'true'
                    and config['match']['ignore_video_tracks']):
                continue

            # Basic information from the recording.
            index += 1
            ti = track_info(
                track['recording'],
                index,
                int(medium['position']),
                int(track['position']),
                track_count,
            )
            ti.release_track_id = track['id']
            ti.disctitle = disctitle
            ti.media = format
            ti.track_alt = track['number']

            # Prefer track data, where present, over recording data.
            if track.get('title'):
                ti.title = track['title']
            if track.get('artist-credit'):
                # Get the artist names.
                ti.artist, ti.artist_sort, ti.artist_credit = \
                    _flatten_artist_credit(track['artist-credit'])
                ti.artist_id = track['artist-credit'][0]['artist']['id']
            if track.get('length'):
                ti.length = int(track['length']) / (1000.0)

            track_infos.append(ti)

    info = beets.autotag.hooks.AlbumInfo(
        album=release['title'],
        album_id=release['id'],
        artist=artist_name,
        artist_id=release['artist-credit'][0]['artist']['id'],
        tracks=track_infos,
        mediums=len(release['medium-list']),
        artist_sort=artist_sort_name,
        artist_credit=artist_credit_name,
        data_source=u'MusicBrainz',
        data_url=album_url(release['id']),
    )
    info.va = info.artist_id == VARIOUS_ARTISTS_ID
    if info.va:
        info.artist = config['va_name'].as_str()
    info.asin = release.get('asin')
    info.releasegroup_id = release['release-group']['id']
    info.albumstatus = release.get('status')

    # Get the disambiguation strings at the release and release group level.
    if release['release-group'].get('disambiguation'):
        info.releasegroupdisambig = \
            release['release-group'].get('disambiguation')
    if release.get('disambiguation'):
        info.albumdisambig = release.get('disambiguation')

    # Get the "classic" Release type. This data comes from a legacy API
    # feature before MusicBrainz supported multiple release types.
    if 'type' in release['release-group']:
        reltype = release['release-group']['type']
        if reltype:
            info.albumtype = reltype.lower()

    # Log the new-style "primary" and "secondary" release types.
    # Eventually, we'd like to actually store this data, but we just log
    # it for now to help understand the differences.
    if 'primary-type' in release['release-group']:
        rel_primarytype = release['release-group']['primary-type']
        if rel_primarytype:
            log.debug('primary MB release type: ' + rel_primarytype.lower())
    if 'secondary-type-list' in release['release-group']:
        if release['release-group']['secondary-type-list']:
            log.debug('secondary MB release type(s): ' + ', '.join([
                secondarytype.lower() for secondarytype in
                release['release-group']['secondary-type-list']
            ]))

    # Release events.
    info.country, release_date = _preferred_release_event(release)
    release_group_date = release['release-group'].get('first-release-date')
    if not release_date:
        # Fall back if release-specific date is not available.
        release_date = release_group_date
    _set_date_str(info, release_date, False)
    _set_date_str(info, release_group_date, True)

    # Label name.
    if release.get('label-info-list'):
        label_info = release['label-info-list'][0]
        if label_info.get('label'):
            label = label_info['label']['name']
            if label != '[no label]':
                info.label = label
        info.catalognum = label_info.get('catalog-number')

    # Text representation data.
    if release.get('text-representation'):
        rep = release['text-representation']
        info.script = rep.get('script')
        info.language = rep.get('language')

    # Media (format).
    if release['medium-list']:
        first_medium = release['medium-list'][0]
        info.media = first_medium.get('format')

    genres = release.get('genre-list')
    if config['musicbrainz']['genres'] and genres:
        info.genre = ';'.join(g['name'] for g in genres)

    extra_albumdatas = plugins.send('mb_album_extract', data=release)
    for extra_albumdata in extra_albumdatas:
        info.update(extra_albumdata)

    info.decode()
    return info
Example #11
0
# find the ID from the extracted json
mbid = data['artists'][0]['id']

# the lyrics site has a limit of a 100 results, the below loops through the pages to return all the songs

limit = 100
offset = 0
recordings = []
page = 0

# create a list to hold the track names
list = []

# use the function from the musicbrainz library to retrieve the track listings
# and loop through the pages based on the recording count
result = musicbrainzngs.browse_recordings(artist=mbid, limit=limit)
for recordinglist in result['recording-list']:
    list.append(recordinglist['title'])
page_recordings = result['recording-list']
recordings += page_recordings

if "recording-count" in result:
    count = result['recording-count']
while len(page_recordings) >= limit:
    offset += limit
    page += 1
    result = musicbrainzngs.browse_recordings(artist=mbid,
                                              limit=limit,
                                              offset=offset)
    page_recordings = result['recording-list']
    recordings += page_recordings
Example #12
0
import musicbrainzngs
import requests

def sources(recordingid):
    res = requests.get('http://185.97.32.250:8468/mbid:{}'.format(recordingid))
    #import pdb;pdb.set_trace()
    if not b'None' in res.content:
        return res.content.decode('utf-8')
musicbrainzngs.set_useragent("mb.py", "0", contact="*****@*****.**")
res = musicbrainzngs.search_artists("Ablaze")
for artist in res['artist-list']:
    print(artist['name'], artist['id'])
#import pdb;pdb.set_trace()
res = musicbrainzngs.browse_releases(artist='d2c0d69e-e3ca-45a4-a540-6ce42c617599', limit=100)
for release in res['release-list']:
    print(release['title'])
    recordings = musicbrainzngs.browse_recordings(release=release['id'])
    for rec in recordings['recording-list']:
#        import pdb;pdb.set_trace()
        print("\t\t",rec['title'],'\t', end='')
        print(sources(rec['id']))
#import pdb;pdb.set_trace()
Example #13
0
def run_app(name):
    response = musicbrainzngs.browse_recordings(artist=get_artist_id(name))
    titles = []
    for val in response['recording-list']:
        titles.append(val.get('title').replace("'", ''))
    return titles
Example #14
0
def get_albums(artist_id):
    """ Browses all releases of a given artist id, where release type is 'album'

    For each release, if not alreay in the dictionary then the title and date are added to one dictionary, whilst title and release id are added to another.
    For each release (album), its recordings (songs) are compared to those in words_dict2 (found previously by browsing the artist's recordings) -
    where songs match their word counnt is found from words_dict2 and thus the average number of words in each album is calculated.
    A bar chart of each album's year of release and the average number of words is plotted.

    """
    limit = 100
    offset = 0

    releases_browse = musicbrainzngs.browse_releases(
        release_type=['album'], artist=artist_id, limit=limit, offset=offset
    )  # Gets all recordings linked to artist - returns dict with keys ['recording-list', 'recording-count']

    num_releases = releases_browse['release-count']
    albums = [None] * num_releases

    for page_num in range(num_releases // 100):

        releases_browse = musicbrainzngs.browse_releases(
            release_type=['album'],
            artist=artist_id,
            limit=limit,
            offset=offset
        )  # Gets all recordings linked to artist - returns dict with keys ['recording-list', 'recording-count']

        for position in range(limit):  # 0 to 99
            album_info = releases_browse['release-list'][position]
            index = (page_num * 100) + position
            albums[index] = album_info
        offset += limit

    releases_browse = musicbrainzngs.browse_releases(
        release_type=['album'], artist=artist_id, limit=limit, offset=offset
    )  # Gets all recordings linked to artist - returns dict with keys ['recording-list', 'recording-count']

    max_index = num_releases - ((num_releases // 100) * 100)
    for position in range(max_index):  # 0 to 99
        album_info = releases_browse['release-list'][position]
        index = ((num_releases // 100) * 100) + position
        albums[index] = album_info

    #albums = list(dict.fromkeys(albums))

    album_id = {}
    album_dates = {}

    for album in albums:
        if album['title'] not in album_id.keys(
        ) and album['title'] not in album_dates.keys():
            try:
                album_date = datetime.datetime.strptime(
                    str(album['date'])[:4], '%Y').date()
                album_dates.update({album['title']: album_date.year})
                album_id.update({album['title']: album['id']})
            except KeyError:
                pass

    album_songs = {}

    for album_name, release_id in album_id.items():
        album_words = 0
        album_num_songs = 0
        recordings = musicbrainzngs.browse_recordings(
            release=release_id, limit=100, offset=0
        )  # Gets all recordings linked to artist - returns dict with keys ['recording-list', 'recording-count']
        for recording in recordings['recording-list']:
            title = recording['title']
            for key, value in words_dict2.items():
                if key == title:
                    album_num_songs += 1
                    album_words += value
        if album_num_songs != 0:
            album_av = album_words / album_num_songs
        else:
            album_av = 0
        album_songs.update({album_name: album_av})

    album_name, av_words = zip(
        *album_songs.items())  # unpack a list of pairs into two tuples
    album_name, album_date = zip(
        *album_dates.items())  # unpack a list of pairs into two tuples

    plt.bar([str(date) for date in album_date], height=av_words)
    plt.axhline(average,
                linewidth=1,
                color='m',
                linestyle='--',
                label="Average over all songs")
    plt.xlabel("Year", fontsize=12)
    plt.ylabel("Average number of words", fontsize=12)
    plt.title(
        "Graph of average number of words in album \n alongside year of release \n for {}"
        .format(artist_name))
    plt.xticks(rotation=90)
    plt.legend()
    plt.show()