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()