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

Definidos jobs basicos y comunicacion con estos

Browse Source
This commit is contained in:
Daniel Cortes
2020-06-08 16:56:14 -04:00
parent 90c34dada3
commit ac58e29c75
2 changed files with 136 additions and 31 deletions
Download Patch File Download Diff File Expand all files Collapse all files

102
fetcher/jobs.py
View File

@@ -12,27 +12,109 @@ _log.addHandler(logging.NullHandler())
@django_rq.job
def load_entities_of_release_group(mbid): # pylint: disable=unused-argument
"""Carga en cache un release group y sus entidades relacionadas"""
def load_entities_of_recording(recording):
"""Carga en cache una grabacion y sus entidades relacionadas"""
mbid = recording
if isinstance(recording, dict):
mbid = recording.get('id')
if cache.ttl(f'recording_{mbid}') is None:
_log.info('La recording ya se habia procesado anteriormente')
return
if isinstance(recording, str):
recording = mb.get_recording_by_mbid(mbid)
cache.set(f'recording_{mbid}', json.dumps(recording), timeout=None)
_log.info('Recording %s fue almacenada correctamente', mbid)
@django_rq.job
def load_artist_on_cache(mbid):
"""Carga en cache a un artista y todas sus entidades"""
def load_entities_of_release(release):
"""Carga en cache una release y sus entidades relacionadas"""
mbid = release
if isinstance(release, dict):
mbid = release.get('id')
if cache.ttl(f'artist_{mbid}') != 0:
_log.info('El artista ya se habia procesado anteriormente')
if cache.ttl(f'release_{mbid}') is None:
_log.info('La release ya se habia procesado anteriormente')
return
artista = mb.get_artist_by_mbid(mbid, includes=['tags'])
cache.set(f'artist_{mbid}', json.dumps(artista))
if isinstance(release, str):
release = mb.get_release_by_mbid(mbid)
cache.set(f'release_{mbid}', json.dumps(release), timeout=None)
_log.info('Release %s fue almacenada en cache', mbid)
cover_art = mb.get_release_cover_art(mbid)
cache.set(f'release_cover_art_{mbid}', json.dumps(cover_art), timeout=None)
_log.info('Cover art de release %s almacenada en cache', mbid)
offset = 0
while True:
recordings = mb.browse_recordings({'release': mbid}, limit=100, offset=offset)
for recording in recordings.get('recordings'):
load_entities_of_recording(recording)
offset += 100
if offset > recordings.get('recording_count', 0):
break
@django_rq.job
def load_entities_of_release_group(release_group):
"""Carga en cache un release group y sus entidades relacionadas"""
mbid = release_group
if isinstance(release_group, dict):
mbid = release_group.get('id')
if cache.ttl(f'release_group_{mbid}') is None:
_log.info('La release group ya se habia procesado anteriormente')
return
if isinstance(release_group, str):
release_group = mb.get_release_group_by_mbid(mbid)
cache.set(f'release_group_{mbid}', json.dumps(release_group), timeout=None)
_log.info('Release Group %s almacenado en cache', mbid)
cover_art = mb.get_release_group_cover_art(mbid)
cache.set(f'release_group_cover_art_{mbid}', json.dumps(cover_art), timeout=None)
_log.info('Cover art de release group %s almacenada en cache', mbid)
offset = 0
while True:
releases = mb.browse_releases({'release-group': mbid}, limit=100, offset=offset)
for release in releases.get('releases'):
load_entities_of_release(release)
offset += 100
if offset > releases.get('release_count', 0):
break
@django_rq.job
def load_artist_on_cache(artist):
"""Carga en cache a un artista y todas sus entidades"""
mbid = artist
if isinstance(artist, dict):
mbid = artist.get('id')
if cache.ttl(f'artist_{mbid}') is None:
_log.info('El artista ya se había procesado anteriormente')
return
if isinstance(artist, str):
artist = mb.get_artist_by_mbid(mbid, includes=['tags'])
cache.set(f'artist_{mbid}', json.dumps(artist), timeout=None)
_log.info('Artista %s almacenado en cache', mbid)
offset = 0
while True:
release_groups = mb.browse_release_groups({'artist': mbid}, limit=100, offset=offset)
for basic_release_group in release_groups.get('release_groups'):
load_entities_of_release_group(basic_release_group.get('id'))
for release_group in release_groups.get('release_groups'):
load_entities_of_release_group.delay(release_group)
offset += 100
if offset > release_groups.get('release_group_count', 0):

65
fetcher/medium.py
View File

@@ -99,7 +99,6 @@ def map_disc(mb_disc, cover_art=None):
'first_release_date': mb_disc.get('first_release_date'),
'primary_type': mb_disc.get('primary_type'),
'cover_art': cover_art,
'artist': [map_artist_credit(c) for c in mb_disc.get('artist_credit')]
}
if len(mb_disc.get('secondary_types', [])) > 0:
@@ -118,7 +117,6 @@ def map_release(mb_release, cover_art=None):
'country': mb_release.get('country'),
'date': mb_release.get('date'),
'cover_art': cover_art,
'artist': [map_artist_credit(c) for c in mb_release.get('artist_credit')]
}
@@ -129,7 +127,6 @@ def map_recording(mb_recording):
'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')]
}
@@ -170,13 +167,19 @@ def get_artist(mbid):
def get_disc(mbid):
"""Obtiene un disco desde musicbrainz incluyendo sus artistas"""
mb_disc = mb.get_release_group_by_mbid(mbid, includes=['artists'])
"""Obtiene un disco desde musicbrainz"""
mb_disc = cache.get(f'release_group_{mbid}')
if mb_disc is None:
mb_disc = mb.get_release_group_by_mbid(mbid)
else:
mb_disc = json.loads(mb_disc)
if 'error' in mb_disc:
return mb_disc
return map_disc(mb_disc)
jobs.load_entities_of_release_group.delay(mbid)
disc = map_disc(mb_disc)
return disc
def get_discs_of_artist(mbid, limit, page):
@@ -212,12 +215,18 @@ def get_artist_of_disc(mbid, limit, page):
def get_release(mbid):
"""Obtiene una release desde musicbrainz incluyendo sus artistas"""
mb_release = mb.get_release_by_mbid(mbid, includes=['artists'])
mb_release = cache.get(f'release_{mbid}')
if mb_release is None:
mb_release = mb.get_release_by_mbid(mbid, includes=['artists'])
else:
mb_release = json.loads(mb_release)
if 'error' in mb_release:
return mb_release
return map_release(mb_release)
jobs.load_entities_of_release.delay(mbid)
release = map_release(mb_release)
return release
def get_releases_of_disc(mbid, limit, page):
@@ -253,13 +262,19 @@ def get_artist_of_release(mbid, limit, page):
def get_recording(mbid):
"""Obtiene una grabacion incluyendo a su artista"""
mb_recording = mb.get_recording_by_mbid(mbid, includes=['artists'])
"""Obtiene una grabación incluyendo a su artista"""
mb_recording = mb.get_recording_by_mbid(mbid)
if mb_recording is None:
mb_recording = mb.get_recording_by_mbid(mbid)
else:
mb_recording = json.loads(mb_recording)
if 'error' in mb_recording:
return mb_recording
return map_recording(mb_recording)
jobs.load_entities_of_recording.delay(mb_recording)
recording = map_recording(mb_recording)
return recording
def get_recordings_of_release(mbid, limit, page):
@@ -311,28 +326,36 @@ def get_artist_of_recording(mbid, limit, page):
def get_cover_art_disc(mbid):
"""Obtiene el cover art de un disco"""
mb_covers = mb.get_release_group_cover_art(mbid)
mb_covers = cache.get(f'release_group_cover_art_{mbid}')
if mb_covers is None:
mb_covers = mb.get_release_group_cover_art(mbid)
else:
mb_covers = json.load(mb_covers)
if 'error' in mb_covers:
return None
if len(mb_covers.get('images', [])) == 1:
return map_coverart(mb_covers.get('images')[0])
jobs.load_entities_of_release_group.delay(mbid)
cover_art = map_coverart(find_best_cover(mb_covers))
return map_coverart(find_best_cover(mb_covers))
return cover_art
def get_cover_art_release(mbid):
"""Obtiene el cover art de una release"""
mb_covers = mb.get_release_cover_art(mbid)
if mb_covers is None:
mb_covers = mb.get_release_cover_art(mbid)
else:
mb_covers = json.loads(mb_covers)
if 'error' in mb_covers:
return None
if len(mb_covers.get('images', [])) == 1:
return map_coverart(mb_covers.get('images')[0])
jobs.load_entities_of_release.delay(mbid)
cover_art = map_coverart(find_best_cover(mb_covers))
return map_coverart(find_best_cover(mb_covers))
return cover_art
def get_cover_art_recording(mbid):