Volver a py-redis

Resulta que django-redis es muy bonito pero esta pensado para usarse
como el cache por default de django, remplazando a memcached y por eso
no permite casi ninguna de las funcionalidades que redis permite, como
usar listas y sets.
Djang-redis permite usar el cliente directamente pero el codigo se
estaba haciendo largo y creando mas problemas de los que necesito
Asi que voy a usar el cliente regular, asi me evito dramas

fetcher/medium.py

@@ -7,13 +7,11 @@ traducción.
 import json
 from math import ceil
 
-from django.core.cache import cache
-from django_redis import get_redis_connection
 from country_list import countries_for_language
 
 import fetcher.musicbrainz as mb
 from fetcher import jobs
-from utils import make_key
+from utils import get_redis_connection
 
 
 ###
@@ -155,33 +153,38 @@ def map_coverart(mb_cover):
 def get_artist(mbid):
     """Obtiene un artista desde musicbrainz incluyendo sus tags"""
 
-    mb_artist = cache.get(f'artist_{mbid}')
-    if mb_artist is None:
-        mb_artist = mb.get_artist_by_mbid(mbid, includes=['tags'])
-    else:
-        mb_artist = json.loads(mb_artist)
-    if 'error' in mb_artist:
-        return mb_artist
+    with get_redis_connection() as redis:
+        mb_artist = redis.get(f'artist_{mbid}')
+        if mb_artist is None:
+            mb_artist = mb.get_artist_by_mbid(mbid, includes=['tags'])
+        else:
+            mb_artist = json.loads(mb_artist)
 
-    jobs.load_artist_on_cache.delay(mbid)
+        if 'error' in mb_artist:
+            return mb_artist
 
-    return map_artist(mb_artist)
+        jobs.load_artist_on_cache.delay(mbid)
+
+        return map_artist(mb_artist)
 
 
 def get_disc(mbid):
     """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
 
-    jobs.load_entities_of_release_group.delay(mbid)
-    disc = map_disc(mb_disc)
+    with get_redis_connection() as redis:
+        mb_disc = redis.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)
 
-    return disc
+        if 'error' in mb_disc:
+            return mb_disc
+
+        jobs.load_entities_of_release_group.delay(mbid)
+        disc = map_disc(mb_disc)
+
+        return disc
 
 
 def get_discs_of_artist(mbid):
@@ -189,10 +192,10 @@ def get_discs_of_artist(mbid):
 
     mb_discs = []
 
-    with get_redis_connection("default") as raw_cache:
-        if raw_cache.exists(make_key(f'artist_{mbid}:release_group_count')) == 1:
-            mb_discs_ids = raw_cache.lrange(make_key(f'artist_{mbid}:release_groups'), 0, -1)
-            mb_discs = [get_disc(str(mbid, 'utf-8')) for mbid in mb_discs_ids]
+    with get_redis_connection() as redis:
+        if f'artist_{mbid}:release_group_count' in redis:
+            mb_discs_ids = redis.lrange(f'artist_{mbid}:release_groups', 0, -1)
+            mb_discs = [get_disc(mbid) for mbid in mb_discs_ids]
 
     if len(mb_discs) == 0:
         jobs.load_artist_on_cache.delay(mbid)
@@ -204,7 +207,7 @@ def get_discs_of_artist(mbid):
             if 'error' in mb_discs_browse:
                 return mb_discs_browse
 
-            mb_discs.extend(*mb_discs_browse.get('release_groups'))
+            mb_discs.extend(mb_discs_browse.get('release_groups'))
 
             offset += 100
             if offset > mb_discs_browse.get('release_group_count'):
@@ -217,7 +220,8 @@ def get_discs_of_artist(mbid):
 
 def get_artist_of_disc(mbid, limit, page):
     """Obtiene el artista de un disco"""
-    mb_artists = mb.browse_artists(params={'disc': mbid}, limit=limit, offset=limit * (page - 1))
+    mb_artists = mb.browse_artists(params={'release-group': mbid},
+                                   limit=limit, offset=limit * (page - 1))
 
     if 'error' in mb_artists:
         return mb_artists
@@ -234,18 +238,19 @@ 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
+    with get_redis_connection() as redis:
+        mb_release = redis.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
 
-    jobs.load_entities_of_release.delay(mbid)
-    release = map_release(mb_release)
+        jobs.load_entities_of_release.delay(mbid)
+        release = map_release(mb_release)
 
-    return release
+        return release
 
 
 def get_releases_of_disc(mbid, limit, page):
@@ -345,19 +350,20 @@ 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.loads(mb_covers)
+    with get_redis_connection() as redis:
+        mb_covers = redis.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.loads(mb_covers)
 
-    if 'error' in mb_covers:
-        return None
+        if 'error' in mb_covers:
+            return None
 
-    jobs.load_entities_of_release_group.delay(mbid)
-    cover_art = map_coverart(find_best_cover(mb_covers))
+        jobs.load_entities_of_release_group.delay(mbid)
+        cover_art = map_coverart(find_best_cover(mb_covers))
 
-    return cover_art
+        return cover_art
 
 
 def get_cover_art_release(mbid):