294 lines
9.2 KiB
Python
294 lines
9.2 KiB
Python
import fetcher.musicbrainz as mb
|
|
from utils import pretty_print_json
|
|
|
|
|
|
def full_country_name(country_code):
|
|
from country_list import countries_for_language
|
|
return dict(countries_for_language('es')).get(country_code, country_code)
|
|
|
|
|
|
def translate_artist_type(artist_type):
|
|
translation = {
|
|
'Person': 'Persona',
|
|
'Group': 'Grupo',
|
|
'Orchestra': 'Orquesta',
|
|
'Choir': 'Coro',
|
|
'Character': 'Personaje',
|
|
'Other': 'Otro',
|
|
}
|
|
return translation.get(artist_type, artist_type)
|
|
|
|
|
|
def map_artist(mb_artist):
|
|
artist = {
|
|
'id': mb_artist.get('id'),
|
|
'name': mb_artist.get('name'),
|
|
'sort_name': mb_artist.get('sort_name'),
|
|
'disambiguation': mb_artist.get('disambiguation'),
|
|
'type': translate_artist_type(mb_artist.get('type')),
|
|
'country': full_country_name(mb_artist.get('country')),
|
|
'tags': sorted(mb_artist.get('tags', []), key=lambda tag: tag['count'], reverse=True),
|
|
}
|
|
|
|
return artist
|
|
|
|
|
|
def map_artist_credit(mb_artist_credit):
|
|
return {
|
|
'id': mb_artist_credit.get('artist').get('id'),
|
|
'name': mb_artist_credit.get('artist').get('name'),
|
|
'sort_name': mb_artist_credit.get('artist').get('sort_name'),
|
|
'disambiguation': mb_artist_credit.get('artist').get('disambiguation'),
|
|
}
|
|
|
|
|
|
def map_disc(mb_disc):
|
|
disc = {
|
|
'id': mb_disc.get('id'),
|
|
'title': mb_disc.get('title'),
|
|
'disambiguation': mb_disc.get('disambiguation'),
|
|
'first_release_date': mb_disc.get('first_release_date'),
|
|
'primary_type': mb_disc.get('primary_type'),
|
|
'cover_art': get_cover_art_disc(mb_disc.get('id')),
|
|
'artist': [map_artist_credit(c) for c in mb_disc.get('artist_credit')]
|
|
}
|
|
|
|
if len(mb_disc.get('secondary_types', [])) > 0:
|
|
disc['secondary_type'] = mb_disc['secondary_types'][0]
|
|
|
|
return disc
|
|
|
|
|
|
def map_release(mb_release):
|
|
return {
|
|
'id': mb_release.get('id'),
|
|
'title': mb_release.get('title'),
|
|
'disambiguation': mb_release.get('disambiguation'),
|
|
'status': mb_release.get('status'),
|
|
'country': mb_release.get('country'),
|
|
'date': mb_release.get('date'),
|
|
'cover_art': get_cover_art_release(mb_release.get('id')),
|
|
'artist': [map_artist_credit(c) for c in mb_release.get('artist_credit')]
|
|
}
|
|
|
|
|
|
def map_recording(mb_recording):
|
|
return {
|
|
'id': mb_recording.get('id'),
|
|
'title': mb_recording.get('title'),
|
|
'disambiguation': mb_recording.get('disambiguation'),
|
|
'length': mb_recording.get('length'),
|
|
'artist': [map_artist_credit(c) for c in mb_recording.get('artist_credit')]
|
|
}
|
|
|
|
|
|
def map_coverart(mb_cover):
|
|
return {
|
|
'image': mb_cover.get('image'),
|
|
'1200': mb_cover.get('thumbnails', {}).get('1200'),
|
|
'500': mb_cover.get('thumbnails', {}).get('500'),
|
|
'250': mb_cover.get('thumbnails', {}).get('250'),
|
|
'large': mb_cover.get('thumbnails', {}).get('large'),
|
|
'small': mb_cover.get('thumbnails', {}).get('small'),
|
|
}
|
|
|
|
|
|
def find_best_cover(mb_covers):
|
|
only_aproved_front = [x for x in mb_covers.get('images') if x.get('approved', False) and x.get('front', False) and not x.get('back', False)]
|
|
if len(only_aproved_front) > 0:
|
|
return only_aproved_front[0]
|
|
|
|
only_aproved = [x for x in mb_covers.get('images') if x.get('approved', False)]
|
|
if len(only_aproved) > 0:
|
|
return only_aproved[0]
|
|
|
|
return mb_covers.get('images')[0]
|
|
|
|
|
|
def paginate(count, limit, page):
|
|
from math import ceil
|
|
return {
|
|
'total': count,
|
|
'current_page': page,
|
|
'last_page': ceil(count / limit),
|
|
'per_page': limit,
|
|
}
|
|
|
|
|
|
def get_artist(mbid):
|
|
mb_artist = mb.get_artist_by_mbid(mbid, includes=['tags'])
|
|
|
|
if 'error' in mb_artist:
|
|
return mb_artist
|
|
|
|
return map_artist(mb_artist)
|
|
|
|
|
|
def get_disc(mbid):
|
|
mb_disc = mb.get_release_group_by_mbid(mbid, includes=['artists'])
|
|
if 'error' in mb_disc:
|
|
return mb_disc
|
|
|
|
return map_disc(mb_disc)
|
|
|
|
|
|
def get_discs_of_artist(mbid, limit, page):
|
|
mb_discs = mb.browse_release_groups(params={'artist': mbid}, includes=['artist-credits'], limit=limit, offset=limit * (page - 1))
|
|
if 'error' in mb_discs:
|
|
return mb_discs
|
|
|
|
return {
|
|
'paginate': paginate(mb_discs['release_group_count'], limit, page),
|
|
'discs': [map_disc(d) for d in mb_discs['release_groups']],
|
|
}
|
|
|
|
|
|
def get_artist_of_disc(mbid, limit, page):
|
|
mb_artists = mb.browse_artists(params={'disc': mbid}, limit=limit, offset=limit * (page - 1))
|
|
if 'error' in mb_artists:
|
|
return mb_artists
|
|
|
|
return {
|
|
'paginate': paginate(mb_artists.get('artist_count', 0), limit, page),
|
|
'artists': [map_artist(mb_artists) for mb_artists in mb_artists['artists']]
|
|
}
|
|
|
|
|
|
def get_release(mbid):
|
|
mb_release = mb.get_release_by_mbid(mbid, includes=['artists'])
|
|
if 'error' in mb_release:
|
|
return mb_release
|
|
|
|
return map_release(mb_release)
|
|
|
|
|
|
def get_releases_of_disc(mbid, limit, page):
|
|
mb_releases = mb.browse_releases(params={'release-group': mbid}, includes=['artist-credits'], limit=limit, offset=limit * (page - 1))
|
|
if 'error' in mb_releases:
|
|
return mb_releases
|
|
|
|
return {
|
|
'paginate': paginate(mb_releases.get('release_count', 0), limit, page),
|
|
'releases': [map_release(release) for release in mb_releases.get('releases')]
|
|
}
|
|
|
|
|
|
def get_artist_of_release(mbid, limit, page):
|
|
mb_artists = mb.browse_artists(params={'release': mbid}, limit=limit, offset=limit * (page - 1))
|
|
if 'error' in mb_artists:
|
|
return mb_artists
|
|
|
|
return {
|
|
'paginate': paginate(mb_artists.get('artist_count', 0), limit, page),
|
|
'artists': [map_artist(mb_artists) for mb_artists in mb_artists['artists']]
|
|
}
|
|
|
|
|
|
def get_recording(mbid):
|
|
mb_recording = mb.get_recording_by_mbid(mbid, includes=['artists'])
|
|
if 'error' in mb_recording:
|
|
return mb_recording
|
|
|
|
return map_recording(mb_recording)
|
|
|
|
|
|
def get_recordings_of_release(mbid, limit, page):
|
|
mb_recordings = mb.browse_recordings(params={'release': mbid}, includes=['artist-credits'], limit=limit, offset=limit * (page - 1))
|
|
if 'error' in mb_recordings:
|
|
return mb_recordings
|
|
|
|
return {
|
|
'paginate': paginate(mb_recordings.get('recording_count', 0), limit, page),
|
|
'recordings': [map_recording(mb_recording) for mb_recording in mb_recordings['recordings']]
|
|
}
|
|
|
|
|
|
def get_release_of_recording(mbid, limit, page):
|
|
mb_releases = mb.browse_releases(params={'recording': mbid}, includes=['artists-credits'], limit=limit, offset=limit * (page - 1))
|
|
if 'error' in mb_releases:
|
|
return mb_releases
|
|
|
|
return {
|
|
'paginate': paginate(mb_releases.get('release_count', 0), limit, page),
|
|
'releases': [map_release(release) for release in mb_releases.get('releases')]
|
|
}
|
|
|
|
|
|
def get_artist_of_recording(mbid, limit, page):
|
|
mb_artists = mb.browse_artists(params={'recording': mbid}, limit=limit, offset=limit * (page - 1))
|
|
if 'error' in mb_artists:
|
|
return mb_artists
|
|
|
|
return {
|
|
'paginate': paginate(mb_artists.get('artist_count', 0), limit, page),
|
|
'artists': [map_recording(mb_recording) for mb_recording in mb_artists['artists']]
|
|
}
|
|
|
|
|
|
def get_cover_art_disc(mbid):
|
|
mb_covers = mb.get_release_group_cover_art(mbid)
|
|
if 'error' in mb_covers:
|
|
return None
|
|
|
|
if len(mb_covers.get('images', [])) == 1:
|
|
return map_coverart(mb_covers.get('images')[0])
|
|
|
|
return map_coverart(find_best_cover(mb_covers))
|
|
|
|
|
|
def get_cover_art_release(mbid):
|
|
mb_covers = mb.get_release_cover_art(mbid)
|
|
if 'error' in mb_covers:
|
|
return None
|
|
|
|
if len(mb_covers.get('images', [])) == 1:
|
|
return map_coverart(mb_covers.get('images')[0])
|
|
|
|
return map_coverart(find_best_cover(mb_covers))
|
|
|
|
|
|
def get_cover_art_recording(mbid):
|
|
release = get_release_of_recording(mbid, limit=1, page=1)
|
|
if 'error' in release:
|
|
return None
|
|
|
|
return get_cover_art_release(release['releases'][0]['id'])
|
|
|
|
|
|
def search_artist(query, limit, page):
|
|
mb_artists = mb.search_artist(query=query, limit=limit, offset=limit * (page - 1))
|
|
if 'error' in mb_artists:
|
|
return mb_artists
|
|
|
|
return {
|
|
'paginate': paginate(mb_artists['count'], limit, page),
|
|
'artists': [map_artist(a) for a in mb_artists['artists']]
|
|
}
|
|
|
|
|
|
def search_disc(query, limit, page):
|
|
mb_discs = mb.search_release_group(query=query, includes=['artist'], limit=limit, offset=limit * (page - 1))
|
|
|
|
return {
|
|
'paginate': paginate(mb_discs['count'], limit, page),
|
|
'discs': [map_disc(r) for r in mb_discs['release_groups']]
|
|
}
|
|
|
|
|
|
def search_release(query, limit, page):
|
|
mb_releases = mb.search_release(query=query, includes=['artist'], limit=limit, offset=limit * (page - 1))
|
|
|
|
return {
|
|
'paginate': paginate(mb_releases['count'], limit, page),
|
|
'releases': [map_release(r) for r in mb_releases['releases']]
|
|
}
|
|
|
|
|
|
def search_recording(query, limit, page):
|
|
mb_recording = mb.search_recording(query=query, includes=['artist'], limit=limit, offset=limit * (page - 1))
|
|
|
|
return {
|
|
'paginate': paginate(mb_recording['count'], limit, page),
|
|
'recordings': [map_recording(r) for r in mb_recording['recordings']]
|
|
}
|