Exemplo n.º 1
0
 def get_release(self, disc_info):
     self.ui.status('Disc ID: %s\n' % disc_info.id)
     self.ui.status('Searching for release info...')
     try:
         release_info = musicbrainz.get_releases_by_discid(
             disc_info.id, includes=['artists', 'recordings', 'labels'])
     except urllib2.HTTPError, ex:
         if ex.getcode() == 404:
             submit = disc.getSubmissionUrl(disc_info)
             self.ui.error('Release info not found!')
             self.ui.info('Submit info at: %s' % submit)
             raise error.Abort()
         raise
Exemplo n.º 2
0
 def get_release(self, disc_info):
     self.ui.status('Disc ID: %s\n' % disc_info.id)
     self.ui.status('Searching for release info...')
     try:
         release_info = musicbrainz.get_releases_by_discid(
                 disc_info.id,
                 includes=['artists', 'recordings', 'labels'])
     except urllib2.HTTPError, ex:
         if ex.getcode() == 404:
             submit = disc.getSubmissionUrl(disc_info)
             self.ui.error('Release info not found!')
             self.ui.info('Submit info at: %s' % submit)
             raise error.Abort()
         raise
Exemplo n.º 3
0
def read_release_from_device(device):
  """
  Reads a L{ExtRelease} object from the given device.

  Reads the disc ID of the disc in the given device, then contacts the
  U{musicbrainz.org} website to create and return a L{ExtRelease} object.

  @param device: the path to the device.
  @return: a L{ExtRelease} object.
  @raise RuntimeError: if one of the following occurs:
    - The CD couldn't be read.
    - The U{musicbrainz.org} website could not be contacted.
    - The CD's DiscID was not available on U{musicbrainz.org}.
  """
  disc = None

  try:
    disc = mb2disc.readDisc(deviceName=device)
  except mb2disc.DiscError as e:
    raise RuntimeError(
      "An error occurred while reading the CD: {}".format(e.message))

  query = mb2ws.Query()
  releaseFilter  = mb2ws.ReleaseFilter(discId=disc.getId(), limit=1)
  releaseResults = None

  try:
    releaseResults = query.getReleases(filter=releaseFilter)
  except (mb2ws.ConnectionError, mb2ws.RequestError, mb2ws.ResponseError) as e:
    raise RuntimeError(
        "An error occurred while trying to retrieve the track information: {}"
        .format(e.message))

  if len(releaseResults) < 1:
    raise RuntimeError(
        "Couldn't find DiscID {} in musicbrainz.org database.\n"
        "If you'd like to add it, use this link:\n  {}".format(
          disc.getId(), mb2disc.getSubmissionUrl(disc)))

  release = releaseResults[0].getRelease()
  release.__class__ = ExtRelease
  release.setDefaults()

  return release
Exemplo n.º 4
0
def searchMbForDisc(device):
    d = disc.readDisc(device)
    cdid = d.id
    numTracks = d.getLastTrackNum()
    toc = {}
    toc["first_track"] = 1
    toc["num_tracks"] = numTracks
    toc["length"] = d.sectors
    toc["offsets"] = [x for (x, y) in d.getTracks()]
    logging.debug("toc: %s" % str(toc))

    logging.info("querying musicbrainz.org to see if this cd is on there...")
    q = ws.Query()
    rf = ws.ReleaseFilter(discId=cdid)
    releases = [result.getRelease() for result in q.getReleases(rf)]

    numFound = len(releases)

    if numFound == 0:
        return (toc, numFound, (disc.getSubmissionUrl(d),), None)
    else:
        return (toc, numFound, (cdid, numTracks), releases)
Exemplo n.º 5
0
def searchMbForDisc(device):
    d = disc.readDisc(device)
    cdid = d.id
    numTracks = d.getLastTrackNum()
    toc = {}
    toc["first_track"] = 1
    toc["num_tracks"] = numTracks
    toc["length"] = d.sectors
    toc["offsets"] = [x for (x, y) in d.getTracks()]
    logging.debug("toc: %s" % str(toc))

    logging.info("querying musicbrainz.org to see if this cd is on there...")
    q = ws.Query()
    rf = ws.ReleaseFilter(discId=cdid)
    releases = [result.getRelease() for result in q.getReleases(rf)]

    numFound = len(releases)

    if numFound == 0:
        return (toc, numFound, (disc.getSubmissionUrl(d), ), None)
    else:
        return (toc, numFound, (cdid, numTracks), releases)
Exemplo n.º 6
0
	def selectReleaseHandler(self):
		if self.preselectedReleaseId:
			disc = None
			results = [ loadRelease(self.preselectedReleaseId) ]
		else:
			disc = readDisc()
			results = getMatchingReleases(disc)

			if len(results) == 0:
				errQuit("no disc found")

		menu = Menu('1', 'Please select a release to rip:')

		for i, r in enumerate(results, 1):
			label = '%s - %s [%s]' % (r.artist.name, r.title,
				', '.join([e.country + ' ' + e.date for e in r.releaseEvents]))
			menu.addChoice(str(i), label)

		menu.addChoice(None, None)
		if disc:
			menu.addChoice('n', 'None of those, show submission URL.')
		menu.addChoice('q', 'Quit')

		choice = menu.showMenu()

		if choice == 'q':
			return State.QUIT
		elif disc and choice == 'n':
			print
			print "Use this URL to submit the disc to MusicBrainz:"
			print " ", getSubmissionUrl(disc)
			return State.QUIT
		else:
			self.releaseToRip = results[int(choice)-1]
			return State.SHOW_RELEASE

		assert( False )
Exemplo n.º 7
0
    def identify(self):
        """Drrn drrn
        """

        ## XXX: Do we really need the old library for this?
        try:
            disc = mbdisc.readDisc(deviceName=DEVICE)
        except mbdisc.DiscError as e:
            logger.error('[FAIL] %s' % e)
            logger.error(''.join(traceback.format_exception(*sys.exc_info())))
            self.interface.queue_to_identify_interface.send('FAILED_IDENTIFY')

            return

        disc_id = disc.getId()
        submission_url = mbdisc.getSubmissionUrl(disc)
        logger.info('[URL] %s' % submission_url)

        logger.info('[SUCCESS] Identified disc as: %s' % disc_id)

        ## XXX: The library doesn't understand a tuple here
        includes = ['artist-credits', 'labels', 'release-rels', 'recordings']
        try:
            data = musicbrainzngs.get_releases_by_discid(disc_id, includes=includes)
        except musicbrainzngs.ResponseError as e:
            ## Fake response to make flow easier
            if e.cause.code == 404:
                data = {
                    'disc': {
                        'id': disc_id,
                        'release-list': []
                    }
                }
            else:
                raise
        except Exception as e:
            logger.error('[FAIL] %s' % e)
            logger.error(''.join(traceback.format_exception(*sys.exc_info())))
            self.interface.queue_to_identify_interface.send('FAILED_IDENTIFY')

            return
        else:
            if not data:
                logger.error('[FAIL] No data returned. Check submission url')
                return

        try:
            releases = data['disc']['release-list']
        except KeyError:
            if 'cdstub' in data:
                logger.warn('[DISC] This release is only a stub, fill it in at MusicBrainz')
                self.interface.queue_to_identify_interface.send('NO_DATA')
                return

        # Make the chance slimmer that selecting a release breaks if mb sends results in odd orders
        releases.sort()

        logger.info('[SUCCESS] Got %d releases' % len(releases))

        if len(releases) == 0:
            self.interface.queue_to_identify_interface.send('NO_DATA')

            self.interface.queue_to_identify_interface.send(submission_url)

            return
        elif len(releases) > 1:
            self.interface.queue_to_identify_interface.send('MULTIPLE_RELEASES')
            self.interface.queue_to_identify_interface.send(releases)

            rel_num = self.interface.queue_to_identify_interface.recv()
        else:
            rel_num = 0

        ## Which release do we want?
        release = releases[rel_num]

        ## Disc title
        title = release['title'].encode('utf-8')
        disambiguation = release.get('disambiguation', None)
        is_remaster = False
        for rel_release in release.get('release-relation-list', ()):
            if rel_release.get('type', None) == 'remaster':
                is_remaster = True
                break

        extra_str = ''
        if disambiguation:
            extra_str = '%s' % disambiguation
        if is_remaster:
            extra_str = '%s remaster' % extra_str

        extra_str = extra_str.strip()

        if extra_str:
            title = '%s (%s)' % (title, extra_str)

        ## Require release date
        date = release['date']
        if not date:
            self.interface.queue_to_identify_interface.send('NO_DATE')

            return

        year = date.split('-', 1)[0]

        ## 0th artist...
        if len(release['artist-credit']) > 1:
            self.interface.queue_to_identify_interface.send('TOO_MANY_ARTISTS')

            return

        artist_sort_name = release['artist-credit'][0]['artist']['sort-name']
        artist_sort_name = artist_sort_name.encode('utf-8')

        ## Media count and name
        disc_num = 1
        if 'medium-count' not in release:
            disc_count = len(release['medium-list'])
        else:
            disc_count = release['medium-count']

        medium_n = 0
        media_name = None
        if disc_count > 1:
            for medium_n, medium in enumerate(release['medium-list']):
                if 'title' in medium:
                    media_name = medium['title']
                else:
                    media_name = None
                if disc_id in [d['id'] for d in medium['disc-list']]:
                    disc_num = medium_n + 1
                    break

        # Pass the media_name along if required, otherwise it's None
        if media_name is not None and media_name == title:
            media_name = None

        ## Unlike the mb example code, disregard different track artists
        track_tuples = []
        for track in release['medium-list'][medium_n]['track-list']:
            formatted_track_num = '%02d' % int(track['number'])

            track_title = track['recording']['title'].encode('utf-8')
            track_tuple = TrackTuple(disc_id=disc_id, release_id=release['id'], artist=artist_sort_name, year=year, title=title, formatted_track_num=formatted_track_num, track_title=track_title, disc_num=disc_num, disc_count=disc_count, media_name=media_name)

            track_tuples.append(track_tuple)

        self.interface.queue_to_identify_interface.send('FINISHED_IDENTIFY')
        self.interface.queue_to_identify_interface.send(tuple(track_tuples))
Exemplo n.º 8
0
            disc = mbdisc.readDisc(self.dev)
        except mbdisc.DiscError, err:
            warn(err)
            raise self.MBError

        discId = disc.getId()
        try:
            myfilter = mbws.ReleaseFilter(discId=discId)
            results = query.getReleases(myfilter)
        except mbws.WebServiceError, err:
            warn(err)
            raise self.MBError

        if len(results) == 0:
            print "Disc is not yet in the MusicBrainz database."
            print "Consider adding it via", mbdisc.getSubmissionUrl(disc)
            raise self.MBError
        try:
            inc = mbws.ReleaseIncludes(artist=True, tracks=True, releaseEvents=True)
            release = query.getReleaseById(results[0].release.getId(), inc)
        except mbws.WebServiceError, err:
            warn(err)
            raise self.MBError

        isSingleArtist = release.isSingleArtistRelease()

        try:
            # try to get the CDDB ID
            import DiscID
            cddb_id = '%08lx' % long(DiscID.disc_id(DiscID.open(self.dev))[0])
        except:
Exemplo n.º 9
0
            disc = mbdisc.readDisc(self.dev)
        except mbdisc.DiscError, err:
            warn(err)
            raise self.MBError

        discId = disc.getId()
        try:
            myfilter = mbws.ReleaseFilter(discId=discId)
            results = query.getReleases(myfilter)
        except mbws.WebServiceError, err:
            warn(err)
            raise self.MBError

        if len(results) == 0:
            print "Disc is not yet in the MusicBrainz database."
            print "Consider adding it via", mbdisc.getSubmissionUrl(disc)
            raise self.MBError
        try:
            inc = mbws.ReleaseIncludes(artist=True, tracks=True, releaseEvents=True)
            release = query.getReleaseById(results[0].release.getId(), inc)
        except mbws.WebServiceError, err:
            warn(err)
            raise self.MBError

        isSingleArtist = release.isSingleArtistRelease()

        try:
            # try to get the CDDB ID
            import DiscID
            cddb_id = '%08lx' % long(DiscID.disc_id(DiscID.open(self.dev))[0])
        except:
Exemplo n.º 10
0
# Usage:
#	python discid.py
#
# $Id: discid.py 201 2006-03-27 14:43:13Z matt $
#
import sys
from musicbrainz2.disc import readDisc, getSubmissionUrl, DiscError

try:
	# Read the disc in the default disc drive. If necessary, you can pass
	# the 'deviceName' parameter to select a different drive.
	#
	disc = readDisc()
except DiscError, e:
	print "DiscID calculation failed:", str(e)
	sys.exit(1)

print 'DiscID      :', disc.id
print 'First Track :', disc.firstTrackNum
print 'Last Track  :', disc.lastTrackNum
print 'Length      :', disc.sectors, 'sectors'

i = disc.firstTrackNum
for (offset, length) in disc.tracks:
	print "Track %-2d    : %8d %8d" % (i, offset, length)
	i += 1

print 'Submit via  :', getSubmissionUrl(disc)

# EOF
Exemplo n.º 11
0
    def get_mb(self):
        try:
            import musicbrainz2.disc as mbdisc
            import musicbrainz2.webservice as mbws
        except ImportError as err:
            warn(
                'You need python-musicbrainz2 (or python-cddb) to convert cds. Please install it. Trying cddb.'
            )
            raise self.MBError(err)

        service = mbws.WebService()
        query = mbws.Query(service)

        # Read the disc in the drive
        try:
            disc = mbdisc.readDisc(self.dev)
        except mbdisc.DiscError as err:
            warn(err)
            raise self.MBError

        discId = disc.getId()
        try:
            myfilter = mbws.ReleaseFilter(discId=discId)
            results = query.getReleases(myfilter)
        except mbws.WebServiceError as err:
            warn(err)
            raise self.MBError

        if len(results) == 0:
            print("Disc is not yet in the MusicBrainz database.")
            print("Consider adding it via", mbdisc.getSubmissionUrl(disc))
            raise self.MBError
        try:
            inc = mbws.ReleaseIncludes(artist=True,
                                       tracks=True,
                                       releaseEvents=True)
            release = query.getReleaseById(results[0].release.getId(), inc)
        except mbws.WebServiceError as err:
            warn(err)
            raise self.MBError

        isSingleArtist = release.isSingleArtistRelease()

        try:
            # try to get the CDDB ID
            import DiscID
            cddb_id = '%08lx' % int(DiscID.disc_id(DiscID.open(self.dev))[0])
        except:
            cddb_id = False

        trackn = 1
        for track in release.tracks:
            title = {}
            title[
                'artist'] = isSingleArtist and release.artist.name or track.artist
            if cddb_id:
                title['discid'] = cddb_id
            title['album'] = release.title
            title['date'] = release.getEarliestReleaseDate()
            title['musicbrainz_albumartistid'] = release.artist.id.split(
                "/")[-1]
            title['musicbrainz_albumid'] = release.id.split("/")[-1]
            title['musicbrainz_discid'] = discId
            title['musicbrainz_sortname'] = release.artist.sortName
            title['musicbrainz_trackid'] = track.id.split("/")[-1]
            title['title'] = track.title
            title['tracktotal'] = str(len(release.tracks))
            title['ntracknumber'] = "%02d" % trackn
            title['tracknumber'] = str(trackn)
            ConvertTrack(self.dev, self.conf, trackn, title)
            trackn += 1