def parse_tracks_from_xml(self, tracks_xml):
"""Extracts track information from XmlNode objects and stores that into Metadata objects.
Args:
tracks_xml -- list of XmlNode objects
"""
for node in tracks_xml:
if "release_list" in node.children and "release" in node.release_list[0].children:
for rel_node in node.release_list[0].release:
track = Metadata()
recording_to_metadata(node, track)
release_to_metadata(rel_node, track)
rg_node = rel_node.release_group[0]
release_group_to_metadata(rg_node, track)
if "release_event_list" in rel_node.children:
# Extract contries list from `release_event_list` element
# Don't use `country` element as it contains information of a single release
# event and is basically for backward compatibility.
country = []
for re in rel_node.release_event_list[0].release_event:
try:
country.append(
re.area[0].iso_3166_1_code_list[0].iso_3166_1_code[0].text)
except AttributeError:
pass
track["country"] = ", ".join(country)
self.search_results.append((track, node))
else:
# This handles the case when no release is associated with a track
# i.e. the track is a NAT
track = Metadata()
recording_to_metadata(node, track)
track["album"] = _("Standalone Recording")
self.search_results.append((track, node))
def _parse_release(self, document):
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:
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
rg_node = release_node.release_group[0]
rg = self.release_group = self.tagger.get_release_group_by_id(
rg_node.id)
rg.loaded_albums.add(self.id)
rg.refcount += 1
release_group_to_metadata(rg_node, rg.metadata, rg)
m.copy(rg.metadata)
release_to_metadata(release_node, m, album=self)
if self._discid:
m['musicbrainz_discid'] = self._discid
# Custom VA name
if m['musicbrainz_albumartistid'] == VARIOUS_ARTISTS_ID:
m['albumartistsort'] = m['albumartist'] = config.setting['va_name']
# Convert Unicode punctuation
if config.setting['convert_punctuation']:
m.apply_func(asciipunct)
m['totaldiscs'] = release_node.medium_list[0].count
# Add album to collections
add_release_to_user_collections(release_node)
# Run album metadata plugins
try:
run_album_metadata_processors(self, m, release_node)
except:
self.error_append(traceback.format_exc())
self._release_node = release_node
return True
def _parse_release(self, document):
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:
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
rg_node = release_node.release_group[0]
rg = self.release_group = self.tagger.get_release_group_by_id(rg_node.id)
rg.loaded_albums.add(self.id)
rg.refcount += 1
release_group_to_metadata(rg_node, rg.metadata, rg)
m.copy(rg.metadata)
release_to_metadata(release_node, m, album=self)
if self._discid:
m['musicbrainz_discid'] = self._discid
# Custom VA name
if m['musicbrainz_albumartistid'] == VARIOUS_ARTISTS_ID:
m['albumartistsort'] = m['albumartist'] = config.setting['va_name']
# Convert Unicode punctuation
if config.setting['convert_punctuation']:
m.apply_func(asciipunct)
m['totaldiscs'] = release_node.medium_list[0].count
# Add album to collections
add_release_to_user_collections(release_node)
# Run album metadata plugins
try:
run_album_metadata_processors(self, m, release_node)
except:
self.error_append(traceback.format_exc())
self._release_node = release_node
return True
def test_1(self):
config.setting = settings
release = XmlNode(attribs={'id': '123'}, children={
'title': [XmlNode(text='Foo')],
'status': [XmlNode(text='Official')],
'text_representation': [XmlNode(children={
'language': [XmlNode(text='eng')],
'script': [XmlNode(text='Latn')]
})],
'artist_credit': [XmlNode(children={
'name_credit': [XmlNode(attribs={'joinphrase': ' & '}, children={
'artist': [XmlNode(attribs={'id': '456'}, children={
'name': [XmlNode(text='Foo Bar')],
'sort_name': [XmlNode(text='Bar, Foo')]
})]
}), XmlNode(children={
'artist': [XmlNode(attribs={'id': '789'}, children={
'name': [XmlNode(text='Baz')],
'sort_name': [XmlNode(text='Baz')]
})]
})]
})],
'date': [XmlNode(text='2009-08-07')],
'country': [XmlNode(text='GB')],
'barcode': [XmlNode(text='012345678929')],
'asin': [XmlNode(text='B123456789')],
'label_info_list': [XmlNode(attribs={'count': '1'}, children={
'label_info': [XmlNode(children={
'catalog_number': [XmlNode(text='ABC 123')],
'label': [XmlNode(children={
'name': [XmlNode(text='ABC')]
})]
})]
})]
})
m = Metadata()
release_to_metadata(release, m)
self.assertEqual('123', m['musicbrainz_albumid'])
self.assertEqual('456; 789', m['musicbrainz_albumartistid'])
self.assertEqual('Foo', m['album'])
self.assertEqual('official', m['releasestatus'])
self.assertEqual('eng', m['~releaselanguage'])
self.assertEqual('Latn', m['script'])
self.assertEqual('Foo Bar & Baz', m['albumartist'])
self.assertEqual('Bar, Foo & Baz', m['albumartistsort'])
self.assertEqual('2009-08-07', m['date'])
self.assertEqual('GB', m['releasecountry'])
self.assertEqual('012345678929', m['barcode'])
self.assertEqual('B123456789', m['asin'])
self.assertEqual('ABC', m['label'])
self.assertEqual('ABC 123', m['catalognumber'])
def test_1(self):
config.setting = settings
release = XmlNode(attribs={'id': '123'}, children={
'title': [XmlNode(text='Foo')],
'status': [XmlNode(text='Official')],
'text_representation': [XmlNode(children={
'language': [XmlNode(text='eng')],
'script': [XmlNode(text='Latn')]
})],
'artist_credit': [XmlNode(children={
'name_credit': [XmlNode(attribs={'joinphrase': ' & '}, children={
'artist': [XmlNode(attribs={'id': '456'}, children={
'name': [XmlNode(text='Foo Bar')],
'sort_name': [XmlNode(text='Bar, Foo')]
})]
}), XmlNode(children={
'artist': [XmlNode(attribs={'id': '789'}, children={
'name': [XmlNode(text='Baz')],
'sort_name': [XmlNode(text='Baz')]
})]
})]
})],
'date': [XmlNode(text='2009-08-07')],
'country': [XmlNode(text='GB')],
'barcode': [XmlNode(text='012345678929')],
'asin': [XmlNode(text='B123456789')],
'label_info_list': [XmlNode(attribs={'count': '1'}, children={
'label_info': [XmlNode(children={
'catalog_number': [XmlNode(text='ABC 123')],
'label': [XmlNode(children={
'name': [XmlNode(text='ABC')]
})]
})]
})]
})
m = Metadata()
release_to_metadata(release, m)
self.assertEqual('123', m['musicbrainz_albumid'])
self.assertEqual('456; 789', m['musicbrainz_albumartistid'])
self.assertEqual('Foo', m['album'])
self.assertEqual('official', m['releasestatus'])
self.assertEqual('eng', m['~releaselanguage'])
self.assertEqual('Latn', m['script'])
self.assertEqual('Foo Bar & Baz', m['albumartist'])
self.assertEqual('Bar, Foo & Baz', m['albumartistsort'])
self.assertEqual('2009-08-07', m['date'])
self.assertEqual('GB', m['releasecountry'])
self.assertEqual('012345678929', m['barcode'])
self.assertEqual('B123456789', m['asin'])
self.assertEqual('ABC', m['label'])
self.assertEqual('ABC 123', m['catalognumber'])
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(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 _earliest_release_downloaded(album, metadata, original_id, document, http, error):
try:
if error:
album.log.error("%r", unicode(http.errorString()))
else:
try:
release_node = document.metadata[0].release[0]
original_album = Album(original_id)
release_to_metadata(release_node, original_album.metadata,
config=album.config, album=original_album)
get_earliest_release_date(original_album, metadata)
for track in album._new_tracks:
track.metadata["originaldate"] = metadata["originaldate"]
except:
error = True
album.log.error(traceback.format_exc())
finally:
album._requests -= 1
album._finalize_loading(None)
def parse_tracks_from_xml(self, tracks_xml):
for node in tracks_xml:
if "release_list" in node.children and "release" in node.release_list[0].children:
for rel_node in node.release_list[0].release:
track = Metadata()
recording_to_metadata(node, track)
release_to_metadata(rel_node, track)
rg_node = rel_node.release_group[0]
release_group_to_metadata(rg_node, track)
countries = country_list_from_node(rel_node)
if countries:
track["country"] = ", ".join(countries)
self.search_results.append((track, node))
else:
# This handles the case when no release is associated with a track
# i.e. the track is an NAT
track = Metadata()
recording_to_metadata(node, track)
track["album"] = _("Standalone Recording")
self.search_results.append((track, node))
def _earliest_release_downloaded(album, metadata, original_id, document, http,
error):
try:
if error:
album.log.error("%r", unicode(http.errorString()))
else:
try:
release_node = document.metadata[0].release[0]
original_album = Album(original_id)
release_to_metadata(release_node,
original_album.metadata,
config=album.config,
album=original_album)
get_earliest_release_date(original_album, metadata)
for track in album._new_tracks:
track.metadata["originaldate"] = metadata["originaldate"]
except:
error = True
album.log.error(traceback.format_exc())
finally:
album._requests -= 1
album._finalize_loading(None)
def test_1(self):
config.setting = settings
release = XmlNode(
attribs={"id": u"123"},
children={
"title": [XmlNode(text=u"Foo")],
"status": [XmlNode(text=u"Official")],
"text_representation": [
XmlNode(children={"language": [XmlNode(text=u"eng")], "script": [XmlNode(text=u"Latn")]})
],
"artist_credit": [
XmlNode(
children={
"name_credit": [
XmlNode(
attribs={"joinphrase": u" & "},
children={
"artist": [
XmlNode(
attribs={"id": u"456"},
children={
"name": [XmlNode(text=u"Foo Bar")],
"sort_name": [XmlNode(text=u"Bar, Foo")],
},
)
]
},
),
XmlNode(
children={
"artist": [
XmlNode(
attribs={"id": u"789"},
children={
"name": [XmlNode(text=u"Baz")],
"sort_name": [XmlNode(text=u"Baz")],
},
)
]
}
),
]
}
)
],
"date": [XmlNode(text=u"2009-08-07")],
"country": [XmlNode(text=u"GB")],
"barcode": [XmlNode(text=u"012345678929")],
"asin": [XmlNode(text=u"B123456789")],
"label_info_list": [
XmlNode(
attribs={"count": u"1"},
children={
"label_info": [
XmlNode(
children={
"catalog_number": [XmlNode(text=u"ABC 123")],
"label": [XmlNode(children={"name": [XmlNode(text=u"ABC")]})],
}
)
]
},
)
],
},
)
m = Metadata()
release_to_metadata(release, m)
self.assertEqual(u"123", m["musicbrainz_albumid"])
self.assertEqual(u"456; 789", m["musicbrainz_albumartistid"])
self.assertEqual(u"Foo", m["album"])
self.assertEqual(u"official", m["releasestatus"])
self.assertEqual(u"eng", m["~releaselanguage"])
self.assertEqual(u"Latn", m["script"])
self.assertEqual(u"Foo Bar & Baz", m["albumartist"])
self.assertEqual(u"Bar, Foo & Baz", m["albumartistsort"])
self.assertEqual(u"2009-08-07", m["date"])
self.assertEqual(u"GB", m["releasecountry"])
self.assertEqual(u"012345678929", m["barcode"])
self.assertEqual(u"B123456789", m["asin"])
self.assertEqual(u"ABC", m["label"])
self.assertEqual(u"ABC 123", m["catalognumber"])
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_release(self, document):
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:
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
rg_node = release_node.release_group[0]
rg = self.release_group = self.tagger.get_release_group_by_id(rg_node.id)
rg.loaded_albums.add(self.id)
rg.refcount += 1
release_group_to_metadata(rg_node, rg.metadata, rg)
m.copy(rg.metadata)
release_to_metadata(release_node, m, album=self)
if self._discid:
m["musicbrainz_discid"] = self._discid
# Custom VA name
if m["musicbrainz_albumartistid"] == VARIOUS_ARTISTS_ID:
m["albumartistsort"] = m["albumartist"] = config.setting["va_name"]
# Convert Unicode punctuation
if config.setting["convert_punctuation"]:
m.apply_func(asciipunct)
m["totaldiscs"] = release_node.medium_list[0].count
# Add album to collections
if "collection_list" in release_node.children:
for node in release_node.collection_list[0].collection:
if node.editor[0].text.lower() == config.setting["username"].lower():
if node.id not in user_collections:
user_collections[node.id] = Collection(node.id, node.name[0].text, node.release_list[0].count)
user_collections[node.id].releases.add(self.id)
# Run album metadata plugins
try:
run_album_metadata_processors(self, m, release_node)
except:
self.error_append(traceback.format_exc())
self._release_node = release_node
return True
