Cache para los cover arts

Aparte hice un metodo que cambia http a https dentro de map_coverart,
porque por alguna razon cover art archive retorna sus imagenes con http
y los navegdores se quejan por esto

fetcher/cache.py

@@ -242,3 +242,25 @@ def get_artist_of_recording(mbid):
 
         _log.debug('Se encontro el artista')
         return json.loads(artist)
+
+
+def get_cover_art_disc(mbid):
+    _log.info('Intentando obtener el cover art del disco %s', mbid)
+
+    with get_redis_connection() as redis:
+        covers = redis.get(f'release_group:{mbid}:cover_art')
+        if not covers:
+            return None
+
+        return json.loads(covers)
+
+
+def get_cover_art_release(mbid):
+    _log.info('Intentando obtener el cover art de la release %s', mbid)
+
+    with get_redis_connection() as redis:
+        covers = redis.get(f'release:{mbid}:cover_art')
+        if not covers:
+            return None
+
+        return json.loads(covers)

fetcher/medium.py

@@ -4,15 +4,13 @@ Su objetivo es modificar los datos que entrega musicbrainz para que sean
 correspondientes con lo que debe entregar la api, se encarga de casos como
 traducción.
 """
-import json
 import logging
 from math import ceil
 
 from country_list import countries_for_language
+from fetcher import cache
 
 import fetcher.musicbrainz as mb
-from fetcher import jobs, cache
-from utils import get_redis_connection
 
 _log = logging.getLogger('fetcher_medium')
 _log.addHandler(logging.NullHandler())
@@ -148,13 +146,17 @@ def map_recording(mb_recording):
 
 def map_coverart(mb_cover):
     """Mapea el modelo de coverart entregado por musicbrainz a uno propio"""
+    def https(link):
+        if link:
+            return link.replace('http://', 'https://')
+
     return {
-        'image': mb_cover.get('image'),
+        'image': https(mb_cover.get('image')),
-        '1200': mb_cover.get('thumbnails', {}).get('1200'),
+        '1200': https(mb_cover.get('thumbnails', {}).get('1200')),
-        '500': mb_cover.get('thumbnails', {}).get('500'),
+        '500': https(mb_cover.get('thumbnails', {}).get('500')),
-        '250': mb_cover.get('thumbnails', {}).get('250'),
+        '250': https(mb_cover.get('thumbnails', {}).get('250')),
-        'large': mb_cover.get('thumbnails', {}).get('large'),
+        'large': https(mb_cover.get('thumbnails', {}).get('large')),
-        'small': mb_cover.get('thumbnails', {}).get('small'),
+        'small': https(mb_cover.get('thumbnails', {}).get('small')),
     }
 
 
@@ -208,7 +210,7 @@ def get_discs_of_artist(mbid, limit, page):
     if mb_discs and total:
         return {
             'paginate': paginate(total, limit, page),
-            'discs': {map_disc(disc) for disc in mb_discs}
+            'discs': [map_disc(disc) for disc in mb_discs]
         }
 
     mb_discs_browse = mb.browse_release_groups(params={'artist': mbid},
@@ -424,49 +426,34 @@ def get_artist_of_recording(mbid):
 
 def get_cover_art_disc(mbid):
     """Obtiene el cover art de un disco"""
-    with get_redis_connection() as redis:
-        mb_covers = redis.get(f'release_group:{mbid}:cover_art')
-        if mb_covers is None:
-            mb_covers = mb.get_release_group_cover_art(mbid)
-        else:
-            mb_covers = json.loads(mb_covers)
 
-        if 'error' in mb_covers:
+    mb_covers = cache.get_cover_art_disc(mbid)
-            return None
+    if mb_covers:
+        return map_coverart(find_best_cover(mb_covers))
 
-        jobs.load_entities_of_release_group.delay(mbid)
+    mb_covers = mb.get_release_group_cover_art(mbid)
-        cover_art = map_coverart(find_best_cover(mb_covers))
 
-        return cover_art
+    if 'error' in mb_covers:
+        _log.error('Error al cargar cover %s', mb_covers)
+        return None
+
+    return map_coverart(find_best_cover(mb_covers))
 
 
 def get_cover_art_release(mbid):
     """Obtiene el cover art de una release"""
-    with get_redis_connection() as redis:
-        mb_covers = redis.get(f'release:{mbid}:cover_art')
 
-        if mb_covers is None:
+    mb_covers = cache.get_cover_art_release(mbid)
-            mb_covers = mb.get_release_cover_art(mbid)
+    if mb_covers:
-        else:
+        return map_coverart(find_best_cover(mb_covers))
-            mb_covers = json.loads(mb_covers)
 
-        if 'error' in mb_covers:
+    mb_covers = mb.get_release_cover_art(mbid)
-            return None
 
-        jobs.load_entities_of_release.delay(mbid)
+    if 'error' in mb_covers:
-        cover_art = map_coverart(find_best_cover(mb_covers))
+        _log.error('Error al cargar cover %s', mb_covers)
-
-        return cover_art
-
-
-def get_cover_art_recording(mbid):
-    """Obtiene el cover art de una grabacion"""
-    release = get_releases_of_recording(mbid, limit=1, page=1)[0]
-
-    if 'error' in release:
         return None
 
-    return get_cover_art_release(release['releases'][0]['id'])
+    return map_coverart(find_best_cover(mb_covers))
 
 
 ##