276 lines
9.7 KiB
Python
276 lines
9.7 KiB
Python
import json
|
|
import logging
|
|
|
|
from fetcher import jobs
|
|
from utils import get_redis_connection
|
|
|
|
_log = logging.getLogger('fetcher_cache')
|
|
_log.addHandler(logging.NullHandler())
|
|
|
|
|
|
def get_artist(mbid):
|
|
_log.info('Intentando obtener artista %s desde redis', mbid)
|
|
|
|
with get_redis_connection() as redis:
|
|
artist = redis.get(f'artist:{mbid}')
|
|
if not artist:
|
|
_log.info('El artista no estaba en redis')
|
|
jobs.load_artist_on_cache.delay(mbid)
|
|
return None
|
|
|
|
_log.info('El artista se encontro en redis')
|
|
return json.loads(artist)
|
|
|
|
|
|
def get_disc(mbid):
|
|
_log.info('Intentando obtener disco %s desde redis', mbid)
|
|
with get_redis_connection() as redis:
|
|
disc = redis.get(f'release_group:{mbid}')
|
|
if not disc:
|
|
_log.info('El disco no estaba en redis')
|
|
jobs.load_entities_of_release_group.delay(mbid)
|
|
return None
|
|
|
|
_log.info('El disco se encontro en redis')
|
|
return json.loads(disc)
|
|
|
|
|
|
def get_discs_of_artist(mbid, limit, offset):
|
|
_log.info('Intentando obtener los discos del arista %s', mbid)
|
|
|
|
with get_redis_connection() as redis:
|
|
key_releases = f'artist:{mbid}:release_groups'
|
|
|
|
if key_releases not in redis:
|
|
_log.debug('%s no existe en redis', key_releases)
|
|
jobs.load_artist_on_cache.delay(mbid)
|
|
return None, 0
|
|
|
|
count = int(redis.get(f'{key_releases}:count'))
|
|
if count != redis.zcard(key_releases):
|
|
_log.debug('La cantidad de release_groups del artista %s no coinciden con el total',
|
|
mbid)
|
|
jobs.load_artist_on_cache.delay(mbid)
|
|
return None, 0
|
|
|
|
release_ids = redis.zrange(key_releases, offset, offset + limit - 1)
|
|
keys = [f'release_group:{mbid}' for mbid in release_ids]
|
|
if redis.exists(*keys) != len(keys):
|
|
_log.debug('Aun no se cargan todas las release_groups del artista %s', mbid)
|
|
jobs.load_artist_on_cache.delay(mbid)
|
|
return None, 0
|
|
|
|
_log.info('Se encontraron los discos en redis')
|
|
return [json.loads(disc) for disc in redis.mget(keys)], count
|
|
|
|
|
|
def get_artist_of_disc(mbid):
|
|
_log.info('Intentando obtener el artista del disco %s en redis', mbid)
|
|
|
|
with get_redis_connection() as redis:
|
|
artist_id = redis.get(f'release_group:{mbid}:artist')
|
|
if not artist_id:
|
|
_log.debug('No se encontro el artista')
|
|
jobs.load_entities_of_release_group.delay(mbid)
|
|
return None
|
|
|
|
_log.debug('Se encontro el artista')
|
|
return json.loads(redis.get(f'artist:{artist_id}'))
|
|
|
|
|
|
def get_release(mbid):
|
|
_log.info('Intentado obtener la release %s en redis', mbid)
|
|
|
|
with get_redis_connection() as redis:
|
|
release = redis.get(f'release:{mbid}')
|
|
if not release:
|
|
_log.info('La release no estaba en redis')
|
|
jobs.load_entities_of_release.delay(mbid)
|
|
return None
|
|
|
|
return json.loads(release)
|
|
|
|
|
|
def get_releases_of_disc(mbid, limit, offset):
|
|
_log.info('Intentando obtener las releases del disco %s', mbid)
|
|
|
|
with get_redis_connection() as redis:
|
|
key_releases = f'release_group:{mbid}:releases'
|
|
|
|
if key_releases not in redis:
|
|
_log.debug('%s no existe en redis', key_releases)
|
|
jobs.load_entities_of_release_group.delay(mbid)
|
|
return None, 0
|
|
|
|
count = int(redis.get(f'{key_releases}:count'))
|
|
if count != redis.zcard(key_releases):
|
|
_log.debug('La cantidad de releases del disco %s no coinciden con el total', mbid)
|
|
jobs.load_entities_of_release_group.delay(mbid)
|
|
return None, 0
|
|
|
|
release_ids = redis.zrange(key_releases, offset, offset + limit - 1)
|
|
keys = [f'release:{mbid}' for mbid in release_ids]
|
|
if redis.exists(*keys) != len(keys):
|
|
_log.debug('Aun no se cargan todas las releases del disco %s', mbid)
|
|
jobs.load_entities_of_release_group.delay(mbid)
|
|
return None, 0
|
|
|
|
_log.info('Se encontraron las releases en redis')
|
|
return [json.loads(disc) for disc in redis.mget(keys)], count
|
|
|
|
|
|
def get_artist_of_release(mbid):
|
|
_log.info('Intentando obtener al artista de la release %s en redis', mbid)
|
|
|
|
with get_redis_connection() as redis:
|
|
artist_id = redis.get(f'release:{mbid}:artist')
|
|
if not artist_id:
|
|
_log.debug('No se encontro el artista')
|
|
jobs.load_entities_of_release.delay(mbid)
|
|
return None
|
|
|
|
artist = redis.get(f'artist:{artist_id}')
|
|
if not artist:
|
|
_log.debug('El artista aun no se carga en redis')
|
|
jobs.load_entities_of_release.delay(mbid)
|
|
return None
|
|
|
|
_log.debug('Se encontro el artista')
|
|
return json.loads(artist)
|
|
|
|
|
|
def get_recording(mbid):
|
|
_log.info('Intentado obtener la grabacion %s en redis', mbid)
|
|
|
|
with get_redis_connection() as redis:
|
|
recording = redis.get(f'recording:{mbid}')
|
|
if not recording:
|
|
_log.info('La grabacion no estaba en redis')
|
|
jobs.load_entities_of_recording.delay(mbid)
|
|
return None
|
|
|
|
return json.loads(recording)
|
|
|
|
|
|
def get_recordings_of_release(mbid):
|
|
_log.info('Intentando obtener las grabaciones de la release %s', mbid)
|
|
|
|
with get_redis_connection() as redis:
|
|
medias_key = f'release:{mbid}:media'
|
|
|
|
if medias_key not in redis:
|
|
_log.debug('%s no existe en redis', medias_key)
|
|
jobs.load_entities_of_release.delay(mbid)
|
|
return None
|
|
|
|
media_count = int(redis.get(f'{medias_key}:count'))
|
|
if redis.zcard(medias_key) != media_count:
|
|
_log.debug('La cantidad de medias de la release %s no coinciden con el total', mbid)
|
|
jobs.load_entities_of_release.delay(mbid)
|
|
return None
|
|
|
|
medias = [json.loads(media) for media in redis.zrange(medias_key, 0, -1)]
|
|
for media in medias:
|
|
recordings_key = f'{medias_key}:{media.get("position")}:recordings'
|
|
if recordings_key not in redis:
|
|
_log.debug('%s no existe en redis', medias_key)
|
|
jobs.load_entities_of_release.delay(mbid)
|
|
return None
|
|
|
|
if f'{recordings_key}:count' not in redis:
|
|
_log.debug('%s no existe en redis', f'{recordings_key}:count')
|
|
jobs.load_entities_of_release.delay(mbid)
|
|
return None
|
|
|
|
recordings_count = int(redis.get(f'{recordings_key}:count'))
|
|
if redis.zcard(recordings_key) != recordings_count:
|
|
_log.debug('La cantidad de recordings de la media %s no coinciden con el total',
|
|
mbid)
|
|
jobs.load_entities_of_release.delay(mbid)
|
|
return None
|
|
|
|
recording_ids = redis.zrange(recordings_key, 0, -1)
|
|
keys = [f'recording:{mbid}' for mbid in recording_ids]
|
|
if redis.exists(*keys) != len(keys):
|
|
_log.debug('No estan todos los recordings almacenados')
|
|
jobs.load_entities_of_release.delay(mbid)
|
|
return None
|
|
|
|
media['recordings'] = []
|
|
for key in keys:
|
|
recording = json.loads(redis.get(key))
|
|
media['recordings'].append(recording)
|
|
|
|
return medias
|
|
|
|
|
|
def get_releases_of_recording(mbid, limit, offset):
|
|
_log.info('Intentando obtener la release de la recording %s', mbid)
|
|
|
|
with get_redis_connection() as redis:
|
|
releases_key = f'recording:{mbid}:release'
|
|
if releases_key not in redis or f'{releases_key}:count' not in redis:
|
|
_log.debug('No existe %s en redis', releases_key)
|
|
jobs.load_entities_of_recording.delay(mbid)
|
|
return None, 0
|
|
|
|
count = int(redis.get(f'{releases_key}:count'))
|
|
if redis.zcard(releases_key) != count:
|
|
_log.debug('No estan almacenadas todas las keys de las releases')
|
|
jobs.load_entities_of_recording.delay(mbid)
|
|
return None, 0
|
|
|
|
release_ids = redis.zrange(releases_key, offset, offset + limit - 1)
|
|
keys = [f'release:{mbid}' for mbid in release_ids]
|
|
if redis.exists(*keys) != len(keys):
|
|
_log.debug('No estan todas las releses')
|
|
jobs.load_entities_of_recording.delay(mbid)
|
|
return None, 0
|
|
|
|
_log.debug('Se encontraron las releases en redis')
|
|
return [json.loads(release) for release in redis.mget(keys)], count
|
|
|
|
|
|
def get_artist_of_recording(mbid):
|
|
_log.info('Intentando obtener el artista de la grabacion %s desde redis', mbid)
|
|
|
|
with get_redis_connection() as redis:
|
|
artist_id = redis.get(f'recording:{mbid}:artist')
|
|
if not artist_id:
|
|
_log.debug('El artista no se encuentra en redis')
|
|
jobs.load_entities_of_recording.delay(mbid)
|
|
return None
|
|
|
|
artist = redis.get(f'artist:{artist_id}')
|
|
if not artist:
|
|
_log.debug('El artista aun no se carga en redis')
|
|
jobs.load_entities_of_recording.delay(mbid)
|
|
return None
|
|
|
|
_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:
|
|
jobs.load_entities_of_release_group.delay(mbid)
|
|
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:
|
|
jobs.load_entities_of_release.delay(mbid)
|
|
return None
|
|
|
|
return json.loads(covers)
|