def _parse_versions(self, document):
"""Parse document and return a list of releases"""
del self.versions[:]
data = []
for node in document.metadata[0].release_list[0].release:
labels, catnums = label_info_from_node(node.label_info_list[0])
release = {
"id": node.id,
"date": node.date[0].text if "date" in node.children else "",
"country": node.country[0].text if "country" in node.children else "",
"format": media_formats_from_node(node.medium_list[0]),
"labels": ", ".join(set(labels)),
"catnums": ", ".join(set(catnums)),
"tracks": " + ".join([m.track_list[0].count for m in node.medium_list[0].medium]),
"barcode":
node.barcode[0].text
if "barcode" in node.children
and node.barcode[0].text != ""
else _("[no barcode]"),
"packaging":
node.packaging[0].text
if "packaging" in node.children
else None,
"disambiguation":
node.disambiguation[0].text
if "disambiguation" in node.children
else None,
"_disambiguate_name": list(),
}
data.append(release)
data.sort(key=lambda x: x["date"])
namekeys = ("date", "country", "labels", "catnums", "tracks", "format")
extrakeys = ("packaging", "barcode", "disambiguation")
versions = defaultdict(list)
for release in data:
name = " / ".join(filter(None, (release[k] for k in namekeys))).replace("&", "&&")
if name == release["tracks"]:
name = "%s / %s" % (_('[no release info]'), name)
versions[name].append(release)
#de-duplicate names if possible
for name, releases in versions.iteritems():
for a, b in combinations(releases, 2):
for key in extrakeys:
(value1, value2) = (a[key], b[key])
if value1 != value2:
a['_disambiguate_name'].append(value1)
b['_disambiguate_name'].append(value2)
for name, releases in versions.iteritems():
for release in releases:
dis = " / ".join(filter(None, uniqify(release['_disambiguate_name']))).replace("&", "&&")
disname = name if not dis else name + ' / ' + dis
self.versions.append({'id': release['id'], 'name': disname})
def _parse_release_group(self, document):
for node in document.metadata[0].release_list[0].release:
v = {}
v["mbid"] = node.id
v["date"] = node.date[0].text if "date" in node.children else ""
v["country"] = node.country[0].text if "country" in node.children else ""
labels, catnums = label_info_from_node(node.label_info_list[0])
v["labels"] = ", ".join(set(labels))
v["catnums"] = ", ".join(set(catnums))
v["tracks"] = " + ".join([m.track_list[0].count for m in node.medium_list[0].medium])
v["format"] = media_formats_from_node(node.medium_list[0])
self.other_versions.append(v)
self.other_versions.sort(key=lambda x: x["date"])
def parse_releases_from_xml(self, release_xml):
for node in release_xml:
release = Metadata()
release_to_metadata(node, release)
rg_node = node.release_group[0]
release_group_to_metadata(rg_node, release)
if "medium_list" in node.children:
medium_list = node.medium_list[0]
release["format"] = media_formats_from_node(medium_list)
release["tracks"] = medium_list.track_count[0].text
countries = country_list_from_node(node)
if countries:
release["country"] = ", ".join(countries)
self.search_results.append(release)
def _parse_release_group(self, document):
for node in document.metadata[0].release_list[0].release:
v = {}
v["mbid"] = node.id
v["date"] = node.date[0].text if "date" in node.children else ""
v["country"] = node.country[
0].text if "country" in node.children else ""
labels, catnums = label_info_from_node(node.label_info_list[0])
v["labels"] = ", ".join(set(labels))
v["catnums"] = ", ".join(set(catnums))
v["tracks"] = " + ".join(
[m.track_list[0].count for m in node.medium_list[0].medium])
v["format"] = media_formats_from_node(node.medium_list[0])
self.other_versions.append(v)
self.other_versions.sort(key=lambda x: x["date"])
def _parse_release(self, document):
self.log.debug("Loading release %r", self.id)
self._tracks_loaded = False
release_node = document.metadata[0].release[0]
if release_node.id != self.id:
self.tagger.mbid_redirects[self.id] = release_node.id
album = self.tagger.albums.get(release_node.id)
if album:
self.log.debug("Release %r already loaded", release_node.id)
album.match_files(self.unmatched_files.files)
album.update()
self.tagger.remove_album(self)
return False
else:
del self.tagger.albums[self.id]
self.tagger.albums[release_node.id] = self
self.id = release_node.id
# Get release metadata
m = self._new_metadata
m.length = 0
release_to_metadata(release_node, m, config=self.config, album=self)
self.format_str = media_formats_from_node(release_node.medium_list[0])
self.rgid = release_node.release_group[0].id
if self._discid:
m['musicbrainz_discid'] = self._discid
# Custom VA name
if m['musicbrainz_albumartistid'] == VARIOUS_ARTISTS_ID:
m['albumartistsort'] = m['albumartist'] = self.config.setting[
'va_name']
# Convert Unicode punctuation
if self.config.setting['convert_punctuation']:
m.apply_func(asciipunct)
m['totaldiscs'] = release_node.medium_list[0].count
# Run album metadata plugins
try:
run_album_metadata_processors(self, m, release_node)
except:
self.log.error(traceback.format_exc())
self._release_node = release_node
return True
def _parse_release(self, document):
self.log.debug("Loading release %r", self.id)
self._tracks_loaded = False
release_node = document.metadata[0].release[0]
if release_node.id != self.id:
self.tagger.mbid_redirects[self.id] = release_node.id
album = self.tagger.albums.get(release_node.id)
if album:
self.log.debug("Release %r already loaded", release_node.id)
album.match_files(self.unmatched_files.files)
album.update()
self.tagger.remove_album(self)
return False
else:
del self.tagger.albums[self.id]
self.tagger.albums[release_node.id] = self
self.id = release_node.id
# Get release metadata
m = self._new_metadata
m.length = 0
release_to_metadata(release_node, m, config=self.config, album=self)
self.format_str = media_formats_from_node(release_node.medium_list[0])
self.rgid = release_node.release_group[0].id
if self._discid:
m['musicbrainz_discid'] = self._discid
# Custom VA name
if m['musicbrainz_albumartistid'] == VARIOUS_ARTISTS_ID:
m['albumartistsort'] = m['albumartist'] = self.config.setting['va_name']
# Convert Unicode punctuation
if self.config.setting['convert_punctuation']:
m.apply_func(asciipunct)
m['totaldiscs'] = release_node.medium_list[0].count
# Run album metadata plugins
try:
run_album_metadata_processors(self, m, release_node)
except:
self.log.error(traceback.format_exc())
self._release_node = release_node
return True
def _parse_versions(self, document):
del self.versions[:]
data = []
for node in document.metadata[0].release_list[0].release:
labels, catnums = label_info_from_node(node.label_info_list[0])
data.append({
"id": node.id,
"date": node.date[0].text if "date" in node.children else "",
"country": node.country[0].text if "country" in node.children else "",
"format": media_formats_from_node(node.medium_list[0]),
"labels": ", ".join(set(labels)),
"catnums": ", ".join(set(catnums)),
"tracks": " + ".join([m.track_list[0].count for m in node.medium_list[0].medium]),
})
data.sort(key=lambda x: x["date"])
keys = ("date", "country", "labels", "catnums", "tracks", "format")
for version in data:
name = " / ".join(filter(None, (version[k] for k in keys))).replace("&", "&&")
if name == version["tracks"]:
name = "%s / %s" % (_('[no release info]'), name)
self.versions.append({"id": version["id"], "name": name})
def _parse_versions(self, document):
del self.versions[:]
data = []
for node in document.metadata[0].release_list[0].release:
labels, catnums = label_info_from_node(node.label_info_list[0])
data.append({
"id": node.id,
"date": node.date[0].text if "date" in node.children else "",
"country": node.country[0].text if "country" in node.children else "",
"format": media_formats_from_node(node.medium_list[0]),
"labels": ", ".join(set(labels)),
"catnums": ", ".join(set(catnums)),
"tracks": " + ".join([m.track_list[0].count for m in node.medium_list[0].medium]),
})
data.sort(key=lambda x: x["date"])
keys = ("date", "country", "labels", "catnums", "tracks", "format")
for version in data:
name = " / ".join(filter(None, (version[k] for k in keys))).replace("&", "&&")
if name == version["tracks"]:
name = "%s / %s" % (_('[no release info]'), name)
self.versions.append({"id": version["id"], "name": name})
def _parse_versions(self, document):
"""Parse document and return a list of releases"""
del self.versions[:]
data = []
namekeys = ("tracks", "year", "country", "format", "label", "catnum")
headings = {
"tracks": N_('Tracks'),
"year": N_('Year'),
"country": N_('Country'),
"format": N_('Format'),
"label": N_('Label'),
"catnum": N_('Cat No'),
}
extrakeys = ("packaging", "barcode", "disambiguation")
for node in document.metadata[0].release_list[0].release:
labels, catnums = label_info_from_node(node.label_info_list[0])
countries = []
if 'release_event_list' in node.children:
for release_event in node.release_event_list[0].release_event:
if "area" in release_event.children:
countries.append(
release_event.area[0].iso_3166_1_code_list[0].
iso_3166_1_code[0].text)
formats = []
for medium in node.medium_list[0].medium:
if "format" in medium.children:
formats.append(medium.format[0].text)
release = {
"id":
node.id,
"year":
node.date[0].text[:4] if "date" in node.children else "????",
"country":
"+".join(countries) if countries else
node.country[0].text if "country" in node.children else "??",
"format":
media_formats_from_node(node.medium_list[0]),
"label":
", ".join([' '.join(x.split(' ')[:2]) for x in set(labels)]),
"catnum":
", ".join(set(catnums)),
"tracks":
"+".join([
m.track_list[0].count for m in node.medium_list[0].medium
]),
"barcode":
node.barcode[0].text if "barcode" in node.children
and node.barcode[0].text != "" else _("[no barcode]"),
"packaging":
node.packaging[0].text
if "packaging" in node.children else None,
"disambiguation":
node.disambiguation[0].text
if "disambiguation" in node.children else None,
"_disambiguate_name":
list(),
"totaltracks":
sum([
int(m.track_list[0].count)
for m in node.medium_list[0].medium
]),
"countries":
countries,
"formats":
formats,
}
data.append(release)
versions = defaultdict(list)
for release in data:
name = " / ".join([release[k]
for k in namekeys]).replace("&", "&&")
if name == release["tracks"]:
name = "%s / %s" % (_('[no release info]'), name)
versions[name].append(release)
# de-duplicate names if possible
for name, releases in versions.iteritems():
for a, b in combinations(releases, 2):
for key in extrakeys:
(value1, value2) = (a[key], b[key])
if value1 != value2:
a['_disambiguate_name'].append(value1)
b['_disambiguate_name'].append(value2)
for name, releases in versions.iteritems():
for release in releases:
dis = " / ".join(
filter(None,
uniqify(release['_disambiguate_name']))).replace(
"&", "&&")
disname = name if not dis else name + ' / ' + dis
version = {
'id': release['id'],
'name': disname,
'totaltracks': release['totaltracks'],
'countries': release['countries'],
'formats': release['formats'],
}
self.versions.append(version)
self.version_headings = " / ".join(_(headings[k]) for k in namekeys)
def _parse_release(self, document):
self.log.debug("Loading release %r", self.id)
release_node = document.metadata[0].release[0]
if release_node.id != self.id:
album = self.tagger.get_album_by_id(release_node.id)
self.tagger.albumids[self.id] = release_node.id
self.id = release_node.id
if album:
album.match_files(self.unmatched_files.files)
album.update()
self.tagger.remove_album(self)
self.log.debug("Release %r already loaded", self.id)
return False
# Get release metadata
m = self._new_metadata
m.length = 0
release_to_metadata(release_node, m, config=self.config, album=self)
self.format_str = media_formats_from_node(release_node.medium_list[0])
self.rgid = release_node.release_group[0].id
if self._discid:
m['musicbrainz_discid'] = self._discid
# 'Translate' artist name
if self.config.setting['translate_artist_names']:
m['albumartist'] = translate_artist(m['albumartist'], m['albumartistsort'])
# Custom VA name
if m['musicbrainz_albumartistid'] == VARIOUS_ARTISTS_ID:
m['albumartistsort'] = m['albumartist'] = self.config.setting['va_name']
ignore_tags = [s.strip() for s in self.config.setting['ignore_tags'].split(',')]
first_artist = None
compilation = False
track_counts = []
m['totaldiscs'] = release_node.medium_list[0].count
self._metadata_processors = [partial(run_album_metadata_processors, self, m, release_node)]
for medium_node in release_node.medium_list[0].medium:
mm = Metadata()
mm.copy(m)
medium_to_metadata(medium_node, mm)
track_counts.append(mm['totaltracks'])
for track_node in medium_node.track_list[0].track:
t = Track(track_node.recording[0].id, self)
self._new_tracks.append(t)
# Get track metadata
tm = t.metadata
tm.copy(mm)
track_to_metadata(track_node, t, self.config)
m.length += tm.length
artist_id = tm['musicbrainz_artistid']
if compilation is False:
if first_artist is None:
first_artist = artist_id
if first_artist != artist_id:
compilation = True
for track in self._new_tracks:
track.metadata['compilation'] = '1'
else:
tm['compilation'] = '1'
t._customize_metadata(ignore_tags)
plugins = partial(run_track_metadata_processors, self, tm, release_node, track_node)
self._metadata_processors.append(plugins)
m["~totalalbumtracks"] = str(sum(map(int, track_counts)))
self.tracks_str = " + ".join(track_counts)
return True
def _parse_versions(self, document):
"""Parse document and return a list of releases"""
del self.versions[:]
data = []
namekeys = ("tracks", "year", "country", "format", "label", "catnum")
headings = {
"tracks": N_('Tracks'),
"year": N_('Year'),
"country": N_('Country'),
"format": N_('Format'),
"label": N_('Label'),
"catnum": N_('Cat No'),
}
extrakeys = ("packaging", "barcode", "disambiguation")
for node in document.metadata[0].release_list[0].release:
labels, catnums = label_info_from_node(node.label_info_list[0])
countries = []
if 'release_event_list' in node.children:
for release_event in node.release_event_list[0].release_event:
if "area" in release_event.children:
countries.append(release_event.area[0].iso_3166_1_code_list[0].iso_3166_1_code[0].text)
formats = []
for medium in node.medium_list[0].medium:
if "format" in medium.children:
formats.append(medium.format[0].text)
release = {
"id": node.id,
"year": node.date[0].text[:4] if "date" in node.children else "????",
"country": "+".join(countries) if countries
else node.country[0].text if "country" in node.children
else "??",
"format": media_formats_from_node(node.medium_list[0]),
"label": ", ".join([' '.join(x.split(' ')[:2]) for x in set(labels)]),
"catnum": ", ".join(set(catnums)),
"tracks": "+".join([m.track_list[0].count for m in node.medium_list[0].medium]),
"barcode":
node.barcode[0].text
if "barcode" in node.children
and node.barcode[0].text != ""
else _("[no barcode]"),
"packaging":
node.packaging[0].text
if "packaging" in node.children
else None,
"disambiguation":
node.disambiguation[0].text
if "disambiguation" in node.children
else None,
"_disambiguate_name": list(),
"totaltracks": sum([int(m.track_list[0].count) for m in node.medium_list[0].medium]),
"countries": countries,
"formats": formats,
}
data.append(release)
versions = defaultdict(list)
for release in data:
name = " / ".join([release[k] for k in namekeys]).replace("&", "&&")
if name == release["tracks"]:
name = "%s / %s" % (_('[no release info]'), name)
versions[name].append(release)
# de-duplicate names if possible
for name, releases in versions.items():
for a, b in combinations(releases, 2):
for key in extrakeys:
(value1, value2) = (a[key], b[key])
if value1 != value2:
a['_disambiguate_name'].append(value1)
b['_disambiguate_name'].append(value2)
for name, releases in versions.items():
for release in releases:
dis = " / ".join(filter(None, uniqify(release['_disambiguate_name']))).replace("&", "&&")
disname = name if not dis else name + ' / ' + dis
version = {
'id': release['id'],
'name': disname,
'totaltracks': release['totaltracks'],
'countries': release['countries'],
'formats': release['formats'],
}
self.versions.append(version)
self.version_headings = " / ".join(_(headings[k]) for k in namekeys)
