def _writeRelation(self, xml, rel, targetType):
relAttrs = ' '.join([mbutils.extractFragment(a)
for a in rel.getAttributes()])
if relAttrs == '':
relAttrs = None
attrs = {
'type': mbutils.extractFragment(rel.getType()),
'target': rel.getTargetId(),
'direction': rel.getDirection(),
'begin': rel.getBeginDate(),
'end': rel.getBeginDate(),
'attributes': relAttrs,
}
if rel.getTarget() is None:
xml.elem('relation', None, attrs)
else:
xml.start('relation', attrs)
if targetType == NS_REL_1 + 'Artist':
self._writeArtist(xml, rel.getTarget())
elif targetType == NS_REL_1 + 'Release':
self._writeRelease(xml, rel.getTarget())
elif targetType == NS_REL_1 + 'Track':
self._writeTrack(xml, rel.getTarget())
xml.end()
def __init__(self, aliases=False, releases=(), vaReleases=(),
artistRelations=False, releaseRelations=False,
trackRelations=False, urlRelations=False, tags=False,
ratings=False, releaseGroups=False):
assert not isinstance(releases, basestring)
assert not isinstance(vaReleases, basestring)
assert len(releases) == 0 or len(vaReleases) == 0
self._includes = {
'aliases': aliases,
'artist-rels': artistRelations,
'release-groups': releaseGroups,
'release-rels': releaseRelations,
'track-rels': trackRelations,
'url-rels': urlRelations,
'tags': tags,
'ratings': ratings,
}
for elem in releases:
self._includes['sa-' + mbutils.extractFragment(elem)] = True
for elem in vaReleases:
self._includes['va-' + mbutils.extractFragment(elem)] = True
def testExtractFragment(self): fragment = 'Album' uri = m.NS_MMD_1 + fragment self.assertEquals(u.extractFragment(None), None) self.assertEquals(u.extractFragment(fragment), fragment) self.assertEquals(u.extractFragment(uri), fragment) self.assertEquals(u.extractFragment(uri, m.NS_MMD_1), fragment) prefix = 'http://example.invalid/' self.assertRaises(ValueError, u.extractFragment, uri, prefix)
def _writeLabel(self, xml, label, score=None):
if label is None:
return
xml.start('label', {
'id': mbutils.extractUuid(label.getId()),
'type': mbutils.extractFragment(label.getType()),
'ext:score': score,
})
xml.elem('name', label.getName())
xml.elem('sort-name', label.getSortName())
xml.elem('disambiguation', label.getDisambiguation())
xml.elem('life-span', None, {
'begin': label.getBeginDate(),
'end': label.getEndDate(),
})
if len(label.getAliases()) > 0:
xml.start('alias-list')
for alias in label.getAliases():
xml.elem('alias', alias.getValue(), {
'type': alias.getType(),
'script': alias.getScript(),
})
xml.end()
# TODO: releases, artists
self._writeRelationList(xml, label)
# TODO: extensions
xml.end()
def _writeRelationList(self, xml, entity):
for tt in entity.getRelationTargetTypes():
xml.start('relation-list', {
'target-type': mbutils.extractFragment(tt),
})
for rel in entity.getRelations(targetType=tt):
self._writeRelation(xml, rel, tt)
xml.end()
def __init__(self, title=None, discId=None, releaseTypes=None,
artistName=None, artistId=None, limit=None,
offset=None, query=None, trackCount=None):
"""Constructor.
If C{discId} or C{artistId} are set, only releases matching
those IDs are returned. The C{releaseTypes} parameter allows
to limit the types of the releases returned. You can set it to
C{(Release.TYPE_ALBUM, Release.TYPE_OFFICIAL)}, for example,
to only get officially released albums. Note that those values
are connected using the I{AND} operator. MusicBrainz' support
is currently very limited, so C{Release.TYPE_LIVE} and
C{Release.TYPE_COMPILATION} exclude each other (see U{the
documentation on release attributes
<http://wiki.musicbrainz.org/AlbumAttribute>} for more
information and all valid values).
If both the C{artistName} and the C{artistId} parameter are
given, the server will ignore C{artistName}.
The C{query} parameter may contain a query in U{Lucene syntax
<http://lucene.apache.org/java/docs/queryparsersyntax.html>}.
Note that C{query} may not be used together with the other
parameters except for C{limit} and C{offset}.
@param title: a unicode string containing the release's title
@param discId: a unicode string containing the DiscID
@param releaseTypes: a sequence of release type URIs
@param artistName: a unicode string containing the artist's name
@param artistId: a unicode string containing the artist's ID
@param limit: the maximum number of releases to return
@param offset: start results at this zero-based offset
@param query: a string containing a query in Lucene syntax
@param trackCount: the number of tracks in the release
@see: the constants in L{musicbrainz2.model.Release}
"""
if releaseTypes is None or len(releaseTypes) == 0:
releaseTypesStr = None
else:
tmp = [ mbutils.extractFragment(x) for x in releaseTypes ]
releaseTypesStr = ' '.join(tmp)
self._params = [
('title', title),
('discid', discId),
('releasetypes', releaseTypesStr),
('artist', artistName),
('artistid', mbutils.extractUuid(artistId)),
('limit', limit),
('offset', offset),
('query', query),
('count', trackCount),
]
if not _paramsValid(self._params):
raise ValueError('invalid combination of parameters')
def tagTrack(self, todoEntry): import eyeD3 fileName = todoEntry['mp3file'] + '.tmp' release = todoEntry['release'] track = todoEntry['track'] tag = eyeD3.Tag() tag.link(str(fileName)) # eyeD3 doesn't like unicode strings tag.header.setVersion(eyeD3.ID3_V2) if track.artist is None: tag.setArtist(release.artist.name) else: tag.setArtist(track.artist.name) tag.setTitle(track.title) tag.setAlbum(release.title) tag.setTrackNum( (todoEntry['num'], len(release.tracks)) ) types = (release.TYPE_OFFICIAL, release.TYPE_PROMOTION, release.TYPE_BOOTLEG) for t in release.types: value = extractFragment(t, NS_MMD_1) if t in types: tag.addUserTextFrame(ALBUM_TYPE, value) else: tag.addUserTextFrame(ALBUM_STATUS, value) tag.addUserTextFrame(ALBUM_ARTIST, release.artist.name) tag.addUserTextFrame(ALBUM_ARTIST_SORTNAME, release.artist.sortName) tag.addUniqueFileID(FILE_ID, str(extractUuid(track.id))) if track.artist is None: tag.addUserTextFrame(ARTIST_ID, extractUuid(release.artist.id)) else: tag.addUserTextFrame(ARTIST_ID, extractUuid(track.artist.id)) tag.addUserTextFrame(ALBUM_ID, extractUuid(release.id)) tag.addUserTextFrame(ALBUM_ARTIST_ID, extractUuid(release.artist.id)) event = release.getEarliestReleaseEvent() if event is not None: tag.addUserTextFrame(RELEASE_COUNTRY, event.country) tag.setDate(event.date[0:4]) tag.update(eyeD3.ID3_V2_3)
def _writeRelease(self, xml, release, score=None):
if release is None:
return
types = [mbutils.extractFragment(t) for t in release.getTypes()]
typesStr = None
if len(types) > 0:
typesStr = ' '.join(types)
xml.start('release', {
'id': mbutils.extractUuid(release.getId()),
'type': typesStr,
'ext:score': score,
})
xml.elem('title', release.getTitle())
xml.elem('text-representation', None, {
'language': release.getTextLanguage(),
'script': release.getTextScript()
})
xml.elem('asin', release.getAsin())
self._writeArtist(xml, release.getArtist())
self._writeReleaseGroup(xml, release.getReleaseGroup())
if len(release.getReleaseEvents()) > 0:
xml.start('release-event-list')
for event in release.getReleaseEvents():
self._writeReleaseEvent(xml, event)
xml.end()
if len(release.getDiscs()) > 0:
xml.start('disc-list')
for disc in release.getDiscs():
xml.elem('disc', None, { 'id': disc.getId() })
xml.end()
if len(release.getTracks()) > 0:
# TODO: count attribute
xml.start('track-list', {
'offset': release.getTracksOffset()
})
for track in release.getTracks():
self._writeTrack(xml, track)
xml.end()
self._writeRelationList(xml, release)
# TODO: extensions
xml.end()
def _writeArtist(self, xml, artist, score=None):
if artist is None:
return
xml.start('artist', {
'id': mbutils.extractUuid(artist.getId()),
'type': mbutils.extractFragment(artist.getType()),
'ext:score': score,
})
xml.elem('name', artist.getName())
xml.elem('sort-name', artist.getSortName())
xml.elem('disambiguation', artist.getDisambiguation())
xml.elem('life-span', None, {
'begin': artist.getBeginDate(),
'end': artist.getEndDate(),
})
if len(artist.getAliases()) > 0:
xml.start('alias-list')
for alias in artist.getAliases():
xml.elem('alias', alias.getValue(), {
'type': alias.getType(),
'script': alias.getScript(),
})
xml.end()
if len(artist.getReleases()) > 0:
xml.start('release-list')
for release in artist.getReleases():
self._writeRelease(xml, release)
xml.end()
if len(artist.getReleaseGroups()) > 0:
xml.start('release-group-list')
for releaseGroup in artist.getReleaseGroups():
self._writeReleaseGroup(xml, releaseGroup)
xml.end()
self._writeRelationList(xml, artist)
# TODO: extensions
xml.end()
def _writeReleaseGroup(self, xml, rg, score = None):
if rg is None:
return
xml.start('release-group', {
'id': mbutils.extractUuid(rg.getId()),
'type': mbutils.extractFragment(rg.getType()),
'ext:score': score,
})
xml.elem('title', rg.getTitle())
self._writeArtist(xml, rg.getArtist())
if len(rg.getReleases()) > 0:
xml.start('release-list')
for rel in rg.getReleases():
self._writeRelease(xml, rel)
xml.end()
xml.end()
