Definidos jobs basicos y comunicacion con estos

fetcher/jobs.py

@@ -12,27 +12,109 @@ _log.addHandler(logging.NullHandler())
 
 
 @django_rq.job
-def load_entities_of_release_group(mbid):  # pylint: disable=unused-argument
+def load_entities_of_recording(recording):
-    """Carga en cache un release group y sus entidades relacionadas"""
+    """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):
+def load_entities_of_release(release):
-    """Carga en cache a un artista y todas sus entidades"""
+    """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:
+    if cache.ttl(f'release_{mbid}') is None:
-        _log.info('El artista ya se habia procesado anteriormente')
+        _log.info('La release ya se habia procesado anteriormente')
         return
 
-    artista = mb.get_artist_by_mbid(mbid, includes=['tags'])
+    if isinstance(release, str):
-    cache.set(f'artist_{mbid}', json.dumps(artista))
+        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'):
+        for release_group in release_groups.get('release_groups'):
-            load_entities_of_release_group(basic_release_group.get('id'))
+            load_entities_of_release_group.delay(release_group)
 
         offset += 100
         if offset > release_groups.get('release_group_count', 0):

fetcher/medium.py

@@ -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"""
+    """Obtiene un disco desde musicbrainz"""
-    mb_disc = mb.get_release_group_by_mbid(mbid, includes=['artists'])
+    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 = 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"""
+    """Obtiene una grabación incluyendo a su artista"""
-    mb_recording = mb.get_recording_by_mbid(mbid, includes=['artists'])
+    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 = 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:
+    jobs.load_entities_of_release_group.delay(mbid)
-        return map_coverart(mb_covers.get('images')[0])
+    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:
+    jobs.load_entities_of_release.delay(mbid)
-        return map_coverart(mb_covers.get('images')[0])
+    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):