skrd/musiclist-server
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Agregada busqueda y cambiada nuevamente api

Browse Source
This commit is contained in:
Daniel Cortes
2020-05-22 22:24:39 -04:00
parent a37d51b120
commit 765005ac4e
4 changed files with 177 additions and 265 deletions
Download Patch File Download Diff File Expand all files Collapse all files

288
fetcher/medium.py
View File

@@ -1,31 +1,21 @@
import math
import fetcher.musicbrainz as mb
from utils import pretty_print_json
def get_artist(mbid):
mb_artist = mb.get_artist_by_mbid(mbid)
if 'error' in mb_artist:
return mb_artist
artist = {
def map_artist(mb_artist):
pretty_print_json(mb_artist.get('tags'))
return {
'id': mb_artist.get('id'),
'name': mb_artist.get('name'),
'sort_name': mb_artist.get('sort_name'),
'disambiguation': mb_artist.get('disambiguation'),
'type': mb_artist.get('type'),
'country': mb_artist.get('country')
'country': mb_artist.get('country'),
'tags': sorted(mb_artist.get('tags', []), key=lambda tag: tag['count'], reverse=True),
}
return artist
def get_disc(mbid):
mb_disc = mb.get_release_group_by_mbid(mbid)
if 'error' in mb_disc:
return mb_disc
def map_disc(mb_disc):
disc = {
'id': mb_disc.get('id'),
'title': mb_disc.get('title'),
@@ -41,43 +31,8 @@ def get_disc(mbid):
return disc
def get_discs_of_artist(mbid, limit, page):
mb_discs = mb.browse_release_groups(params={'artist': mbid}, limit=limit, offset=limit * (page - 1))
if 'error' in mb_discs:
return mb_discs
response = {
'total': mb_discs.get('release_group_count', 0),
'current_page': page,
'last_page': math.ceil(mb_discs.get('release_group_count', 0) / limit),
'per_page': limit,
'discs': [],
}
for mb_disc in mb_discs['release_groups']:
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'))
}
if len(mb_disc.get('secondary_types', [])) > 0:
disc['secondary_type'] = mb_disc['secondary_types'][0]
response['discs'].append(disc)
return response
def get_release(mbid):
mb_release = mb.get_release_by_mbid(mbid)
if 'error' in mb_release:
return mb_release
release = {
def map_release(mb_release):
return {
'id': mb_release.get('id'),
'title': mb_release.get('title'),
'disambiguation': mb_release.get('disambiguation'),
@@ -87,41 +42,9 @@ def get_release(mbid):
'cover_art': get_cover_art_release(mb_release.get('id'))
}
return release
def get_releases_of_disc(mbid, limit, page):
mb_releases = mb.browse_releases(params={'release-group': mbid}, limit=limit, offset=limit * (page - 1))
response = {
'total': mb_releases.get('release_count', 0),
'current_page': page,
'last_page': math.ceil(mb_releases.get('release_count', 0) / limit),
'per_page': limit,
'releases': [],
}
for mb_release in mb_releases['releases']:
release = {
'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'))
}
response['releases'].append(release)
return response
def get_recording(mbid):
mb_recording = mb.get_recording_by_mbid(mbid)
if 'error' in mb_recording:
return mb_recording
recording = {
def map_recording(mb_recording):
return {
'id': mb_recording.get('id'),
'title': mb_recording.get('title'),
'disambiguation': mb_recording.get('disambiguation'),
@@ -129,7 +52,91 @@ def get_recording(mbid):
'length': mb_recording.get('length')
}
return recording
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)
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}, 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_release(mbid):
mb_release = mb.get_release_by_mbid(mbid)
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}, limit=limit, offset=limit * (page - 1))
return {
'paginate': paginate(mb_releases.get('release_count', 0), limit, page),
'releases': [map_release(release) for release in mb_releases.get('releases')]
}
def get_recording(mbid):
mb_recording = mb.get_recording_by_mbid(mbid)
if 'error' in mb_recording:
return mb_recording
return map_recording(mb_recording)
def get_recordings_of_release(mbid, limit, page):
@@ -137,81 +144,56 @@ def get_recordings_of_release(mbid, limit, page):
if 'error' in mb_recordings:
return mb_recordings
response = {
'total': mb_recordings.get('release_count', 0),
'current_page': page,
'last_page': math.ceil(mb_recordings.get('release_count', 0) / limit),
'per_page': limit,
'recordings': [],
return {
'paginate': paginate(mb_recordings.get('recording_count', 0), limit, page),
'recordings': [map_recording(mb_recording) for mb_recording in mb_recordings['recordings']]
}
for mb_recording in mb_recordings['recordings']:
recording = {
'id': mb_recording.get('id'),
'title': mb_recording.get('title'),
'disambiguation': mb_recording.get('disambiguation'),
'video': mb_recording.get('video'),
'length': mb_recording.get('length')
}
response['recordings'].append(recording)
return response
def get_cover_art_disc(mbid):
covers = mb.get_release_group_cover_art(mbid)
if 'error' in covers:
return covers
mb_covers = mb.get_release_group_cover_art(mbid)
if 'error' in mb_covers:
return None
def build(cover):
return {
'image': cover.get('image'),
'1200': cover.get('thumbnails', {}).get('1200'),
'500': cover.get('thumbnails', {}).get('500'),
'250': cover.get('thumbnails', {}).get('250'),
'large': cover.get('thumbnails', {}).get('large'),
'small': cover.get('thumbnails', {}).get('small'),
}
if len(mb_covers.get('images', [])) == 1:
return map_coverart(mb_covers.get('images')[0])
if len(covers.get('images', [])) == 1:
return build(covers.get('images')[0])
only_aproved_front = [x for x in covers.get('images') if x.get('approved', False) and x.get('front', False) and not x.get('back', False)]
only_aproved = [x for x in covers.get('images') if x.get('approved', False)]
if len(only_aproved_front) > 0:
return build(only_aproved_front[0])
elif len(only_aproved) > 0:
return build(only_aproved[0])
else:
return build(covers.get('images')[0])
return map_coverart(find_best_cover(mb_covers))
def get_cover_art_release(mbid):
covers = mb.get_release_cover_art(mbid)
if 'error' in covers:
return covers
mb_covers = mb.get_release_cover_art(mbid)
if 'error' in mb_covers:
return None
def build(cover):
return {
'image': cover.get('image'),
'1200': cover.get('thumbnails', {}).get('1200'),
'500': cover.get('thumbnails', {}).get('500'),
'250': cover.get('thumbnails', {}).get('250'),
'large': cover.get('thumbnails', {}).get('large'),
'small': cover.get('thumbnails', {}).get('small'),
}
if len(mb_covers.get('images', [])) == 1:
return map_coverart(mb_covers.get('images')[0])
if len(covers.get('images', [])) == 1:
return build(covers.get('images')[0])
return map_coverart(find_best_cover(mb_covers))
only_aproved_front = [x for x in covers.get('images', []) if x.get('approved', False) and x.get('front', False) and not x.get('back', False)]
only_aproved = [x for x in covers.get('images', []) if x.get('approved', False)]
if len(only_aproved_front) > 0:
return build(only_aproved_front[0])
elif len(only_aproved) > 0:
return build(only_aproved[0])
else:
return build(covers.get('images')[0])
def search_artist(query, limit, page):
mb_artists = mb.search_artist(query=query, limit=limit, offset=limit * (page - 1))
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, 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, limit=limit, offset=limit * (page - 1))
return {
'paginate': paginate(mb_releases['count'], limit, page),
'releases': [map_release(r) for r in mb_releases['release_groups']]
}

5
fetcher/musicbrainz.py
View File

@@ -1,3 +1,8 @@
"""
Modulo que se encarga de realizar requests a musicbrainz, mayormente devuelve el resultado que musicbrainz entrega
exceptuando los errores.
"""
import logging
import requests
from ratelimit import limits, sleep_and_retry

19
fetcher/urls.py
View File

@@ -2,15 +2,18 @@ from django.urls import path
from . import views
urlpatterns = [
path('get/artist/<mbid>/', views.get_artist),
path('get/artist/<mbid>/discs/', views.get_discs_of_artist),
path('artist/<mbid>/', views.get_artist),
path('artist/<mbid>/discs/', views.get_discs_of_artist),
path('artist/', views.search_artist),
path('get/disc/<mbid>/', views.get_disc),
path('get/disc/<mbid>/releases/', views.get_releases_of_disc),
path('disc/<mbid>/', views.get_disc),
path('disc/<mbid>/releases/', views.get_releases_of_disc),
path('disc/<mbid>/coverart/', views.get_release_group_cover_art),
path('disc/', views.search_disc),
path('get/release/<mbid>/', views.get_release),
path('get/release/<mbid>/recordings/', views.get_recordings_of_release),
path('release/<mbid>/', views.get_release),
path('release/<mbid>/recordings/', views.get_recordings_of_release),
path('release/<mbid>/coverart', views.get_release_group_cover_art),
path('search/release/', views.search_release),
path('coverart/release-group/<mbid>/', views.get_release_group_cover_art),
path('coverart/release/<mbid>/', views.get_release_group_cover_art),
]

130
fetcher/views.py
View File

@@ -5,72 +5,6 @@ from rest_framework.response import Response
from . import musicbrainz as mb, medium
def _get_by_mbid(request, entity_type, mbid):
includes = request.GET.get('inc', '').split('+')
if entity_type == 'artist':
response = mb.get_artist_by_mbid(mbid, includes)
elif entity_type == 'release-group':
response = mb.get_release_group_by_mbid(mbid, includes)
elif entity_type == 'release':
response = mb.get_release_by_mbid(mbid, includes)
elif entity_type == 'recording':
response = mb.get_recording_by_mbid(mbid, includes)
else:
raise ValueError('Entity Type isn\'t valid')
if 'status' in response:
return Response(response, status=response['status'])
else:
return Response(response)
def _search(request, entity_type):
query = request.GET.get('query', '')
limit = request.GET.get('limit', 25)
offset = request.GET.get('offset', 0)
if entity_type == 'artist':
response = mb.search_artist(query, limit, offset)
elif entity_type == 'release-group':
response = mb.search_release_group(query, limit, offset)
elif entity_type == 'release':
response = mb.search_release(query, limit, offset)
elif entity_type == 'recording':
response = mb.search_recording(query, limit, offset)
else:
raise ValueError('Entity Type isn\'t valid')
return Response(response)
def _browse(request, entity_type):
includes = request.GET.get('inc', '').split('+')
limit = request.GET.get('limit', 25)
offset = request.GET.get('offset', 0)
params = request.GET.copy().dict()
if 'inc' in params:
del params['inc']
if 'limit' in params:
del params['limit']
if 'offset' in params:
del params['offset']
if entity_type == 'artist':
response = mb.browse_artists(params, includes, limit, offset)
elif entity_type == 'release-group':
response = mb.browse_release_groups(params, includes, limit, offset)
elif entity_type == 'release':
response = mb.browse_releases(params, includes, limit, offset)
elif entity_type == 'recording':
response = mb.browse_recordings(params, includes, limit, offset)
else:
raise ValueError('Entity Type isn\'t valid')
return Response(response)
@api_view(['GET'])
def get_artist(request, mbid):
return Response(medium.get_artist(mbid))
@@ -115,57 +49,45 @@ def get_recordings_of_release(request, mbid):
return Response(medium.get_recordings_of_release(mbid, limit, page))
@api_view(['GET'])
def get_artist_by_mbid(request, mbid): return _get_by_mbid(request, 'artist', mbid)
def search_artist(request):
query = request.GET.get('query', '')
limit = int(request.GET.get('per_page', 10))
page = int(request.GET.get('page', 1))
return Response(medium.search_artist(query, limit, page))
@api_view(['GET'])
def get_release_group_by_mbid(request, mbid): return _get_by_mbid(request, 'release-group', mbid)
def search_disc(request):
query = request.GET.get('query', '')
limit = int(request.GET.get('per_page', 10))
page = int(request.GET.get('page', 1))
return Response(medium.search_disc(query, limit, page))
@api_view(['GET'])
def get_release_by_mbid(request, mbid): return _get_by_mbid(request, 'release', mbid)
def search_release(request):
query = request.GET.get('query', '')
limit = int(request.GET.get('per_page', 10))
page = int(request.GET.get('page', 1))
return Response(medium.search_release(query, limit, page))
@api_view(['GET'])
def get_recording_by_mbid(request, mbid): return _get_by_mbid(request, 'recording', mbid)
def search_recording(request):
query = request.GET.get('query', '')
limit = int(request.GET.get('per_page', 10))
page = int(request.GET.get('page', 1))
return Response(medium.search_release(query, limit, page))
@api_view(['GET'])
def search_artist(request): return _search(request, 'artist')
@api_view(['GET'])
def search_release_group(request): return _search(request, 'release-group')
@api_view(['GET'])
def search_release(request): return _search(request, 'release')
@api_view(['GET'])
def search_recording(request): return _search(request, 'recording')
@api_view(['GET'])
def browse_artists(request): return _browse(request, 'artist')
@api_view(['GET'])
def browse_release_groups(request): return _browse(request, 'release-group')
@api_view(['GET'])
def browse_releases(request): return _browse(request, 'release')
@api_view(['GET'])
def browse_recordings(request): return _browse(request, 'recording')
@api_view(['GET'])
def get_release_cover_art(request, mbid, size=None): return Response(mb.get_release_cover_art(mbid, size))
def get_release_cover_art(request, mbid, size=None):
return Response(mb.get_release_cover_art(mbid, size))
@api_view(['GET'])