def get_album_ids(name, artist_id, artist_name):
"""Find the first and latest IDs of an album by its name and its artist ID.
Artist name is for error output.
"""
albums_list = [
album for album in musicbrainzngs.search_releases(
query=name, arid=artist_id)["release-list"]
if remove_forbidden_characters(custom_replace_title(album["title"])).
lower() == name.lower() and "date" in album and album["date"]
]
if not albums_list:
raise ValueError(f"Album {name} not literally found by artist "
f"{artist_name}")
albums_list = sorted(albums_list, key=lambda a: a["date"])
use_for_cover = None
for album in reversed(albums_list):
try:
musicbrainzngs.get_image_list(album["id"])
use_for_cover = album
break
except musicbrainzngs.musicbrainz.ResponseError:
continue
if use_for_cover is None:
raise ValueError(f"No cover art available for {name} by "
f"{artist_name}, this is unsupported behaviour")
else:
return albums_list[0]["id"], use_for_cover["id"]
def _get_cover_art(self, album_id):
try:
if album_id in self._cover_art_cache:
return self._cover_art_cache[album_id]
else:
if self.small_cover_art:
self._cover_art_cache[album_id] = \
musicbrainzngs.get_image_list(album_id)['images'][0]['thumbnails'][
'small']
else:
self._cover_art_cache[album_id] = musicbrainzngs.get_image_list(album_id)[
'images'][0]['image']
return self._cover_art_cache[album_id]
except musicbrainzngs.musicbrainz.ResponseError:
return None
def get_coverart(self, album):
path = "app/static/media/"
filename = "%s.jpg" % album.id
musicbrainzngs.set_useragent("python-musicplayer-flask","0.1","*****@*****.**")
covers = cache.get('covers')
if album.id in covers:
return
covers.append(album.id)
cache.set("covers", covers)
if not album.musicbrainz_albumid or album.coverimage:
return
#raise NameError('musicbrainz_albumid not set')
try:
data = musicbrainzngs.get_image_list(album.musicbrainz_albumid)
except Exception as e:
return e
if len(data['images']) == 0:
raise NameError('No images returned from service')
urllib.request.urlretrieve(data['images'][0]['image'], "%s%s" % (path, filename))
ci = open("%s%s" % (path, filename), 'rb')
album.coverimage.put(ci, content_type = 'image/jpeg')
return
def find_coverart(release):
from lxml import etree
root = etree.XML(u'<coverart></coverart>')
try:
data = musicbrainzngs.get_image_list(release)
except musicbrainzngs.ResponseError as err:
if err.cause.code == 404:
etree.SubElement(root, "error").text = "Release ID not found"
log(True, convert_etree(etree.tostring(root, encoding='UTF-8', pretty_print=True, xml_declaration=True)))
sys.exit(1)
else:
etree.SubElement(root, "error").text = "Received bad response from the MB server"
log(True, convert_etree(etree.tostring(root, encoding='UTF-8', pretty_print=True, xml_declaration=True)))
sys.exit(1)
if debug:
pprint.pprint(data)
for image in data["images"]:
imageNode = etree.SubElement(root, "image")
etree.SubElement(imageNode, "image").text = image["image"]
etree.SubElement(imageNode, "approved").text = str(image["approved"])
etree.SubElement(imageNode, "front").text = str(image["front"])
etree.SubElement(imageNode, "back").text = str(image["back"])
#etree.SubElement(imageNode, "types").text = image["types"]
etree.SubElement(imageNode, "thumb-small").text = image["thumbnails"]["small"]
etree.SubElement(imageNode, "thumb-large").text = image["thumbnails"]["large"]
log(True, convert_etree(etree.tostring(root, encoding='UTF-8', pretty_print=True, xml_declaration=True)))
sys.exit(0)
def get_coverart(self, album):
path = "app/static/media/"
filename = "%s.jpg" % album.id
musicbrainzngs.set_useragent("python-musicplayer-flask", "0.1",
"*****@*****.**")
covers = cache.get('covers')
if album.id in covers:
return
covers.append(album.id)
cache.set("covers", covers)
if not album.musicbrainz_albumid or album.coverimage:
return
#raise NameError('musicbrainz_albumid not set')
try:
data = musicbrainzngs.get_image_list(album.musicbrainz_albumid)
except Exception as e:
return e
if len(data['images']) == 0:
raise NameError('No images returned from service')
urllib.request.urlretrieve(data['images'][0]['image'],
"%s%s" % (path, filename))
ci = open("%s%s" % (path, filename), 'rb')
album.coverimage.put(ci, content_type='image/jpeg')
return
async def toptrack(self, ctx, username):
payload = {
"method": "user.gettoptracks",
"user": username,
"period": "overall",
"limit": "1"
}
trackdata = self.api(payload)
response = discord.Embed(title="toptrack")
if "error" in trackdata:
response.add_field(name="Failed to load top track",
value=trackdata["message"])
await ctx.send(embed=response)
return
toptrack = trackdata["toptracks"]["track"][0]
response.add_field(name="{0}'s top track".format(username),
value="{0} - {1}".format(toptrack["artist"]["name"],
toptrack["name"]))
recording = musicbrainzngs.search_recordings(tid=toptrack["mbid"])
recording = recording["recording-list"][0]
release = recording["release-list"][0]
imgs = musicbrainzngs.get_image_list(release["id"])
url = requests.get(imgs["images"][0]["thumbnails"]["small"])
url = url.url
response.set_thumbnail(url=url)
await ctx.send(embed=response)
def find_coverart(release):
from lxml import etree
root = etree.XML(u'<coverart></coverart>')
try:
data = musicbrainzngs.get_image_list(release)
except musicbrainzngs.ResponseError as err:
if err.cause.code == 404:
etree.SubElement(root, "error").text = "Release ID not found"
log(True, etree.tostring(root, encoding='UTF-8', pretty_print=True, xml_declaration=True))
sys.exit(1)
else:
etree.SubElement(root, "error").text = "Received bad response from the MB server"
log(True, etree.tostring(root, encoding='UTF-8', pretty_print=True, xml_declaration=True))
sys.exit(1)
if debug:
pprint.pprint(data)
for image in data["images"]:
imageNode = etree.SubElement(root, "image")
etree.SubElement(imageNode, "image").text = image["image"]
etree.SubElement(imageNode, "approved").text = str(image["approved"])
etree.SubElement(imageNode, "front").text = str(image["front"])
etree.SubElement(imageNode, "back").text = str(image["back"])
#etree.SubElement(imageNode, "types").text = image["types"]
etree.SubElement(imageNode, "thumb-small").text = image["thumbnails"]["small"]
etree.SubElement(imageNode, "thumb-large").text = image["thumbnails"]["large"]
log(True, etree.tostring(root, encoding='UTF-8', pretty_print=True, xml_declaration=True))
sys.exit(0)
def get_taggable_information(album_ids):
"""Find the songs, release year, and coverartarchive.org URL of an album
by its ID.
"""
album_dict = musicbrainzngs.get_release_by_id(id=album_ids[0],
includes="recordings")
image_dict = musicbrainzngs.get_image_list(album_ids[1])
taggable_information = {}
taggable_information["year"] = re.sub(r"([0-9]{4})(-[0-9]{2}){2}", r"\1",
album_dict["release"]["date"])
discs = album_dict["release"]["medium-list"]
taggable_information["tracks"] = []
for disc in sorted(discs, key=lambda disc: int(disc["position"])):
for song in sorted(disc["track-list"],
key=lambda song: int(song["position"])):
if "title" in song:
title = song["title"]
else:
title = song["recording"]["title"]
taggable_information["tracks"].append(custom_replace_title(title))
for image in image_dict["images"]:
if "Front" in image["types"]:
taggable_information["image_url"] = image["image"]
return taggable_information
def handle(self, **options):
musicbrainzngs.set_useragent(settings.MB_APP, settings.MB_VERSION, settings.MB_CONTACT)
if options['full']:
albums = Album.objects.filter(image='')
else:
albums = Album.objects.filter(is_get_image=False)
for album in albums:
print 'ALBUM: ', album
for release in album.releases.all():
try:
data = musicbrainzngs.get_image_list(release.mbid)
url = ''
for image in data['images']:
if 'Front' in image['types'] and image['approved']:
url = image['thumbnails']['large']
if url:
print '+'
album.image = url
break
except musicbrainzngs.musicbrainz.ResponseError:
pass
if not album.image:
print '-'
album.is_get_image = True
album.save()
print 'FINISHED'
def get_more_data(song):
"""Get extra data for the song like cover art"""
id = song.release_id
cover_art = musicbrainzngs.get_image_list(id)
song.artwork_url_100 = cover_art["images"][0]["image"]
return song
def get_release_cover(release_id):
try:
data = musicbrainzngs.get_image_list(release_id)
except musicbrainzngs.musicbrainz.ResponseError:
return None
for image in data["images"]:
if "Front" in image["types"] and image["approved"]:
return image["thumbnails"]["large"]
def coverart_test(release_id):
data = musicbrainzngs.get_image_list(
"46a48e90-819b-4bed-81fa-5ca8aa33fbf3")
print(data, '\n')
for image in data["images"]:
if "Front" in image["types"] and image["approved"]:
print("%s is an approved front image!" %
image["thumbnails"]["large"])
break
def parse_cover_url(self, soup):
if soup["cover-art-archive"] and soup["cover-art-archive"]["front"] == "true":
try:
r = musicbrainzngs.get_image_list(soup["id"])
except musicbrainzngs.musicbrainz.ResponseError:
return None
for image in r["images"]:
if image["approved"] and image["front"]:
return image["image"]
return None
def get_albumart(self, snapmeta, cached):
album_key = 'musicbrainzAlbumId'
track_key = self.__track_key(snapmeta)
album_art = self._album_art_map.get(track_key)
if album_art is not None:
if album_art == '':
return None
else:
return album_art
if cached:
return None
self._album_art_map[track_key] = ''
try:
if not album_key in snapmeta:
mbartist = None
mbrelease = None
if 'artist' in snapmeta:
mbartist = snapmeta['artist'][0]
if 'album' in snapmeta:
mbrelease = snapmeta['album']
else:
if 'title' in snapmeta:
mbrelease = snapmeta['title']
if mbartist is not None and mbrelease is not None:
logger.info(
f'Querying album art for artist "{mbartist}", release: "{mbrelease}"'
)
result = musicbrainzngs.search_releases(artist=mbartist,
release=mbrelease,
limit=1)
if result['release-list']:
snapmeta[album_key] = result['release-list'][0]['id']
if album_key in snapmeta:
data = musicbrainzngs.get_image_list(snapmeta[album_key])
for image in data["images"]:
if "Front" in image["types"] and image["approved"]:
album_art = image["thumbnails"]["small"]
logger.debug(f'{album_art} is an approved front image')
self._album_art_map[track_key] = album_art
break
except musicbrainzngs.musicbrainz.ResponseError as e:
logger.error(
f'Error while getting cover for {snapmeta[album_key]}: {e}')
album_art = self._album_art_map[track_key]
if album_art == '':
return None
return album_art
def get_image_uri(self, release_id):
try:
# print(("look art at ID", release_id)
data = musicbrainzngs.get_image_list(release_id)
print(data, '\n')
for image in data["images"]:
if "Front" in image["types"] and image["approved"]:
print( "%s is an approved front image!" % image["thumbnails"]["large"])
return image["thumbnails"]["large"]
return False
except Exception as e:
# print( "Musicbrainz: get_image_uri: failed ",e)
return False
def MusicBrainz(release_path, query, ofile):
try:
r = musicbrainzngs.search_releases(query.replace('-', ''))
id = r['release-list'][0]['id']
img = musicbrainzngs.get_image_list(id)
url = img['images'][0]['image']
urllib.urlretrieve(url, ofile)
print("OK " + ofile)
return query, ofile
except Exception as e:
print("Error for %s (%s)" % (release_path, e))
traceback.print_exc()
return genimage(release_path, query, ofile)
def MusicBrainz(release_path, query, ofile):
try:
r = musicbrainzngs.search_releases(query.replace('-', ''))
id = r['release-list'][0]['id']
img = musicbrainzngs.get_image_list(id)
url = img['images'][0]['image']
urllib.urlretrieve(url, ofile)
print("OK " + ofile)
return query, ofile
except Exception as e:
print("Error for %s (%s)" % (release_path, e))
traceback.print_exc()
return genimage(release_path, query, ofile)
def parse_apic(self, id3, release):
release_id = release['id']
covers = musicbrainzngs.get_image_list(release_id)
if covers['images']:
data = requests.get(
covers['images'][0]['thumbnails']['small']).content
self.pop(id3, 'APIC')
id3.add(
APIC(encoding=3,
mime='image/jpeg',
type=3,
desc=u"Cover",
data=data))
def get_AlbumArt(self, artist, album):
try:
result = musicbrainzngs.search_releases(artist=artist,
release=album,
limit=5)
except Exception as e:
return ''
for r in result['release-list']:
try:
data = musicbrainzngs.get_image_list(r['id'])
return data['images'][0]['image']
except Exception as e:
continue
def get_cd_art(job, infos):
"""
Ask musicbrainz.org for the art of the disc
arguments:
job - the job object for the database entry
infos - object/json returned from musicbrainz.org api
return:
True if we find the cd art
False if we didnt find the art
"""
try:
# Use the build-in images from coverartarchive if available
if infos['disc']['release-list'][0]['cover-art-archive'][
'artwork'] != "false":
artlist = mb.get_image_list(job.crc_id)
for image in artlist["images"]:
# For verified images only
"""if "Front" in image["types"] and image["approved"]:
job.poster_url_auto = str(image["thumbnails"]["large"])
job.poster_url = str(image["thumbnails"]["large"])
return True"""
# We dont care if its verified ?
if "image" in image:
job.poster_url_auto = str(image["image"])
job.poster_url = str(image["image"])
return True
except mb.WebServiceError as exc:
db.session.rollback()
logging.error("get_cd_art ERROR: " + str(exc))
try:
# This uses roboBrowser to grab the amazon/3rd party image if it exists
browser = RoboBrowser(user_agent='a python robot')
browser.open('https://musicbrainz.org/release/' + job.crc_id)
img = browser.select('.cover-art img')
# [<img src="https://images-eu.ssl-images-amazon.com/images/I/41SN9FK5ATL.jpg"/>]
job.poster_url = re.search(r'<img src="(.*)"', str(img)).group(1)
job.poster_url_auto = job.poster_url
# logging.debug("img ===== " + str(img))
# logging.debug("img stripped =====" + str(job.poster_url))
db.session.commit()
if job.poster_url != "":
return True
else:
return False
except mb.WebServiceError as exc:
logging.error("get_cd_art ERROR: " + str(exc))
db.session.rollback()
return False
def get_coverart(self):
musicbrainzngs.set_useragent("python-musicplayer-flask","0.1","*****@*****.**")
if not self.album.musicbrainz_albumid:
raise NameError('musicbrainz_albumid not set')
try:
data = musicbrainzngs.get_image_list(self.album.musicbrainz_albumid)
except Exception as e:
return e
if data['images'].len == 0:
raise NameError('No images returned from service')
urllib.request.urlretrieve(data['images'][0]['image'], "%s%s" % (self.path, self.filename))
ci = open("%s%s" % (self.path, self.filename), 'rb')
self.album.coverimage.put(ci, content_type = 'image/jpeg')
self.album.save()
def get_cover(artist, album, size=250):
"""Download the cover art."""
try:
data = mus.search_releases(artist=artist, release=album, limit=1)
release_id = data["release-list"][0]["id"]
print("RELEASE ID:", release_id)
#print(f"album: Using release-id: {data['release-list'][0]['id']}")
imgdata = mus.get_image_list(release_id)
imageurl = imgdata['images'][0]['image']
return imageurl
except mus.NetworkError:
get_cover(artist, album, size)
except mus.ResponseError:
print("MUSICBRAINZ: Couldn't find album art for",
f"{artist} - {album}")
return ''
def read(self):
try:
disc_id = discid.read()
logger.debug(
'Read disc: MusicBrainz DiscID %s, FreeDB ID %s, %d tracks',
disc_id.id, disc_id.freedb_id, len(disc_id.tracks))
except (discid.DiscError, NotImplementedError) as e:
logger.info('Error identifying disc: %s', e)
self.disc = UNKNOWN_DISC
return
# use cached disc info if possible
if self.disc.discid == disc_id.id:
return
try:
mbrainz_info = musicbrainzngs.get_releases_by_discid(
id=disc_id.id,
toc=disc_id.toc_string,
includes=['artist-credits', 'recordings'],
cdstubs=False)
# mbrainz_info is either
# a {disc: {release-list: [...]}, ...} dict or
# a {release-list: [...]} dict when matched by ToC
release = mbrainz_info.get('disc', mbrainz_info)['release-list'][0]
try:
images = musicbrainzngs.get_image_list(release['id'])
except musicbrainzngs.ResponseError as e:
logger.debug('Error getting CD images from MusicBrainz: %s', e)
images = {'images': ()}
self.disc = Disc(
id=release['id'],
discid=disc_id.id,
title=release['title'],
discs=release['medium-count'],
year=release['date'],
images=CdRom._extract_images(images['images']),
artists=CdRom._extract_artists(release['artist-credit']),
tracks=CdRom._extract_tracks(disc_id, release['medium-list']))
except (LookupError, musicbrainzngs.WebServiceError) as e:
logger.info('Error accessing MusicBrainz: %s', e)
self.disc = UNKNOWN_DISC._replace(
discid=disc_id.id, tracks=CdRom._extract_tracks(disc_id))
def get_coverart(self):
musicbrainzngs.set_useragent("python-musicplayer-flask", "0.1",
"*****@*****.**")
if not self.album.musicbrainz_albumid:
raise NameError('musicbrainz_albumid not set')
try:
data = musicbrainzngs.get_image_list(
self.album.musicbrainz_albumid)
except Exception as e:
return e
if data['images'].len == 0:
raise NameError('No images returned from service')
urllib.request.urlretrieve(data['images'][0]['image'],
"%s%s" % (self.path, self.filename))
ci = open("%s%s" % (self.path, self.filename), 'rb')
self.album.coverimage.put(ci, content_type='image/jpeg')
self.album.save()
async def get_cover_art(release_id, e):
# Try to get the cover art from CoverArtArchive
try:
print("Trying CoverArtArchive")
redirect = requests.get(
mb.get_image_list(release_id)["images"][0]["thumbnails"]
["large"]).url
e.set_thumbnail(url=redirect)
except Exception:
# Try to get the cover art from Amazon
try:
print("Trying Amazon")
response = requests.get(
f'https://musicbrainz.org/ws/2/release/{release_id}?fmt=json')
response.raise_for_status()
asin = response.json()["asin"]
if asin:
response = requests.get(
f"https://images-na.ssl-images-amazon.com/images/P/{asin}.jpg"
)
if response.headers['Content-Type'] == "image/gif":
raise ValueError("Image is a 1x1 GIF")
else:
e.set_thumbnail(
url=
f"https://images-na.ssl-images-amazon.com/images/P/{asin}.jpg"
)
else:
raise ValueError("ASIN not found")
# Else set a dummy image
except Exception:
print("Using fallback image")
e.set_thumbnail(
url="https://cdn.discordapp.com/emojis/778698404317364224.png")
def hydrate(self, bundle):
#Translate model field name to audio metadata name
tag_name_translator: Dict[str, List[str]] = {
'title': ['title'],
}
if 'audio' in bundle.data.keys() and bundle.request.method == 'POST':
if settings.USE_ACOUSTID:
tmp_file_path = bundle.data.get('audio').temporary_file_path()
matches = acoustid.match(settings.ACOUSTID_API_KEY,
tmp_file_path)
try:
score, recording_id, title, artist_entry = next(matches)
except StopIteration:
pass
else:
musicbrainzngs.set_useragent('Open_Sound_Stream:Server',
settings.OSS_VERSION)
try:
rec = musicbrainzngs.get_recording_by_id(
recording_id,
includes=['artists', 'tags', 'releases'])
except musicbrainzngs.WebServiceError:
pass
else:
bundle_data_translate: Dict[str,
Union[List[str],
List[Artist],
List[Album]]] = {
'title': title,
'mbid':
recording_id,
}
for key, val in bundle_data_translate.items():
if key not in bundle.data:
bundle.data[key] = val
artists: List[str] = []
artist_obj_list: List[Artist] = []
if "artists" not in bundle.data:
artist_list: List[Dict] = rec['recording'][
'artist-credit']
for artist_entry in artist_list:
artist_by_id: Artist = Artist.get_by_mbid(
bundle.request.user,
artist_entry["artist"]["id"])
if artist_by_id is not None:
artists.append("/api/v1/artist/{}/".format(
artist_by_id.pk))
artist_obj_list.append(artist_by_id)
bundle.data['artists'] = artists
else:
for artist_entry in bundle.data.getlist('artist'):
artist_entry_splitted = artist_entry.split("/")
if artist_entry_splitted[-1] == '':
del artist_entry_splitted[-1]
try:
artist_id = int(artist_entry_splitted[-1])
except ValueError:
continue
try:
artist_obj_list.append(
Artist.objects.get(
user=bundle.request.user,
pk=artist_id))
except ObjectDoesNotExist:
#dont process any further, let tastypie throw the exception
return bundle
if "album" not in bundle.data and len(
rec['recording']['release-list']) >= 1:
release = rec['recording']['release-list'][0]
album, created = Album.objects.get_or_create(
user=bundle.request.user,
name=release['title'])
for artist_entry in artist_obj_list:
album.artist.add(artist_entry)
album.mbid = release["id"]
try:
img = musicbrainzngs.get_image_list(
release["id"])
except musicbrainzngs.ResponseError:
pass
else:
if len(img["images"]) > 0:
album.cover_url = img["images"][0]["image"]
album.save()
bundle.data['album'] = "/api/v1/album/{}/".format(
album.pk)
metadata = GetTags(fileobj=bundle.data['audio'].file)
for field_name, tag_names in tag_name_translator.items():
if field_name not in bundle.data.keys():
for tag_name in tag_names:
if tag_name in metadata.keys():
bundle.data[field_name] = metadata.get(tag_name)
break
return bundle
import musicbrainzngs as mb
data = "default"
artist_names = []
inf = open("/users/sunjingxuan/desktop/fyp/top_artists_150.txt")
while data is not "":
data = inf.readline()
artist_names.append(data.strip())
image_list = mb.get_image_list("03367cb8-1001-451b-b06f-1da05d44da49")
print(image_list)
# mb.get_image("03367cb8-1001-451b-b06f-1da05d44da49", coverid)
def get_cd_info(rel, discid):
discno = None
album = rel.get("title")
for medium in rel["medium-list"]:
for disc in medium["disc-list"]:
if disc["id"] == discid:
discno = int(medium["position"])
album = medium.get("title", album)
break
if discno:
break
else:
raise Exception("could not find disc no")
relid = rel["id"]
ret = mb.get_release_by_id(
relid, includes=["artists", "recordings", "media", "artist-credits"])
rel = ret.get("release")
date = rel["date"]
fmts = [
"%Y-%m-%d",
"%Y-%m",
"%Y",
]
for fmt in fmts:
try:
year = datetime.datetime.strptime(date, fmt).year
break
except:
pass
else:
print(f"Can't figure out album year: {date}")
year = 1900
set_size = rel["medium-count"]
for medium in rel["medium-list"]:
if int(medium["position"]) == discno:
tracks = medium["track-list"]
break
else:
raise Exception("cannot find tracks")
atracks = []
found_artists = set()
for t in tracks:
artists = t["artist-credit"]
if len(artists) > 1:
artist = "Various"
else:
artist = artists[0]["artist"]["name"]
found_artists.add(artist)
track = TrackInfo(
artist=artist,
album=album,
title=t.get("title") or t["recording"]["title"],
trackno=int(t["position"]),
)
atracks.append(track)
album_artist = "Various"
if len(found_artists) == 1:
album_artist = list(found_artists)[0]
atracks = sorted(atracks, key=lambda t: t.trackno)
cover_art = None
if rel.get("cover-art-archive").get("artwork") == "true":
try:
art = mb.get_image_list(relid)
pos = 0
for img in art["images"]:
if not "Front" in img.get("types", []):
continue
if not cover_art or pos == discno:
cover_art = util.http_get(img["image"])
if pos == discno:
break
pos += 1
except Exception as e:
util.print_error()
pass
return CDInfo(
artist=album_artist,
album=album,
tracks=atracks,
discno=discno,
year=year,
set_size=set_size,
multi_artist=len(found_artists) > 1,
cover_art=cover_art,
disambiguation=rel.get("disambiguation"),
)
def get_album_art(self) -> None:
"""
Get album art for each release. This modifies the release structure
to include an images field.
"""
# Record the IDs of images we've seen in case they're shared across
# releases.
seen_images: Set[str] = set()
# Record how many images we've seen of each type so we can number any
# images beyond the first.
image_type_counts: Dict[str, int] = {}
for release in self.disc_metadata["disc"]["release-list"]:
rel_id = release["id"]
log.debug("Getting images for release id %s", rel_id)
try:
il_result = mb.get_image_list(rel_id)
image_list = il_result["images"]
for image_info in image_list:
image_id = image_info["id"]
if image_id in seen_images:
# Don't re-download images we've seen before.
log.debug("Skipping already-seen image %s", image_id)
continue
# image_types will usually be a single element list, e.g.:
# ["Front"], ["Back"], but occasionally contains multiple
# items: ["Back", "Spine"].
image_types = image_info.get("types", [])
if image_types:
image_type = "-".join(image_types)
else:
image_type = "Unknown"
image_type_count = image_type_counts.get(image_type, 0) + 1
image_type_counts[image_type] = image_type_count
# If this is the first image, don't include a -# suffix.
key = (f"{self.config.s3_prefix}{self.disc_id}/"
f"{image_type.lower()}")
if image_type_count > 1:
key += f"-{image_type_count}"
key += ".jpg"
image_info["local"] = f"s3://{self.bucket.name}{key}"
log.debug("Image %s: type=%s key=%s", image_id, image_type,
key)
# Download the image from the Cover Art Archive, then
# write it to S3.
def copy_art_to_s3(image_id, rel_id, key):
nonlocal self
image = mb.get_image(rel_id, image_id)
self.bucket.put_object(ACL="private",
Body=image,
ContentType="image/jpeg",
Key=key)
self.executor.submit(copy_art_to_s3, image_id, rel_id, key)
release["images"] = image_list
except mb.musicbrainz.ResponseError:
release["images"] = []
def parse(self, relnum):
if not self.mblist:
self.mblist = {'manual': 'manual'} #lazy bugfix is lazy
for k in self.mblist:
if k == 'disc':
data = self.mblist['disc']['release-list'][relnum]
self.infodict = { 'artist': data['artist-credit-phrase'], 'album': data['title'], 'discnum': '',\
'multidisc': False, 'date': data['date'], 'relid': data['id'], \
'infotype': 'musicbrainz', 'tracklist': []}
if int(data['medium-count']) > 1:
self.infodict['multidisc'] = True
for x in data['medium-list']:
for y in x['disc-list']:
if str(self.disc) == y['id']:
self.infodict['discnum'] = x['position']
dindex = int(self.infodict['discnum']) - 1
for x in data['medium-list'][dindex]['track-list']:
self.infodict['tracklist'].append(x['recording']['title'])
break
elif k == 'cdstub':
data = self.mblist['cdstub']
self.infodict = { 'artist': data['artist'], 'album': data['title'], 'date': '0000',\
'discnum': '1', 'multidisc': False, 'relid': data['id'], \
'infotype': 'cdstub', 'tracklist': []}
for x in data['track-list']:
self.infodict['tracklist'].append(x['title'])
break
else:
self.infodict = { 'artist': 'Artist', 'album': 'Album Title', 'date': '0000', 'discnum': '1',\
'multidisc': False, 'relid': 'helpmeihavenoentryonmusicbrainz',
'infotype': 'manual', 'tracklist': []}
for x in range(len(self.disc.tracks)):
self.infodict['tracklist'].append(f'Track {(x+1):02d}')
break
try:
imageinfo = False
imagelist = musicbrainzngs.get_image_list(self.infodict['relid'])
for x in imagelist['images']:
if x['front']:
imageinfo = x
except Exception as e:
print(e)
if os.path.exists(f"{temppath}/{self.infodict['relid']}"):
shutil.rmtree(f"{temppath}/{self.infodict['relid']}")
os.makedirs(f"{temppath}/{self.infodict['relid']}")
if imageinfo:
self.infodict[
'cover'] = f"{temppath}/{self.infodict['relid']}/cover{imageinfo['image'][-4:]}"
coverart = open(self.infodict['cover'], 'wb')
coverart.write(
musicbrainzngs.get_image_front(self.infodict['relid']))
coverart.close()
else:
self.infodict['cover'] = False
print("Couldn't find cover art for this release.")
return (self.infodict)
