def artist_info():
if request.method != 'GET':
return None
artistID = request.args.get('id', type=int)
print('id', artistID)
result = MusicBrainzDatabase.get_artist_info(artistID=artistID)
result_aliases = MusicBrainzDatabase.get_artist_aliases(
artistID, locales=config.config['preferred_locales'])
return jsonify(structFromArtist(result, result_aliases))
def artist_member_relations():
if request.method != 'GET':
return None
artistID = request.args.get('id', type=int)
r1, r2 = \
MusicBrainzDatabase.get_artist_members_of_band_relations(artistID)
result = {'members': r1, 'memberOf': r2}
r1, r2 = \
MusicBrainzDatabase.get_artist_collaboration_relations(artistID)
result.update({'collaborators': r1, 'collaboratorOn': r2})
print(result)
return jsonify(result)
def artist_get_image():
artist_id = request.args.get('id', type=int)
path = MusicBrainzDatabase.get_artist_image_path(artist_id)
if not path:
path = 'web-root/images/artist.png'
print('Delivering artist image of artist %s: %s' % (artist_id, path))
return send_file(path)
def api_v1_song_search():
plman = app.bard.playlist_manager
sq = SearchQuery.from_request(request, current_user.userID, plman)
if not sq:
raise ValueError('No SearchQuery!')
pl = plman.get_search_result_playlist(sq)
if not pl:
pl = SearchPlaylist(sq)
plman.add_search_playlist(pl)
songs = MusicBrainzDatabase.search_songs_for_webui(sq.query, sq.offset,
sq.page_size)
song_ids = [song['song_id'] for song in songs]
for song_id in song_ids:
pl.append_song(song_id)
ratings = MusicDatabase.get_songs_ratings(song_ids, current_user.userID)
songs = [{
'rating': ratings[song['song_id']],
**dict(song)
} for song in songs]
result = {
'search_playlist_id': pl.searchPlaylistID,
'search_query': sq.as_dict(),
'songs': songs
}
return jsonify(result)
def release_group_get_image():
release_group_mbid = request.args.get('mbid', type=str)
dirnames = MusicBrainzDatabase.get_release_group_directories(
release_group_mbid)
path = 'web-root/images/cd.png'
def find_cover_at_paths(dirnames, prefer_album_image):
for dirname in dirnames:
if prefer_album_image:
dirname = albumPath(dirPath=dirname)
cover = os.path.join(dirname, 'cover.jpg')
if os.path.exists(cover):
return cover
cover = cover[:-3] + 'png'
if os.path.exists(cover):
return cover
return None
path = (find_cover_at_paths(dirnames, True)
or find_cover_at_paths(dirnames, False))
print('Delivering release_group image of release_group %s: %s' %
(release_group_mbid, path))
return send_file(path) if path else ''
def release_group_info():
if request.method != 'GET':
return None
rgID = request.args.get('id', type=int)
print('id', rgID)
result = MusicBrainzDatabase.get_release_group_info(rgID)
print('release_group_info', dict(result))
return jsonify(dict(result))
def artists_letter_offset():
if request.method != 'GET':
return None
letter = request.args.get('letter', default='0', type=str)
print(letter)
result = {
'offset': MusicBrainzDatabase.get_letter_offset_for_artist(letter)
}
return jsonify(result)
def artist_credit_info():
if request.method != 'GET':
return None
artistCreditID = request.args.get('id', type=int)
print('artistCredit: ', artistCreditID)
result = MusicBrainzDatabase.get_artist_credit_info(artistCreditID)
result = [dict(x) for x in result]
return jsonify(result)
def artist_release_groups():
if request.method != 'GET':
return None
artistID = request.args.get('id', type=int)
print('artist release groups id=', artistID)
result = [
structFromReleaseGroup(x)
for x in MusicBrainzDatabase.get_artist_release_groups(artistID)
]
return jsonify(result)
def release_group_set_ratings():
if request.method != 'GET':
return None
rgID = request.args.get('id', type=int)
rating = request.args.get('rating', type=int)
album_ids = MusicBrainzDatabase.get_release_group_albums(rgID)
for album_id in album_ids:
MusicDatabase.set_album_rating(album_id, rating, current_user.userID)
return ''
def release_group_releases():
if request.method != 'GET':
return None
rgID = request.args.get('id', type=int)
print('id', rgID)
releases = MusicBrainzDatabase.get_release_group_releases(rgID)
result = []
for release in releases:
mediums = MusicBrainzDatabase.get_release_mediums(release['id'])
rel = dict(release)
rel['mediums_desc'] = MusicBrainzDatabase.mediumlist_to_string(mediums)
rel['audio_properties'] = [
album_properties_to_string(x)
for x in MusicDatabase.getAlbumProperties(release['album_id'])
]
rel['album_disambiguation'] = \
MusicBrainzDatabase.getAlbumDisambiguation(release)
result.append(rel)
return jsonify(result)
def structFromReleaseGroup(rg):
r = {}
r['id'] = rg.id
r['mbid'] = rg.mbid
r['name'] = rg.name
r['disambiguation'] = rg.disambiguation
r['release_group_type'] = rg.release_group_type
r['artist_credit_id'] = rg.artist_credit_id
r['artist_credit_name'] = rg.artist_credit_name
r['secondary_types'] = \
MusicBrainzDatabase.get_release_group_secondary_types(rg.id)
return r
def artists_list():
if request.method != 'GET':
return None
offset = request.args.get('offset', default=0, type=int)
page_size = request.args.get('page_size', default=500, type=int)
print('/api/v1/artists/list', offset, page_size)
# result = []
# for artist in getArtists(from_idx, to_idx, metadata=True):
# result.append(artist)
result = [
structFromArtist(x) for x in MusicBrainzDatabase.get_range_artists(
offset, page_size, metadata=True)
]
return jsonify(result)
def playlist_tracks():
if request.method != 'GET':
return None
playlistID = request.args.get('id', type=int)
songs = MusicBrainzDatabase.get_playlist_songs_information_for_webui(
playlistID)
song_ids = [song['song_id'] for song in songs]
ratings = MusicDatabase.get_songs_ratings(song_ids, current_user.userID)
result = [{
'rating': ratings[song['song_id']],
**dict(song)
} for song in songs]
return jsonify(result)
def album_tracks():
if request.method != 'GET':
return None
albumID = request.args.get('id', type=int)
# songIDs = {x['releasetrackid']: x['song_id']
# for x in MusicBrainzDatabase.get_album_songs(albumID)}
all_tracks = MusicBrainzDatabase.get_album_tracks(albumID)
existing_tracks = MusicBrainzDatabase. \
get_album_songs_information_for_webui(albumID)
song_ids = [track['song_id'] for track in existing_tracks]
ratings = MusicDatabase.get_songs_ratings(song_ids, current_user.userID)
existing_tracks = {
x['track_mbid']: {
'rating': ratings[x['song_id']],
**dict(x)
}
for x in existing_tracks
}
result = []
medium = {'number': None, 'tracks': []}
current_medium_number = None
for track in all_tracks:
if track['medium_number'] != current_medium_number:
if current_medium_number:
result.append(medium)
current_medium_number = track['medium_number']
format_id = track['medium_format_id']
medium_format_name = (MediumFormatEnum.name(format_id)
or 'Unknown Format')
medium = {
'number': track['medium_number'],
'name': track['medium_name'],
'format': medium_format_name,
'tracks': []
}
try:
medium['tracks'].append(existing_tracks[track['track_mbid']])
except KeyError:
trk = dict(track)
trk['song_id'] = None
trk['rating'] = (5, None)
medium['tracks'].append(trk)
result.append(medium)
return jsonify(result)
def release_get_image():
release_mbid = request.args.get('mbid', type=str)
dirnames = MusicBrainzDatabase.get_release_directories(release_mbid)
path = 'web-root/images/cd.png'
for dirname in dirnames:
cover = os.path.join(dirname, 'cover.jpg')
if os.path.exists(cover):
path = cover
break
cover = cover[:-3] + 'png'
if os.path.exists(cover):
path = cover
break
print('Delivering release image of release %s: %s' % (release_mbid, path))
return send_file(path) if path else ''
def importData(verbose):
print(f'importData {verbose}')
importer = MusicBrainzImporter()
_ = MusicDatabase()
_ = MusicBrainzDatabase()
print('Load data to import')
time1 = datetime.now()
importer.load_data_to_import()
time2 = datetime.now()
print(str(time2 - time1))
importer.import_everything()
time2 = datetime.now()
print(str(time2 - time1))
return set(x for (x,) in result.fetchall())
def get_song_paths_from_songs_mb(column, uuids):
c = MusicDatabase.getCursor()
sql = f'''select path
from songs
where id in (select song_id
from songs_mb
where {column} in :uuid_list)
order by path'''
result = c.execute(sql, {'uuid_list': tuple(uuids)})
return [x for (x,) in result.fetchall()]
db = MusicDatabase()
mbdb = MusicBrainzDatabase()
#artists = mbdb.get_all_artists()
#recordings = mbdb.get_all_recordings()
#releasegroups = mbdb.get_all_releasegroups()
#releases = mbdb.get_all_releases()
#tracks = mbdb.get_all_tracks()
#works = mbdb.get_all_works()
# MusicBrainzImporter.retrieve_mbdump_file('mbdump.tar.bz2')
importer = MusicBrainzImporter()
# importer.retrieve_musicbrainz_dumps()
importer.load_data_to_import(artist_credits=False, mediums=False,
linked_entities=False)