def test_compare_to_release(self):
release = load_test_json('release.json')
metadata = Metadata()
release_to_metadata(release, metadata)
match = metadata.compare_to_release(release, Cluster.comparison_weights)
self.assertEqual(1.0, match.similarity)
self.assertEqual(release, match.release)
def test_release(self):
m = Metadata()
a = Album("1")
release_to_metadata(self.json_doc, m, a)
self.assertEqual(m['album'], 'The Dark Side of the Moon')
self.assertEqual(m['albumartist'], 'Pink Floyd')
self.assertEqual(m['albumartistsort'], 'Pink Floyd')
self.assertEqual(m['asin'], 'b123')
self.assertEqual(m['barcode'], '123')
self.assertEqual(m['catalognumber'], 'SHVL 804')
self.assertEqual(m['date'], '1973-03-24')
self.assertEqual(m['label'], 'Harvest')
self.assertEqual(m['musicbrainz_albumartistid'], '83d91898-7763-47d7-b03b-b92132375c47')
self.assertEqual(m['musicbrainz_albumid'], 'b84ee12a-09ef-421b-82de-0441a926375b')
self.assertEqual(m['releasecountry'], 'GB')
self.assertEqual(m['releasestatus'], 'official')
self.assertEqual(m['script'], 'Latn')
self.assertEqual(m['~albumartists'], 'Pink Floyd')
self.assertEqual(m['~albumartists_sort'], 'Pink Floyd')
self.assertEqual(m['~releaselanguage'], 'eng')
self.assertEqual(a.genres, {
'genre1': 6, 'genre2': 3,
'tag1': 6, 'tag2': 3 })
for artist in a._album_artists:
self.assertEqual(artist.genres, {
'british': 2,
'progressive rock': 10 })
def test_release(self):
m = Metadata()
a = Album("1")
release_to_metadata(self.json_doc, m, a)
self.assertEqual(m['album'], 'The Dark Side of the Moon')
self.assertEqual(m['albumartist'], 'Pink Floyd')
self.assertEqual(m['albumartistsort'], 'Pink Floyd')
self.assertEqual(m['asin'], 'b123')
self.assertEqual(m['barcode'], '123')
self.assertEqual(m['catalognumber'], 'SHVL 804')
self.assertEqual(m['date'], '1973-03-24')
self.assertEqual(m['label'], 'Harvest')
self.assertEqual(m['musicbrainz_albumartistid'], '83d91898-7763-47d7-b03b-b92132375c47')
self.assertEqual(m['musicbrainz_albumid'], 'b84ee12a-09ef-421b-82de-0441a926375b')
self.assertEqual(m['releasecountry'], 'GB')
self.assertEqual(m['releasestatus'], 'official')
self.assertEqual(m['script'], 'Latn')
self.assertEqual(m['~albumartists'], 'Pink Floyd')
self.assertEqual(m['~albumartists_sort'], 'Pink Floyd')
self.assertEqual(m['~releaselanguage'], 'eng')
self.assertEqual(m.getall('~releasecountries'), ['GB', 'NZ'])
self.assertEqual(a.genres, {
'genre1': 6, 'genre2': 3,
'tag1': 6, 'tag2': 3})
for artist in a._album_artists:
self.assertEqual(artist.genres, {
'british': 2,
'progressive rock': 10})
def test_compare_to_release_with_score(self):
release = load_test_json('release.json')
metadata = Metadata()
release_to_metadata(release, metadata)
for score, sim in ((42, 0.42), ('42', 0.42), ('foo', 1.0), (None, 1.0)):
release['score'] = score
match = metadata.compare_to_release(release, Cluster.comparison_weights)
self.assertEqual(sim, match.similarity)
def test_compare_to_release_parts_totalalbumtracks_totaltracks_fallback(self):
release = load_test_json('release_multidisc.json')
metadata = Metadata()
weights = {"totalalbumtracks": 30}
release_to_metadata(release, metadata)
for totaltracks, sim in ((7, 1.0), (6, 0.3), (8, 0.0)):
metadata['totaltracks'] = totaltracks
parts = metadata.compare_to_release_parts(release, weights)
self.assertIn((sim, 30), parts)
def _parse_release(self, release_node):
log.debug("Loading release %r ...", self.id)
self._tracks_loaded = False
release_id = release_node['id']
if release_id != self.id:
self.tagger.mbid_redirects[self.id] = release_id
album = self.tagger.albums.get(release_id)
if album:
log.debug("Release %r already loaded", release_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_id] = self
self.id = release_id
# Get release metadata
m = self._new_metadata
m.length = 0
rg_node = release_node['release-group']
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'] = len(release_node['media'])
# 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, release_node):
log.debug("Loading release %r ...", self.id)
self._tracks_loaded = False
release_id = release_node['id']
if release_id != self.id:
self.tagger.mbid_redirects[self.id] = release_id
album = self.tagger.albums.get(release_id)
if album:
log.debug("Release %r already loaded", release_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_id] = self
self.id = release_id
# Get release metadata
m = self._new_metadata
m.length = 0
rg_node = release_node['release-group']
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'] = len(release_node['media'])
# 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_releases(self, releases):
for node in releases:
release = Metadata()
release_to_metadata(node, release)
rg_node = node['release-group']
release_group_to_metadata(rg_node, release)
if "media" in node:
media = node['media']
release["format"] = media_formats_from_node(media)
release["tracks"] = node['track-count']
countries = country_list_from_node(node)
if countries:
release["country"] = ", ".join(countries)
self.search_results.append(release)
def parse_releases(self, releases):
for node in releases:
release = Metadata()
release_to_metadata(node, release)
release['score'] = node['score']
rg_node = node['release-group']
release_group_to_metadata(rg_node, release)
if "media" in node:
media = node['media']
release["format"] = media_formats_from_node(media)
release["tracks"] = node['track-count']
countries = countries_from_node(node)
if countries:
release["country"] = ", ".join(countries)
self.search_results.append(release)
def parse_tracks(self, tracks):
for node in tracks:
if "releases" in node:
for rel_node in node['releases']:
track = Metadata()
recording_to_metadata(node, track)
release_to_metadata(rel_node, track)
rg_node = rel_node['release-group']
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 test_release(self):
m = Metadata()
a = Album("1")
release_to_metadata(self.json_doc, m, a)
self.assertEqual(m['album'], 'The Dark Side of the Moon')
self.assertEqual(m['albumartist'], 'Pink Floyd')
self.assertEqual(m['albumartistsort'], 'Pink Floyd')
self.assertEqual(m['asin'], 'b123')
self.assertEqual(m['barcode'], '123')
self.assertEqual(m['catalognumber'], 'SHVL 804')
self.assertEqual(m['date'], '1973-03-24')
self.assertEqual(m['label'], 'Harvest')
self.assertEqual(m['musicbrainz_albumartistid'], '83d91898-7763-47d7-b03b-b92132375c47')
self.assertEqual(m['musicbrainz_albumid'], 'b84ee12a-09ef-421b-82de-0441a926375b')
self.assertEqual(m['releasecountry'], 'GB')
self.assertEqual(m['releasestatus'], 'official')
self.assertEqual(m['script'], 'Latn')
self.assertEqual(m['~albumartists'], 'Pink Floyd')
self.assertEqual(m['~albumartists_sort'], 'Pink Floyd')
self.assertEqual(m['~releaselanguage'], 'eng')
self.assertEqual(a.folksonomy_tags, {'test2': 3, 'test': 6})
def parse_tracks(self, tracks):
for node in tracks:
if "releases" in node:
for rel_node in node['releases']:
track = Metadata()
recording_to_metadata(node, track)
track['score'] = node['score']
release_to_metadata(rel_node, track)
rg_node = rel_node['release-group']
release_group_to_metadata(rg_node, track)
countries = countries_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['score'] = node['score']
track["album"] = _("Standalone Recording")
self.search_results.append((track, node))
def test_preferred_release_country(self):
m = Metadata()
a = Album("1")
release_to_metadata(self.json_doc, m, a)
self.assertEqual(m['releasecountry'], 'GB')
config.setting['preferred_release_countries'] = ['NZ', 'GB']
release_to_metadata(self.json_doc, m, a)
self.assertEqual(m['releasecountry'], 'NZ')
config.setting['preferred_release_countries'] = ['GB', 'NZ']
release_to_metadata(self.json_doc, m, a)
self.assertEqual(m['releasecountry'], 'GB')
def test_release(self):
m = Metadata()
a = Album("1")
release_to_metadata(self.json_doc, m, a)
self.assertEqual(m, {})
def test_release(self):
m = Metadata()
a = Album("1")
release_to_metadata(self.json_doc, m, a)
self.assertEqual(m, {})
def _parse_release(self, release_node):
log.debug("Loading release %r ...", self.id)
self._tracks_loaded = False
release_id = release_node['id']
if release_id != self.id:
self.tagger.mbid_redirects[self.id] = release_id
album = self.tagger.albums.get(release_id)
if album:
log.debug("Release %r already loaded", release_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_id] = self
self.id = release_id
# Make the release artist nodes available, since they may
# contain supplementary data (aliases, tags, genres, ratings)
# which aren't present in the release group, track, or
# recording artist nodes. We can copy them into those places
# wherever the IDs match, so that the data is shared and
# available for use in mbjson.py and external plugins.
self._release_artist_nodes = _create_artist_node_dict(release_node)
# Get release metadata
m = self._new_metadata
m.length = 0
rg_node = release_node['release-group']
rg = self.release_group = self.tagger.get_release_group_by_id(rg_node['id'])
rg.loaded_albums.add(self.id)
rg.refcount += 1
_copy_artist_nodes(self._release_artist_nodes, rg_node)
release_group_to_metadata(rg_node, rg.metadata, rg)
m.copy(rg.metadata)
release_to_metadata(release_node, m, album=self)
# 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'] = len(release_node['media'])
# 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 BaseException:
self.error_append(traceback.format_exc())
self._release_node = release_node
return True
def _parse_release(self, release_node):
log.debug("Loading release %r ...", self.id)
self._tracks_loaded = False
release_id = release_node['id']
if release_id != self.id:
self.tagger.mbid_redirects[self.id] = release_id
album = self.tagger.albums.get(release_id)
if album:
log.debug("Release %r already loaded", release_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_id] = self
self.id = release_id
# Make the release artist nodes available, since they may
# contain supplementary data (aliases, tags, genres, ratings)
# which aren't present in the release group, track, or
# recording artist nodes. We can copy them into those places
# wherever the IDs match, so that the data is shared and
# available for use in mbjson.py and external plugins.
self._release_artist_nodes = _create_artist_node_dict(release_node)
# Get release metadata
m = self._new_metadata
m.length = 0
rg_node = release_node['release-group']
rg = self.release_group = self.tagger.get_release_group_by_id(rg_node['id'])
rg.loaded_albums.add(self.id)
rg.refcount += 1
_copy_artist_nodes(self._release_artist_nodes, rg_node)
release_group_to_metadata(rg_node, rg.metadata, rg)
m.copy(rg.metadata)
release_to_metadata(release_node, m, album=self)
# 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'] = len(release_node['media'])
# 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 BaseException:
self.error_append(traceback.format_exc())
self._release_node = release_node
return True
