Esempio n. 1
0
    def getReleases(self, artistResult):
        q = Query()

        offset = 0
        limit = 100
        releaseResults = set()
        while True:
            try:
                f = ReleaseFilter(artistId=artistResult.getKey(
                    MusicbrainzSource._sourceName),
                                  offset=offset,
                                  limit=limit)
                results = q.getReleases(f)
            except WebServiceError, e:
                raise SourceError

            count = len(results)

            results = filter(lambda res: res.getScore() == 100, results)

            for r in results:
                rr = ReleaseResult(
                    title=r.getRelease().getTitle(),
                    date=r.getRelease().getEarliestReleaseDate(),
                    tracksCount=r.getRelease().getTracksCount())
                rr.setKey(MusicbrainzSource._sourceName,
                          r.getRelease().getId())
                releaseResults.add(rr)

            if count < limit:
                break
            offset += count
Esempio n. 2
0
    def getReleases(self, artistResult):
        q = Query()

        offset = 0
        limit = 100
        releaseResults = set()
        while True:
            try:
                f = ReleaseFilter(artistId = 
                        artistResult.getKey(MusicbrainzSource._sourceName),
                        offset = offset, limit = limit)
                results = q.getReleases(f)
            except WebServiceError, e:
                raise SourceError

            count = len(results)

            results = filter(lambda res: res.getScore() == 100, results)

            for r in results:
                rr = ReleaseResult(title = r.getRelease().getTitle(),
                        date = r.getRelease().getEarliestReleaseDate(),
                        tracksCount = r.getRelease().getTracksCount())
                rr.setKey(MusicbrainzSource._sourceName, r.getRelease().getId())
                releaseResults.add(rr)

            if count < limit:
                break
            offset += count
Esempio n. 3
0
    def FetchTrackListByArtistRelease(self, string_artist_name, string_release_name):
      musicbrainz_query = Query()
      try:
        # Search for all releases matching the given name. Limit the results
        # to the first best matches.

        string_release_id = ""
        string_release_title = ""

        musicbrainz_release_filter = ReleaseFilter(title=string_release_name, artistName=string_artist_name, limit=1)
        musicbrainz_release_results = musicbrainz_query.getReleases(musicbrainz_release_filter)
        if musicbrainz_release_results is not None:
          if len(musicbrainz_release_results) > 0:
            string_release_id = musicbrainz_release_results[0].getRelease().getId()
            string_release_title = musicbrainz_release_results[0].getRelease().getTitle()
            include_info = ReleaseIncludes(artist=True, tracks=True)
            release = self.__musicbrainz_query__.getReleaseById(string_release_id, include_info)

            track_list = []

            for track in release.getTracks():
                track_title = track.getTitle()
                for escape_char in self.__escape_list__:
                    track_title = track_title.replace(escape_char, "")
                track_list.append(track_title)

        return string_release_title, track_list

      except WebServiceError, e:
          # print 'Error:', e
          return []
Esempio n. 4
0
 def populate_album_set(self):
     """
     Find and create models for all albums released by this artist.
     Only albums with an Amazon ASIN are imported, to try and stop the
     database getting clogged up with b-sides, remixes, and bonus
     material.
     """
     # We can't do anything without the MusicBrainz and Last.fm libraries.
     try:
         ReleaseFilter
     except NameError:
         return False
     # Find any official album release held by MusicBrainz for this artist.
     filter = ReleaseFilter(artistName=self.name,
                            releaseTypes=(Release.TYPE_ALBUM,
                                          Release.TYPE_OFFICIAL))
     query = Query()
     releases = query.getReleases(filter)
     for release in releases:
         album = release.release
         # Only import albums with an Amazon ASIN.  That allows for some
         # quality-control as Music Brainz lists every B-side and bonus
         # material you can think of.
         if album.asin:
             # First try and find an already-existing album with this ASIN
             # As an ASIN is unique it means we'll find it even if the fields
             # have been changed since creation.
             try:
                 db_album = Album.objects.get(asin=album.asin)
             except Album.DoesNotExist:
                 db_album = Album(artist=self,
                                  title=album.title,
                                  asin=album.asin,
                                  mbid=album.id.rsplit("/", 1)[1])
                 # MusicBrainz stores releases dates for as many countries as
                 # it can.  I'm only interested in Britain though, so look
                 # for that first.  As a fallback, us the world wide release
                 # date (XE) or the US release date.
                 release_dates = dict(
                     (r.country, r.date) for r in album.releaseEvents)
                 if release_dates:
                     # GB = United Kingdom, XE = world, US = United States.
                     for country in ('GB', 'XE', 'US'):
                         if release_dates.has_key(country):
                             db_album.released_in = country
                             # The release date can be in the format "2010",
                             # "2010-02", or "2010-02-18", so make up the
                             # missing month and/or day so a proper release
                             # date object can be created.
                             release_date = release_dates[country]
                             date_list = map(int, release_date.split('-'))
                             try:
                                 db_album.release_date = datetime.date(
                                     *date_list + [1] *
                                     (3 - len(date_list)))
                             except ValueError:
                                 pass  # Date couldn't be parsed.
                             break
                 db_album.save()
Esempio n. 5
0
def find_artist_and_title(puid):
    q = Query()
    try:
        f = TrackFilter(puid=sys.argv[1])
        results = q.getTracks(f)
    except WebServiceError, e:
        print 'Error:', e
        sys.exit(1)
Esempio n. 6
0
 def __init__(self, wait=1):
     if not os.path.isdir('cache'):
         os.mkdir('cache')
         os.mkdir(os.path.join('cache', 'artist_q'))
         os.mkdir(os.path.join('cache', 'release_q'))
         os.mkdir(os.path.join('cache', 'track_q'))
     self.wait = wait
     self.last_called = time.time()
     Query.__init__(self)
Esempio n. 7
0
	def __init__(self,wait=1) :
		if not os.path.isdir(CACHE_DIR) :
			os.mkdir(CACHE_DIR)
			os.mkdir(os.path.join(CACHE_DIR,'artist_q'))
			os.mkdir(os.path.join(CACHE_DIR,'release_q'))
			os.mkdir(os.path.join(CACHE_DIR,'track_q'))
		self.wait = wait
		self.last_called = time.time()
		Query.__init__(self)
Esempio n. 8
0
 def populate_album_set(self):
     """
     Find and create models for all albums released by this artist.
     Only albums with an Amazon ASIN are imported, to try and stop the
     database getting clogged up with b-sides, remixes, and bonus
     material.
     """
     # We can't do anything without the MusicBrainz and Last.fm libraries.
     try:
         ReleaseFilter
     except NameError:
         return False
     # Find any official album release held by MusicBrainz for this artist.
     filter = ReleaseFilter(artistName=self.name, releaseTypes=(Release.TYPE_ALBUM,
         Release.TYPE_OFFICIAL))
     query = Query()
     releases = query.getReleases(filter)
     for release in releases:
         album = release.release
         # Only import albums with an Amazon ASIN.  That allows for some
         # quality-control as Music Brainz lists every B-side and bonus
         # material you can think of.
         if album.asin:
             # First try and find an already-existing album with this ASIN
             # As an ASIN is unique it means we'll find it even if the fields
             # have been changed since creation.
             try:
                 db_album = Album.objects.get(asin=album.asin)
             except Album.DoesNotExist:
                 db_album = Album(artist=self, title=album.title,
                     asin=album.asin, mbid=album.id.rsplit("/", 1)[1])
                 # MusicBrainz stores releases dates for as many countries as
                 # it can.  I'm only interested in Britain though, so look
                 # for that first.  As a fallback, us the world wide release
                 # date (XE) or the US release date.
                 release_dates = dict((r.country, r.date)
                     for r in album.releaseEvents)
                 if release_dates:
                     # GB = United Kingdom, XE = world, US = United States.
                     for country in ('GB', 'XE', 'US'):
                         if release_dates.has_key(country):
                             db_album.released_in = country
                             # The release date can be in the format "2010",
                             # "2010-02", or "2010-02-18", so make up the
                             # missing month and/or day so a proper release
                             # date object can be created.
                             release_date = release_dates[country]
                             date_list = map(int, release_date.split('-'))
                             try:
                                 db_album.release_date = datetime.date(
                                     *date_list + [1] * (3 - len(date_list)))
                             except ValueError:
                                 pass  # Date couldn't be parsed.
                             break
                 db_album.save()
Esempio n. 9
0
	def lookup_puid(self,_puid):
		q = Query()
		f = TrackFilter(puid=_puid)
		try :
			r = q.getTracks(f)
			track = r[0].track
			return track
		except:
			print 'MusicBrainz::lookup_puid: Error finding track metadata.'
			# raise AssertionError('MusicBrainz::lookup_puid: Error finding track metadata.')
			return None
Esempio n. 10
0
 def lookup_puid(self, _puid):
     q = Query()
     f = TrackFilter(puid=_puid)
     try:
         r = q.getTracks(f)
         track = r[0].track
         return track
     except:
         print 'MusicBrainz::lookup_puid: Error finding track metadata.'
         # raise AssertionError('MusicBrainz::lookup_puid: Error finding track metadata.')
         return None
Esempio n. 11
0
	def testRemoveFromUserCollection(self):
		ws = FakeWebService()
		q = Query(ws)

		r1 = "9e186398-9ae2-45bf-a9f6-d26bc350221e"
		r2 = "http://musicbrainz.org/release/6b050dcf-7ab1-456d-9e1b-c3c41c18eed2"
		r3 = Release("d3cc336e-1010-4252-9091-7923f0429824")

		q.removeFromUserCollection([r1, r2, r3])
		self.assertEquals(len(ws.data), 1)
		res = ws.data[0]
		self.assertEquals(res[0], "collection")
		self.assertEquals(res[2], "remove=9e186398-9ae2-45bf-a9f6-d26bc350221e%2C6b050dcf-7ab1-456d-9e1b-c3c41c18eed2%2Cd3cc336e-1010-4252-9091-7923f0429824")
Esempio n. 12
0
	def testSubmitPuid(self):
		tracks2puids = {
					    '6a47088b-d9e0-4088-868a-394ee3c6cd33':'c2a2cee5-a8ca-4f89-a092-c3e1e65ab7e6', 
					    'b547acbc-58c6-4a31-9806-e2348db3a167':'c2a2cee5-a8ca-4f89-a092-c3e1e65ab7e6'
		}
		ws = FakeWebService()
		q = Query(ws, clientId='test-1')
		
		q.submitPuids(tracks2puids)
		
		self.assertEquals(len(ws.data), 1)
		req = ws.data[0]
		qstring = 'client=test-1&puid=6a47088b-d9e0-4088-868a-394ee3c6cd33+c2a2cee5-a8ca-4f89-a092-c3e1e65ab7e6&puid=b547acbc-58c6-4a31-9806-e2348db3a167+c2a2cee5-a8ca-4f89-a092-c3e1e65ab7e6'
		self.assertEquals(req[0], 'track')
		self.assertEquals(req[2], qstring)
Esempio n. 13
0
	def testSubmitIsrc(self):
		tracks2isrcs = {
					    '6a47088b-d9e0-4088-868a-394ee3c6cd33':'NZABC0800001', 
					    'b547acbc-58c6-4a31-9806-e2348db3a167':'NZABC0800002'
		}
		ws = FakeWebService()
		q = Query(ws)
		
		q.submitISRCs(tracks2isrcs)
		
		self.assertEquals(len(ws.data), 1)
		req = ws.data[0]
		qstring = 'isrc=6a47088b-d9e0-4088-868a-394ee3c6cd33+NZABC0800001&isrc=b547acbc-58c6-4a31-9806-e2348db3a167+NZABC0800002'
		self.assertEquals(req[0], 'track')
		self.assertEquals(req[2], qstring)
Esempio n. 14
0
def find_releases(puid):
    """Given a track's puid, return a list of
      (track-no, track, release)
    for each release that the song appeared on on."""
    query = Query()
    trackfilter = TrackFilter(puid=puid)
    results = query.getTracks(trackfilter)

    out = []
    for result in results:
        track = result.track
        rels = track.getReleases()
        assert len(rels) == 1
        rel = rels[0]
        out.append((rel.getTracksOffset()+1, track, rel))
    return out
Esempio n. 15
0
 def __init__(self, username, password, server='https://musicbrainz.org'):
     self.user_agent = 'zeroinch-bot/1.0 ( %s/user/%s )' % (server,
                                                            username)
     self.ws = WebService(userAgent=self.user_agent,
                          host=re.sub(r'^http://', '', server),
                          username=username,
                          password=password)
     self.q = Query(self.ws)
Esempio n. 16
0
def find_releases(puid):
    """
	Given a track's puid, return a list of
	(track-no, track, release)
	for each release that the song appeared on on.
	"""
    service = get_service()
    q = Query(service)
    f = TrackFilter(puid=puid)
    results = None
    while results == None:
        try:
            results = q.getTracks(f)
        except WebServiceError, e:
            print "!! WebServiceError: ", e
            print "!! Retry in 5 seconds..."
            time.sleep(5)
Esempio n. 17
0
def print_release(mbid):
	q = Query()
	i = ReleaseIncludes(
		artist=True,
		tracks=True,
		urlRelations=True
	)

	rel = q.getReleaseById(mbid, i)
	if not rel:
		print 'Not found :/'
		return

	print 'Title:  %s' % rel.title
	print 'Artist: %s' % rel.artist.name
	print ''
	for no, trk in enumerate(rel.tracks):
		print '	  %d. %s' % ((no+1), trk.title)
Esempio n. 18
0
def guess_release(folder, files):
	nfiles = []
	cache = musicdns.cache.MusicDNSCache()
	print "Fingerprinting..."
	for fn in files:
		try:
			puid, _ = cache.getpuid(fn, MUSICDNS_KEY)
		except IOError:
			puid = None
		track = filename_track_number(fn)
		nfiles += [(track, fn, puid)]
	nfiles.sort()

	matchrel = defaultdict(int)
	for i, (no, fn, puid) in enumerate(nfiles):
		print 'Asking MusicBrainz about ' + basename(fn)
		if puid is None:
			continue
		for tno, track, release in find_releases(puid):
			included = 0
			if no == tno:
				matchrel[release.id] += 1
				included = 1
			print u'	%d - %s - %s %s' % (tno, track.title, release.title, ' <=' if included else '')

	q = Query()
	i = ReleaseIncludes(
		artist=True,
		tracks=True,
		urlRelations=True
	)
	releaseids = sorted(matchrel.iteritems(), key=itemgetter(1), reverse=1)

	if not releaseids:
		return None

	releases = None
	while not releases:
		try:
			releases = [(q.getReleaseById(rid, i), freq) for rid, freq in releaseids]
		except WebServiceError, e:
			print '!! WebServiceError: ', e
			print '!! Retry in 5 seconds...'
			time.sleep(5)
Esempio n. 19
0
def show_release():
    from musicbrainz2.webservice import Query, ArtistFilter, WebServiceError

    import string
    import musicbrainz2.webservice as ws
    import musicbrainz2.model as m
    import musicbrainz2.utils as u
	
    q = Query()
    inc = ws.ReleaseIncludes(artist=True, releaseEvents=True, labels=True,
                                 discs=True, tracks=True)
    rid = u'http://musicbrainz.org/release/52ec1af7-28a1-42e3-896a-0eddc8e338d5.html'
    release = q.getReleaseById(rid, inc)
    tracks = release.tracks
    
    for t in tracks:
        #print dir(t)
        minutes,seconds = divmod(t.duration/1000,60)
        print t.title, '-', string.join([str(minutes),':',str(seconds)],'')
Esempio n. 20
0
def main(argv=None):
	if argv==None:
		argv=sys.argv
	
	q = Query()
	
	conn = sqlite3.connect('db/mu_trumps.sqlite3')
	c = conn.cursor()
	insert_cursor = conn.cursor()
	c.execute('select * from artists')
	
	for artist_id, created, modified, artist_name, artist_url in c:
		try:
			# Search for all artists matching the given name. Limit the results
			# to the best match. 
			f = ArtistFilter(name=artist_name, limit=5)
			artistResults = q.getArtists(f)
		except WebServiceError, e:
			print 'Error:', e
			if "HTTP Error 503" in str(e):
				print "taking a rest..."
				sleep(SLEEP_TIME*10)
			continue
		try:
			mbz_id = artistResults[0].artist.id
		except IndexError:
			print "Could not find a musicbrainz id for the artist", artist_name, "moving on..."
			continue
		if VERBOSE:
			print "For artist", artist_name, "found id", artist_id
		try:
			# The result should include all official albums.
			#
			inc = ws.ArtistIncludes(
				releases=(m.Release.TYPE_OFFICIAL, m.Release.TYPE_ALBUM),
				tags=True, releaseGroups=True)
			artist = q.getArtistById(mbz_id, inc)
		except ws.WebServiceError, e:
			print 'Error:', e
			if "HTTP Error 503" in str(e):
				print "taking a rest..."
				sleep(SLEEP_TIME*10)
			continue
Esempio n. 21
0
def find_album_name( track_details ):
    """Find album name via Musicbrainz API

    Arguments:

    track_details -- dict containing 'Title' and 'Artist'

    Returns album name, empty string if unsuccessful.

    """

    album = ""

    # Musicbrainz limits API calls to one per second from a specific IP
    time.sleep(1.1)

    query = Query()

    # Loop through at most 9 times as the webservice is occasionally busy.
    # Results will not be None if is successful
    i = 1
    results = None
    while (results == None) and (i < 10):
        try:
            tracks = TrackFilter(title=track_details['Title'], 
                                 artistName=track_details['Artist'])
            results = query.getTracks(tracks)
        except (AuthenticationError,
                ConnectionError,
                RequestError,
                ResponseError,
                ResourceNotFoundError,
                WebServiceError) as error:
            print('Error:', error, 'waiting', i*10, 'seconds')
            time.sleep(i*10)
            i += 1
            results = None

    if (results != None) and (len(results) != 0):
        album = find_preferred_album( results )

    return album
Esempio n. 22
0
 def get_musicbrainz_id(self):
     """
     Retrieve the MusicBrainz id for this artist and save it on the
     model.
     """
     # Make sure the useful bits of the musicbrainz2 package have been
     # imported.
     try:
         Query, ArtistFilter
     except NameError:
         return False
     # Query MusicBrainz.
     artist_filter = ArtistFilter(name=self.name)
     query = Query()
     try:
         artist = query.getArtists(artist_filter)[0].artist
         self.mbid = artist.id.rsplit("/", 1)[1]
         self.save()
     except (IndexError, AttributeError):
         return False
Esempio n. 23
0
 def sanitize_with_musicBrainz(self):
     titleName = self['title']
     artistName = self['artist']
     albumName = self['album']
     q = Query()
     try:
         logging.debug("Querying with title:{},artist:{},album:{}"
         .format(titleName, artistName, albumName))
         f = TrackFilter(title=titleName, artistName=artistName,
         releaseTitle=albumName, limit=2)
         results = q.getTracks(f)
         logging.debug("results are " + str(results))
     except WebServiceError as e:
         logging.error("Failed to contact musicbrainz server.")
         if str(e)[:15]=="HTTP Error 503:":
             logging.info("Pausing for a moment, \
             the musicbrainz server doesn't handle too much request")
             sleep(60)
         return self.sanitize_with_musicBrainz()
     self.treat_musicbrainz_result(results)
Esempio n. 24
0
def get_puid_tags(puid):
    """Returns a list of `TagGroup` elements, matching the song's puid"""
    
    global _lastServerCall
    # wait at least a second
    while True:
        currentTime = time.time()
        if currentTime >= _lastServerCall+1:
            _lastServerCall = currentTime
            break
        time.sleep(0.05)

    q = Query()
    res = []
    try:
        f = TrackFilter(puid=puid)
        results = q.getTracks(f)
    except WebServiceError, e:
        print e
        return None
Esempio n. 25
0
 def get_musicbrainz_id(self):
     """
     Retrieve the MusicBrainz id for this artist and save it on the
     model.
     """
     # Make sure the useful bits of the musicbrainz2 package have been
     # imported.
     try:
         Query, ArtistFilter
     except NameError:
         return False
     # Query MusicBrainz.
     artist_filter = ArtistFilter(name=self.name)
     query = Query()
     try:
         artist = query.getArtists(artist_filter)[0].artist
         self.mbid = artist.id.rsplit("/", 1)[1]
         self.save()
     except (IndexError, AttributeError):
         return False
Esempio n. 26
0
class mbzAPI:
    def __init__(self):
        self.q = Query()

    def findArtists(self, artist, limit = 20):
        try:
            aFilter = ArtistFilter(artist, limit)
            return self.q.getArtists(aFilter)
        except WebServiceError, e:
            # Logging Need
            return None
Esempio n. 27
0
    def getArtists(self, name, date=None, disambiguation=None):
        q = Query()

        if disambiguation:
            disPattern = re.compile(disambiguation, re.I)
        else:
            disPattern = None

        offset = 0
        limit = 100
        artistResults = set()
        while True:
            try:
                f = ArtistFilter(name=name, offset=offset, limit=limit)
                results = q.getArtists(f)
            except WebServiceError, e:
                raise SourceError

            results = filter(lambda res: res.getScore() == 100, results)
            # use filtered count because resulsts are score-ordered
            count = len(results)

            results = filter(
                lambda res:
                (not date or res.getArtist().getBeginDate() == date) and
                (not disPattern or disPattern.search(res.getArtist(
                ).getDisambiguation())), results)

            for r in results:
                ar = ArtistResult(name=r.getArtist().getName(),
                                  date=r.getArtist().getBeginDate(),
                                  disambiguation=disambiguation)
                # use original disambiguation cause it'll be used in
                # artist's comparation

                ar.setKey(MusicbrainzSource._sourceName, r.getArtist().getId())
                artistResults.add(ar)

            if count < limit:
                break
            offset += count
Esempio n. 28
0
    def getArtists(self, name, date = None, disambiguation = None):
        q = Query()

        if disambiguation:
            disPattern = re.compile(disambiguation, re.I)
        else:
            disPattern = None

        offset = 0
        limit = 100
        artistResults = set()
        while True:
            try:
                f = ArtistFilter(name = name, offset = offset, limit = limit)
                results = q.getArtists(f)
            except WebServiceError, e:
                raise SourceError

            results = filter(lambda res: res.getScore() == 100, results)
            # use filtered count because resulsts are score-ordered
            count = len(results)

            results = filter(lambda res: 
                    (not date or res.getArtist().getBeginDate() == date)
                    and ( not disPattern or
                        disPattern.search(res.getArtist().getDisambiguation()) ),
                    results)

            for r in results:
                ar = ArtistResult(name = r.getArtist().getName(),
                        date = r.getArtist().getBeginDate(),
                        disambiguation = disambiguation)
                        # use original disambiguation cause it'll be used in 
                        # artist's comparation

                ar.setKey(MusicbrainzSource._sourceName, r.getArtist().getId())
                artistResults.add(ar)

            if count < limit:
                break
            offset += count
Esempio n. 29
0
    def guess_release(self, folder, files):
        nfiles = []
        print "Fingerprinting..."
        for fn in files:
            try:
                puid, _ = self.cache.getpuid(fn, self.musicdns_key)
            except IOError:
                puid = None
            track = filename_track_number(fn)
            nfiles += [(track, fn, puid)]
        nfiles.sort()

        matchrel = defaultdict(int)
        for i, (no, fn, puid) in enumerate(nfiles):
            print "Asking MusicBrainz about " + basename(fn)
            if puid is None:
                continue
            for tno, track, release in find_releases(puid):
                included = 0
                if no == tno:
                    matchrel[release.id] += 1
                    included = 1
                print u"    %d - %s - %s %s" % (tno, track.title, release.title, " <=" if included else "")

        service = get_service()
        q = Query(service)
        i = ReleaseIncludes(artist=True, tracks=True, urlRelations=True)
        releaseids = sorted(matchrel.iteritems(), key=itemgetter(1), reverse=1)

        if not releaseids:
            return None

        releases = None
        while not releases:
            try:
                releases = [(q.getReleaseById(rid, i), freq) for rid, freq in releaseids]
            except WebServiceError, e:
                print "!! WebServiceError: ", e
                print "!! Retry in 5 seconds..."
                time.sleep(5)
Esempio n. 30
0
	def getTracks(self,filter=filter) :
		p = md5.new(pickle.dumps(filter)).hexdigest()
		cache_file = os.path.join(CACHE_DIR,'track_q',p)
                if os.path.exists(cache_file) :
                        instream = open(cache_file,"r")
                        toret = pickle.loads(instream.read())
                        instream.close()
                        return toret
                else :
			self.throttle()
			toret = Query.getTracks(self,filter=filter)
                        outstream = open(cache_file,"w")
                        outstream.write(pickle.dumps(toret))
                        outstream.close()
                        return toret
Esempio n. 31
0
 def getTracks(self, filter=filter):
     p = md5.new(pickle.dumps(filter)).hexdigest()
     cache_file = os.path.join('cache', 'track_q', p)
     if os.path.exists(cache_file):
         instream = open(cache_file, "r")
         toret = pickle.loads(instream.read())
         instream.close()
         return toret
     else:
         self.throttle()
         toret = Query.getTracks(self, filter=filter)
         outstream = open(cache_file, "w")
         outstream.write(pickle.dumps(toret))
         outstream.close()
         return toret
Esempio n. 32
0
	def testSubmitCdStub(self):
		from musicbrainz2.model import Disc, CDStub

		ws = FakeWebService()
		q = Query(ws, clientId='test-1')

		discid = "6EmGGSLhuDYz2lNXtqrCiCCqO0o-"
		disc = Disc(discid)
		disc.firstTrackNum = 1
		disc.lastTrackNum = 4
		disc.sectors = 89150
		disc.addTrack( (150, 20551) )
		disc.addTrack( (20701, 26074) )
		disc.addTrack( (46775, 19438) )
		disc.addTrack( (66213, 22937) )

		cdstub = CDStub(disc)
		cdstub.artist = "artist"
		cdstub.title = "title"
		cdstub.addTrack("trackname1")
		cdstub.addTrack("trackname2")
		cdstub.addTrack("trackname3")
		cdstub.addTrack("trackname4")
		q.submitCDStub(cdstub)

		cdstub.barcode = "12345"
		cdstub.comment = "acomment"
		q.submitCDStub(cdstub)

		self.assertEquals(len(ws.data), 2)
		req = ws.data[0]
		qstring = 'client=test-1&discid=6EmGGSLhuDYz2lNXtqrCiCCqO0o-&title=title&artist=artist&track0=trackname1&track1=trackname2&track2=trackname3&track3=trackname4&toc=1+4+89150+150+20701+46775+66213'
		self.assertEquals(req[0], 'release')
		self.assertEquals(req[2], qstring)

		req = ws.data[1]
		qstring = 'client=test-1&discid=6EmGGSLhuDYz2lNXtqrCiCCqO0o-&title=title&artist=artist&barcode=12345&comment=acomment&track0=trackname1&track1=trackname2&track2=trackname3&track3=trackname4&toc=1+4+89150+150+20701+46775+66213'
		self.assertEquals(req[2], qstring)

		cdstub._tracks = []
		cdstub.addTrack("tname1", "artist1")
		cdstub.addTrack("tname2", "artist2")
		cdstub.addTrack("tname3", "artist3")
		cdstub.addTrack("tname4", "artist4")
		q.submitCDStub(cdstub)
		self.assertEquals(len(ws.data), 3)
		req = ws.data[2]
		qstring = 'client=test-1&discid=6EmGGSLhuDYz2lNXtqrCiCCqO0o-&title=title&artist=artist&barcode=12345&comment=acomment&track0=tname1&artist0=artist1&track1=tname2&artist1=artist2&track2=tname3&artist2=artist3&track3=tname4&artist3=artist4&toc=1+4+89150+150+20701+46775+66213'
		self.assertEquals(req[2], qstring)
Esempio n. 33
0
	def testSubmitUserTags(self):
		ws = FakeWebService()
		q = Query(ws)
		t1 = [u"foo", u"bar", u"f\u014do"]
		t2 = [Tag(u"foo"), Tag(u"bar"), Tag(u"f\u014do")]

		prefix = 'http://musicbrainz.org/artist/'
		uri = prefix + 'c0b2500e-0cef-4130-869d-732b23ed9df5'

		q.submitUserTags(uri, t1)
		q.submitUserTags(uri, t2)

		self.assertEquals(len(ws.data), 2)
		self.assertEquals(ws.data[0], ws.data[1])

		q.submitUserRating(uri, Rating(5))
		q.submitUserRating(uri, 5)

		self.assertEquals(len(ws.data), 4)
		self.assertEquals(ws.data[2], ws.data[3])
class MusicBrainzTrackSearch:
	"""
		Searches MusicBrainz database for Suggestions based on a Track
	"""
	def __init__(self):
		self.query = Query()

	def _build_musicbrainz_query(self, track):
		"""
			Build a query string in Lucene Format.

			track: The Track object wich values will be used to build
			the query
		"""
		tags = {
			'release': 'album',
			'artist': 'artist',
			'tnum': 'tracknumber',
			'track': 'title'
		}
		query_params = []
		for musicbrainz_tag, exaile_tag in tags.iteritems():
			tag_value = track.get_tag(exaile_tag)
			if tag_value:
				query_params.append(musicbrainz_tag + ":("+ tag_value[0] +")")
		query = ' '.join(query_params)
		return query

	def get_tracks_suggestions(self, track):
		"""
			Fetch track suggestions from Musicbrainz WebService

			track: The Track object wich values will be used in the query
		"""
		query = self._build_musicbrainz_query(track)
		filter = TrackFilter(query = query)
		tracks_result = self.query.getTracks(filter)
		return tracks_result
Esempio n. 35
0
    def main(self):
        if len(sys.argv) < 2:
            print "Usage:\n\t%s <archive|folder>" % sys.argv[0]
            sys.exit()

        s = os.path.abspath(sys.argv[1])
        try:
            shutil.rmtree(".brainwash-work")
        except:
            pass
        try:
            os.mkdir(".brainwash-work")
        except:
            pass
        os.chdir(".brainwash-work")

        if os.path.isdir(s):
            print "Creating working copy..."
            shutil.copytree(s, "work")
        else:
            subprocess.call(["unp", s])

        folders = find_music_folders(".")

        for folder in folders:
            music_files = myglob(folder[0], "*" + folder[1])
            if len(music_files) < 2:
                cue_files = myglob(folder[0], "*.cue")
                if len(cue_files) < 1:
                    # ask for mbid
                    # need to write cuesheet generation code!!!
                    # print "There is no cue file. To generate one I need the Release MBID."
                    # mbid = raw_input('Enter MBID: ').strip()
                    print "There is no cuesheet. please generate one yourself :P"
                    continue
                else:
                    cue_file = cue_files[0]

                wav_file = self.decode_to_wav(music_files[0])
                subprocess.call(["bchunk", "-w", wav_file, cue_file, folder[0] + "/tmp-brainwash-"])
                wav_files = myglob(folder[0], "tmp-brainwash-*.wav")
                music_files = []
                for wav_file in wav_files:
                    music_files += [self.encode_to_flac(wav_file)]
                folder[1] = "flac"

                # encode into a nice format
            if folder[1] not in formats_final:
                wav_files = []
                if folder[1] == ".wav":
                    wav_files = music_files[:]
                else:
                    for music_file in music_files:
                        wav_files += [self.decode_to_wav(music_file)]
                music_files = []
                for wav_file in wav_files:
                    music_files += [self.encode_to_flac(wav_file)]
                folder[1] = "flac"
                # take over the tags?

            print "Found: " + folder[0]
            try:
                mbid = file(folder[0] + "/.mbid").read().strip()
                print "Using existing mbid"
            except:
                release = self.guess_release(folder[0], music_files)
                if release is None:
                    # ask for mbid
                    print "Could not guess!"
                    mbid = raw_input("Enter MBID: ").strip()
                else:
                    # ask if guess is correct
                    tmp_mbid = release.id.split("/")[-1:][0]
                    print "Selected %s" % tmp_mbid
                    answer = raw_input("Correct? [Y|n]").strip()
                    if answer == "" or answer.lower() == "y":
                        mbid = tmp_mbid
                    else:
                        print str(answer.lower())
                        mbid = raw_input("Enter MBID: ").strip()

                file(join(folder[0], ".mbid"), "w").write(str(mbid))

            service = get_service()
            q = Query(service)
            i = ReleaseIncludes(artist=True, tracks=True, urlRelations=True, releaseEvents=True, discs=True)
            try:
                release = q.getReleaseById(mbid, i)
            except WebServiceError, e:
                print "Error: ", e
                continue

            dst = self.config["destination_dir"]

            year = 9999

            for event in release.releaseEvents:
                year = min(year, int(event.date[:4]))

            if year == 9999:
                year = int(raw_input("Enter Release Year: ").strip())

            release_title = self.clean_filename(release.title)

            if release.TYPE_SOUNDTRACK in release.getTypes():
                dst += "/_soundtracks/(%s) %s/" % (year, release_title)
            elif not release.artist:
                dst += "/_va/(%s) %s/" % (year, release_title)
            else:
                sort_char = release.artist.sortName[:1].lower()
                sort_char = unicodedata.normalize("NFKD", sort_char).encode("ASCII", "ignore")
                dst += "/%s/%s/(%s) %s/" % (
                    sort_char,
                    self.clean_filename(release.artist.sortName),
                    year,
                    release_title,
                )

            try:
                os.makedirs(dst)
            except:
                raw_input("Failed creating %s! Press Anykey" % dst)
            file(join(dst, ".mbid"), "w").write(str(mbid))

            for music_file in music_files:
                # fix permissions for broken archives
                os.chmod(music_file, (stat.S_IRUSR + stat.S_IWUSR + stat.S_IRGRP + stat.S_IROTH))
                track_number = filename_track_number(music_file)
                track = release.tracks[track_number - 1]
                if folder[1] == ".mp3":
                    # meta_file = MP3(music_file, ID3=EasyID3)
                    meta_file = EasyID3()
                elif folder[1] == ".ogg":
                    meta_file = OggVorbis(music_file)
                elif folder[1] == "flac":
                    meta_file = FLAC(music_file)
                else:
                    print "Uh oh, no meta-file for " + music_file
                    # if not meta_file.tags:
                    # 	meta_file.add_tags()
                artist = track.artist.name if track.artist else release.artist.name
                meta_file["title"] = track.title
                meta_file["artist"] = artist
                meta_file["album"] = release.title
                meta_file["tracknumber"] = str(track_number) + "/" + str(len(music_files))
                meta_file["genre"] = self.get_lastfm_tags(meta_file["artist"][0])
                meta_file.save(music_file)

                file_dst = dst + self.clean_filename(
                    "%02d-%s - %s%s%s"
                    % (track_number, artist, track.title, "." if folder[1] == "flac" else "", folder[1])
                )
                os.rename(music_file, file_dst)

                # cover art
            image_files = myglob(folder[0], "*.[jpg|png]")
            if len(image_files) > 1:
                for image_file in image_files:
                    os.rename(image_file, dst + basename(image_file))
            elif len(image_files) == 1:
                os.rename(image_files[0], dst + "cover." + image_files[0][-3:])
            else:
                # try downlaod from amazon
                if release.asin:
                    urllib.urlretrieve(
                        "http://images.amazon.com/images/P/" + release.asin + ".01.LZZZZZZZ.jpg", dst + "cover.jpg"
                    )
                    if os.path.getsize(dst + "cover.jpg") < 1000L:
                        os.remove(dst + "cover.jpg")
            print "Done: " + dst
Esempio n. 36
0
 def get_release(self, gid):
     q = Query(self.ws)
     inc = ReleaseIncludes(tracks=True, isrcs=True)
     return q.getReleaseById(gid, include=inc)
Esempio n. 37
0
import logging
from musicbrainz2.webservice import Query, ArtistFilter, WebServiceError, ReleaseFilter, ArtistIncludes, ReleaseIncludes
import musicbrainz2.model as m
from time import sleep
import codecs

logging.basicConfig()
logger = logging.getLogger()
logger.setLevel(logging.ERROR)
sys.stdout = codecs.getwriter('utf8')(sys.stdout) # workaround for pipes

if len(sys.argv) < 2:
	print "Usage:", os.path.basename(sys.argv[0]), "'artist name' [offset]"
	sys.exit(1)

q = Query()

try:
	# Search for all artists matching the given name. Limit the results
	# to the 5 best matches. The offset parameter could be used to page
	# through the results.
	#
	f = ArtistFilter(name=sys.argv[1], limit=10)
	artistResults = q.getArtists(f)
except WebServiceError, e:
	print 'Error:', e
	sys.exit(1)

if len(sys.argv) > 2:
	artistResults = [artistResults[int(sys.argv[2])]]
else:
Esempio n. 38
0
for arg in sys.argv[1:]:
    if os.path.isdir(arg):
        for root, dirs, files2 in walk(arg):
            files.extend([os.path.join(root, file) for file in files2])
    elif os.path.isfile(arg):
        files.append(arg)

toSubmit = {}
        
for file in files:
    file = file.decode(encoding)
    fileId = tp.addFile(file, 0)
    print ("Adding %s (%s)" % (file, fileId)).encode('ascii', 'ignore')
    
ws = WebService(host=server, username=username, password=password)
q = Query(ws, clientId='puid_submit.py-%s' % (__version__,))

analyzed = {}

while tp.getNumFiles():
    ret, type, fileId, status = tp.getNotification()
    if not ret:
        continue
    
    print ret,type,fileId,status
    tr = tp.getTrack(fileId)
    tr.lock()
    fileName = tr.getFileName()
    mdata = tr.getLocalMetadata()
    tr.unlock()
Esempio n. 39
0
# $Id: findartist.py 8779 2007-01-07 10:01:52Z matt $
#
import sys
import logging
from musicbrainz2.webservice import Query, ArtistFilter, WebServiceError

logging.basicConfig()
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)
	

if len(sys.argv) < 2:
	print "Usage: findartist.py 'artist name'"
	sys.exit(1)

q = Query()

try:
	# Search for all artists matching the given name. Limit the results
	# to the 5 best matches. The offset parameter could be used to page
	# through the results.
	#
	f = ArtistFilter(name=sys.argv[1], limit=5)
	artistResults = q.getArtists(f)
except WebServiceError, e:
	print 'Error:', e
	sys.exit(1)


# No error occurred, so display the results of the search. It consists of
# ArtistResult objects, where each contains an artist.
Esempio n. 40
0
    def __init__(self, releaseId):
        #self.ignoreMissing(True)
        super(MusicBrainz2AlbumInfo, self).__init__()
        if isinstance(releaseId, basestring):
            self.__releaseId = releaseId
            query = Query()
            include = ReleaseIncludes(artist=True, tracks=True,
                    releaseEvents=True)
            release = query.getReleaseById(releaseId, include)
        elif isinstance(releaseId, Release):
            release = releaseId
            self.__releaseId = release.id
        else:
            raise Exception(
                    "incorrect type parameter for MusicBrainz2AlbumInfo %s"
                    % releaseId)

        self.title = release.title
        # XXX: musicbrainz doesn't have genre info. what to do?
        #self.genre = 'Musicbrainz'
        self.artist = release.artist.name
        date = release.getEarliestReleaseDate()
        if not date:
            self.year = 0
        else:
            self.year = int(date[0:4])
        self.genre = ''
        tracks = []
        number = 0
        self.isVarious = False
        for track in release.tracks:
            number += 1
            # XXX: get rid of the overcomplicated validation scheme that makes
            # for these ugly hacks
            class MBTrackInfo(TrackInfo):
                '''Represent musicbrainz track information.'''
                def getPlayLength(self):
                    'getter'
                    return self.__playLength
                def setPlayLength(self, playLength):
                    'setter'
                    self.__playLength = playLength
                def __init__(self):
                    super(MBTrackInfo, self).__init__()
                playLength = property(getPlayLength, setPlayLength)

            track_info = MBTrackInfo()
            del track_info.validateProps[
                    track_info.validateProps.index('playLength')]
            track_info.number = number
            if track.duration:
                track_info.playLength = track.duration / 1000.0
            else:
                # XXX: make sure we don't use namebinder relying on track length
                track_info.playLength = 0
            if track.artist:
                track_info.artist = track.artist.name
                self.isVarious = True
            else:
                track_info.artist = release.artist.name
            track_info.title = track.title
            tracks.append(track_info)
        self.tracks = tracks
Esempio n. 41
0
import pylast, sys, sqlite3, os, re
from musicbrainz2.webservice import Query, ArtistFilter, WebServiceError
import musicbrainz2.webservice as ws
import musicbrainz2.model as model

# Notifo API settings
USERNAME = ""
API_KEY = ""

# NZBMatrix Account Details
#API_URL = "http://api.nzbmatrix.com/v1.1/search.php?search=" + searchTerm + #"&catid=22&age=800&username=burningfire&apikey=75390295cf99a1db49c9314c86061405"

connection = sqlite3.connect('musicSearch.db')
cursor = connection.cursor()

q = Query()
query = ArtistFilter("Streetlight Manifesto", limit = 2)
artistResults = q.getArtists(query)

path = "C:\Users\Mongo\Music\iTunes\iTunes Media\Music"
unknown = ".+unknown.+"

itunesArtist = os.listdir(path)
artistExists = 0

def findArtist():
    artistName = cursor.execute('SELECT ArtistName FROM Artists')
    
    for i in itunesArtist:
        try:
            filter = ArtistFilter(i, limit = 2)
Esempio n. 42
0
import pylast, sys, sqlite3, os, re
from musicbrainz2.webservice import Query, ArtistFilter, WebServiceError
import musicbrainz2.webservice as ws
import musicbrainz2.model as model

# Notifo API settings
USERNAME = ""
API_KEY = ""

# NZBMatrix Account Details
#API_URL = "http://api.nzbmatrix.com/v1.1/search.php?search=" + searchTerm + #"&catid=22&age=800&username=burningfire&apikey=75390295cf99a1db49c9314c86061405"

connection = sqlite3.connect('musicSearch.db')
cursor = connection.cursor()

q = Query()
query = ArtistFilter("Streetlight Manifesto", limit=2)
artistResults = q.getArtists(query)

path = "C:\Users\Mongo\Music\iTunes\iTunes Media\Music"
unknown = ".+unknown.+"

itunesArtist = os.listdir(path)
artistExists = 0


def findArtist():
    artistName = cursor.execute('SELECT ArtistName FROM Artists')

    for i in itunesArtist:
        try:
Esempio n. 43
0
 def submit_isrcs(self, tracks2isrcs):
     q = Query(self.ws)
     q.submitISRCs(tracks2isrcs)
Esempio n. 44
0
 def __init__(self):
     self.q = Query()
Esempio n. 45
0
# $Id$
#
import sys
import logging
from musicbrainz2.webservice import Query, TrackFilter, WebServiceError

logging.basicConfig()
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)
    

if len(sys.argv) < 1:
    print "Usage: findtrack.py 'puid'"
    sys.exit(1)

q = Query()
try:
    f = TrackFilter(puid=sys.argv[1])
    results = q.getTracks(f)
except WebServiceError, e:
    print 'Error:', e
    sys.exit(1)


for result in results:
    track = result.track
    print "Score     :", result.score
    print "Id        :", track.id
    print "Title     :", track.title
    print "Artist    :", track.artist.name
    print