def do(self): runner = task.SyncRunner() t = cdparanoia.AnalyzeTask(self.options.device) runner.run(t) if t.defeatsCache is None: sys.stdout.write( 'Cannot analyze the drive. Is there a CD in it?\n') return if not t.defeatsCache: sys.stdout.write( 'cdparanoia cannot defeat the audio cache on this drive.\n') else: sys.stdout.write( 'cdparanoia can defeat the audio cache on this drive.\n') info = drive.getDeviceInfo(self.options.device) if not info: sys.stdout.write('Drive caching behaviour not saved:' 'could not get device info (requires pycdio).\n') return sys.stdout.write( 'Adding drive cache behaviour to configuration file.\n') config.Config().setDefeatsCache(info[0], info[1], info[2], t.defeatsCache)
def do(self): paths = drive.getAllDevicePaths() self.config = config.Config() if not paths: logger.critical('no drives found. Create /dev/cdrom ' 'if you have a CD drive, or install ' 'pycdio for better detection') return try: import cdio as _ # noqa: F401 (TODO: fix it in a separate PR?) except ImportError: logger.error('install pycdio for vendor/model/release detection') return for path in paths: vendor, model, release = drive.getDeviceInfo(path) print("drive: %s, vendor: %s, model: %s, release: %s" % (path, vendor, model, release)) try: offset = self.config.getReadOffset(vendor, model, release) print(" Configured read offset: %d" % offset) except KeyError: # Note spaces at the beginning for pretty terminal output logger.warning("no read offset found. " "Run 'whipper offset find'") try: defeats = self.config.getDefeatsCache(vendor, model, release) print(" Can defeat audio cache: %s" % defeats) except KeyError: logger.warning("unknown whether audio cache can be " "defeated. Run 'whipper drive analyze'")
def do(self): runner = task.SyncRunner() t = cdparanoia.AnalyzeTask(self.options.device) runner.run(t) if t.defeatsCache is None: sys.stdout.write( 'Cannot analyze the drive. Is there a CD in it?\n') return if not t.defeatsCache: sys.stdout.write( 'cdparanoia cannot defeat the audio cache on this drive.\n') else: sys.stdout.write( 'cdparanoia can defeat the audio cache on this drive.\n') info = drive.getDeviceInfo(self.options.device) if not info: sys.stdout.write('Drive caching behaviour not saved:' 'could not get device info (requires pycdio).\n') return sys.stdout.write( 'Adding drive cache behaviour to configuration file.\n') config.Config().setDefeatsCache( info[0], info[1], info[2], t.defeatsCache)
def add_arguments(self): loggers = result.getLoggers().keys() default_offset = None info = drive.getDeviceInfo(self.opts.device) if info: try: default_offset = config.Config().getReadOffset(*info) sys.stdout.write("Using configured read offset %d\n" % default_offset) except KeyError: pass _CD.add_arguments(self.parser) self.parser.add_argument('-L', '--logger', action="store", dest="logger", default='whipper', help="logger to use (choose from '" "', '".join(loggers) + "')") # FIXME: get from config self.parser.add_argument('-o', '--offset', action="store", dest="offset", default=default_offset, help="sample read offset") self.parser.add_argument('-x', '--force-overread', action="store_true", dest="overread", default=False, help="Force overreading into the " "lead-out portion of the disc. Works only " "if the patched cdparanoia package is " "installed and the drive " "supports this feature. ") self.parser.add_argument('-O', '--output-directory', action="store", dest="output_directory", default=os.path.relpath(os.getcwd()), help="output directory; will be included " "in file paths in log") self.parser.add_argument('-W', '--working-directory', action="store", dest="working_directory", help="working directory; whipper will " "change to this directory " "and files will be created relative to " "it when not absolute") self.parser.add_argument('--track-template', action="store", dest="track_template", default=DEFAULT_TRACK_TEMPLATE, help="template for track file naming") self.parser.add_argument('--disc-template', action="store", dest="disc_template", default=DEFAULT_DISC_TEMPLATE, help="template for disc file naming") self.parser.add_argument('-U', '--unknown', action="store_true", dest="unknown", help="whether to continue ripping if " "the CD is unknown", default=False) self.parser.add_argument('--cdr', action="store_true", dest="cdr", help="whether to continue ripping if " "the disc is a CD-R", default=False)
def add_arguments(self): loggers = result.getLoggers().keys() default_offset = None info = drive.getDeviceInfo(self.opts.device) if info: try: default_offset = config.Config().getReadOffset(*info) sys.stdout.write("Using configured read offset %d\n" % default_offset) except KeyError: pass _CD.add_arguments(self.parser) self.parser.add_argument('-L', '--logger', action="store", dest="logger", default='whipper', help="logger to use (choose from '" "', '".join(loggers) + "')") # FIXME: get from config self.parser.add_argument('-o', '--offset', action="store", dest="offset", default=default_offset, help="sample read offset") self.parser.add_argument('-x', '--force-overread', action="store_true", dest="overread", default=False, help="Force overreading into the " "lead-out portion of the disc. Works only " "if the patched cdparanoia package is " "installed and the drive " "supports this feature. ") self.parser.add_argument('-O', '--output-directory', action="store", dest="output_directory", default=os.path.relpath(os.getcwd()), help="output directory; will be included " "in file paths in log") self.parser.add_argument('-W', '--working-directory', action="store", dest="working_directory", help="working directory; whipper will " "change to this directory " "and files will be created relative to " "it when not absolute") self.parser.add_argument('--track-template', action="store", dest="track_template", default=DEFAULT_TRACK_TEMPLATE, help="template for track file naming") self.parser.add_argument('--disc-template', action="store", dest="disc_template", default=DEFAULT_DISC_TEMPLATE, help="template for disc file naming") self.parser.add_argument('-U', '--unknown', action="store_true", dest="unknown", help="whether to continue ripping if " "the CD is unknown", default=False) self.parser.add_argument('--cdr', action="store_true", dest="cdr", help="whether to continue ripping if " "the disc is a CD-R", default=False)
def _foundOffset(self, device, offset): print('\nRead offset of device is: %d.' % offset) info = drive.getDeviceInfo(device) if not info: logger.error('offset not saved: ' 'could not get device info (requires pycdio)') return logger.info('adding read offset to configuration file') config.Config().setReadOffset(info[0], info[1], info[2], offset)
def _foundOffset(self, device, offset): sys.stdout.write('\nRead offset of device is: %d.\n' % offset) info = drive.getDeviceInfo(device) if not info: sys.stdout.write('Offset not saved: could not get ' 'device info (requires pycdio).\n') return sys.stdout.write('Adding read offset to configuration file.\n') config.Config().setReadOffset(info[0], info[1], info[2], offset)
def _foundOffset(self, device, offset): sys.stdout.write('\nRead offset of device is: %d.\n' % offset) info = drive.getDeviceInfo(device) if not info: sys.stdout.write('Offset not saved: could not get device info (requires pycdio).\n') return sys.stdout.write('Adding read offset to configuration file.\n') config.Config().setReadOffset(info[0], info[1], info[2], offset)
def _foundOffset(self, device, offset): print('\nRead offset of device is: %d.' % offset) info = drive.getDeviceInfo(device) if not info: logger.error('offset not saved: ' 'could not get device info (requires pycdio)') return logger.info('adding read offset to configuration file') config.Config().setReadOffset(info[0], info[1], info[2], offset)
def do(self): paths = drive.getAllDevicePaths() self.config = config.Config() if not paths: sys.stdout.write('No drives found.\n') sys.stdout.write('Create /dev/cdrom if you have a CD drive, \n') sys.stdout.write('or install pycdio for better detection.\n') return try: import cdio as _ # noqa: F401 (TODO: fix it in a separate PR?) except ImportError: sys.stdout.write( 'Install pycdio for vendor/model/release detection.\n') return for path in paths: vendor, model, release = drive.getDeviceInfo(path) sys.stdout.write( "drive: %s, vendor: %s, model: %s, release: %s\n" % ( path, vendor, model, release)) try: offset = self.config.getReadOffset( vendor, model, release) sys.stdout.write( " Configured read offset: %d\n" % offset) except KeyError: # Note spaces at the beginning for pretty terminal output sys.stdout.write(" " "No read offset found. " "Run 'whipper offset find'\n") try: defeats = self.config.getDefeatsCache( vendor, model, release) sys.stdout.write( " Can defeat audio cache: %s\n" % defeats) except KeyError: sys.stdout.write( " Unknown whether audio cache can be defeated. " "Run 'whipper drive analyze'\n") if not paths: sys.stdout.write('No drives found.\n')
def do(self): paths = drive.getAllDevicePaths() self.config = config.Config() if not paths: sys.stdout.write('No drives found.\n') sys.stdout.write('Create /dev/cdrom if you have a CD drive, \n') sys.stdout.write('or install pycdio for better detection.\n') return try: import cdio as _ except ImportError: sys.stdout.write( 'Install pycdio for vendor/model/release detection.\n') return for path in paths: vendor, model, release = drive.getDeviceInfo(path) sys.stdout.write( "drive: %s, vendor: %s, model: %s, release: %s\n" % ( path, vendor, model, release)) try: offset = self.config.getReadOffset( vendor, model, release) sys.stdout.write( " Configured read offset: %d\n" % offset) except KeyError: sys.stdout.write( " No read offset found. Run 'whipper offset find'\n") try: defeats = self.config.getDefeatsCache( vendor, model, release) sys.stdout.write( " Can defeat audio cache: %s\n" % defeats) except KeyError: sys.stdout.write( " Unknown whether audio cache can be defeated. " "Run 'whipper drive analyze'\n") if not paths: sys.stdout.write('No drives found.\n')
def do(self): paths = drive.getAllDevicePaths() self.config = config.Config() if not paths: logger.critical('no drives found. Create /dev/cdrom ' 'if you have a CD drive, or install ' 'pycdio for better detection') return try: import cdio as _ # noqa: F401 (TODO: fix it in a separate PR?) except ImportError: logger.error('install pycdio for vendor/model/release detection') return for path in paths: vendor, model, release = drive.getDeviceInfo(path) print("drive: %s, vendor: %s, model: %s, release: %s" % ( path, vendor, model, release)) try: offset = self.config.getReadOffset( vendor, model, release) print(" Configured read offset: %d" % offset) except KeyError: # Note spaces at the beginning for pretty terminal output logger.warning("no read offset found. " "Run 'whipper offset find'") try: defeats = self.config.getDefeatsCache( vendor, model, release) print(" Can defeat audio cache: %s" % defeats) except KeyError: logger.warning("unknown whether audio cache can be " "defeated. Run 'whipper drive analyze'")
def do(self): runner = task.SyncRunner() t = cdparanoia.AnalyzeTask(self.options.device) runner.run(t) if t.defeatsCache is None: logger.critical('cannot analyze the drive: is there a CD in it?') return if not t.defeatsCache: logger.info('cdparanoia cannot defeat the audio cache ' 'on this drive') else: logger.info('cdparanoia can defeat the audio cache on this drive') info = drive.getDeviceInfo(self.options.device) if not info: logger.error('drive caching behaviour not saved: ' 'could not get device info') return logger.info('adding drive cache behaviour to configuration file') config.Config().setDefeatsCache( info[0], info[1], info[2], t.defeatsCache)
def do(self): runner = task.SyncRunner() t = cdparanoia.AnalyzeTask(self.options.device) runner.run(t) if t.defeatsCache is None: logger.critical('cannot analyze the drive: is there a CD in it?') return if not t.defeatsCache: logger.info('cdparanoia cannot defeat the audio cache ' 'on this drive') else: logger.info('cdparanoia can defeat the audio cache on this drive') info = drive.getDeviceInfo(self.options.device) if not info: logger.error('drive caching behaviour not saved: ' 'could not get device info') return logger.info('adding drive cache behaviour to configuration file') config.Config().setDefeatsCache(info[0], info[1], info[2], t.defeatsCache)
def do(self): self.config = config.Config() self.program = program.Program(self.config, record=self.options.record, stdout=sys.stdout) self.runner = task.SyncRunner() # if the device is mounted (data session), unmount it self.device = self.options.device sys.stdout.write('Checking device %s\n' % self.device) utils.load_device(self.device) utils.unmount_device(self.device) # first, read the normal TOC, which is fast self.ittoc = self.program.getFastToc(self.runner, self.options.toc_pickle, self.device) # already show us some info based on this self.program.getRipResult(self.ittoc.getCDDBDiscId()) sys.stdout.write("CDDB disc id: %s\n" % self.ittoc.getCDDBDiscId()) self.mbdiscid = self.ittoc.getMusicBrainzDiscId() sys.stdout.write("MusicBrainz disc id %s\n" % self.mbdiscid) sys.stdout.write("MusicBrainz lookup URL %s\n" % self.ittoc.getMusicBrainzSubmitURL()) self.program.metadata = ( self.program.getMusicBrainz(self.ittoc, self.mbdiscid, release=self.options.release_id, country=self.options.country, prompt=self.options.prompt) ) if not self.program.metadata: # fall back to FreeDB for lookup cddbid = self.ittoc.getCDDBValues() cddbmd = self.program.getCDDB(cddbid) if cddbmd: sys.stdout.write('FreeDB identifies disc as %s\n' % cddbmd) # also used by rip cd info if not getattr(self.options, 'unknown', False): logger.critical("unable to retrieve disc metadata, " "--unknown not passed") return -1 self.program.result.isCdr = cdrdao.DetectCdr(self.device) if (self.program.result.isCdr and not getattr(self.options, 'cdr', False)): logger.critical("inserted disc seems to be a CD-R, " "--cdr not passed") return -1 # now, read the complete index table, which is slower self.itable = self.program.getTable(self.runner, self.ittoc.getCDDBDiscId(), self.ittoc.getMusicBrainzDiscId(), self.device, self.options.offset) assert self.itable.getCDDBDiscId() == self.ittoc.getCDDBDiscId(), \ "full table's id %s differs from toc id %s" % ( self.itable.getCDDBDiscId(), self.ittoc.getCDDBDiscId()) assert self.itable.getMusicBrainzDiscId() == \ self.ittoc.getMusicBrainzDiscId(), \ "full table's mb id %s differs from toc id mb %s" % ( self.itable.getMusicBrainzDiscId(), self.ittoc.getMusicBrainzDiscId()) assert self.itable.accuraterip_path() == \ self.ittoc.accuraterip_path(), \ "full table's AR URL %s differs from toc AR URL %s" % ( self.itable.accuraterip_url(), self.ittoc.accuraterip_url()) if self.program.metadata: self.program.metadata.discid = self.ittoc.getMusicBrainzDiscId() # result self.program.result.cdrdaoVersion = cdrdao.getCDRDAOVersion() self.program.result.cdparanoiaVersion = \ cdparanoia.getCdParanoiaVersion() info = drive.getDeviceInfo(self.device) if info: try: self.program.result.cdparanoiaDefeatsCache = \ self.config.getDefeatsCache(*info) except KeyError as e: logger.debug('Got key error: %r' % (e, )) self.program.result.artist = self.program.metadata \ and self.program.metadata.artist \ or 'Unknown Artist' self.program.result.title = self.program.metadata \ and self.program.metadata.title \ or 'Unknown Title' _, self.program.result.vendor, self.program.result.model, \ self.program.result.release = \ cdio.Device(self.device).get_hwinfo() self.doCommand() if self.options.eject in ('success', 'always'): utils.eject_device(self.device)
def do(self): self.config = config.Config() self.program = program.Program(self.config, record=self.options.record, stdout=sys.stdout) self.runner = task.SyncRunner() # if the device is mounted (data session), unmount it #self.device = self.parentCommand.options.device self.device = self.options.device sys.stdout.write('Checking device %s\n' % self.device) utils.load_device(self.device) utils.unmount_device(self.device) # first, read the normal TOC, which is fast self.ittoc = self.program.getFastToc(self.runner, self.options.toc_pickle, self.device) # already show us some info based on this self.program.getRipResult(self.ittoc.getCDDBDiscId()) sys.stdout.write("CDDB disc id: %s\n" % self.ittoc.getCDDBDiscId()) self.mbdiscid = self.ittoc.getMusicBrainzDiscId() sys.stdout.write("MusicBrainz disc id %s\n" % self.mbdiscid) sys.stdout.write("MusicBrainz lookup URL %s\n" % self.ittoc.getMusicBrainzSubmitURL()) self.program.metadata = self.program.getMusicBrainz(self.ittoc, self.mbdiscid, release=self.options.release_id, country=self.options.country, prompt=self.options.prompt) if not self.program.metadata: # fall back to FreeDB for lookup cddbid = self.ittoc.getCDDBValues() cddbmd = self.program.getCDDB(cddbid) if cddbmd: sys.stdout.write('FreeDB identifies disc as %s\n' % cddbmd) # also used by rip cd info if not getattr(self.options, 'unknown', False): logger.critical("unable to retrieve disc metadata, " "--unknown not passed") return -1 # FIXME ????? # Hackish fix for broken commit offset = 0 info = drive.getDeviceInfo(self.device) if info: try: offset = self.config.getReadOffset(*info) except KeyError: pass # now, read the complete index table, which is slower self.itable = self.program.getTable(self.runner, self.ittoc.getCDDBDiscId(), self.ittoc.getMusicBrainzDiscId(), self.device, offset) assert self.itable.getCDDBDiscId() == self.ittoc.getCDDBDiscId(), \ "full table's id %s differs from toc id %s" % ( self.itable.getCDDBDiscId(), self.ittoc.getCDDBDiscId()) assert self.itable.getMusicBrainzDiscId() == \ self.ittoc.getMusicBrainzDiscId(), \ "full table's mb id %s differs from toc id mb %s" % ( self.itable.getMusicBrainzDiscId(), self.ittoc.getMusicBrainzDiscId()) assert self.itable.getAccurateRipURL() == \ self.ittoc.getAccurateRipURL(), \ "full table's AR URL %s differs from toc AR URL %s" % ( self.itable.getAccurateRipURL(), self.ittoc.getAccurateRipURL()) if self.program.metadata: self.program.metadata.discid = self.ittoc.getMusicBrainzDiscId() # result self.program.result.cdrdaoVersion = cdrdao.getCDRDAOVersion() self.program.result.cdparanoiaVersion = \ cdparanoia.getCdParanoiaVersion() info = drive.getDeviceInfo(self.device) if info: try: self.program.result.cdparanoiaDefeatsCache = \ self.config.getDefeatsCache(*info) except KeyError, e: logger.debug('Got key error: %r' % (e, ))
def do(self): self.config = config.Config() self.program = program.Program(self.config, record=self.options.record) self.runner = task.SyncRunner() # if the device is mounted (data session), unmount it self.device = self.options.device logger.info('checking device %s', self.device) if self.options.drive_auto_close is True: utils.load_device(self.device) utils.unmount_device(self.device) # Exit and inform the user if there's no CD in the disk drive if drive.get_cdrom_drive_status(self.device) == 1: # rc 1 -> no disc raise OSError("no CD detected, please insert one and retry") # first, read the normal TOC, which is fast self.ittoc = self.program.getFastToc(self.runner, self.device) # already show us some info based on this self.program.getRipResult() print("CDDB disc id: %s" % self.ittoc.getCDDBDiscId()) self.mbdiscid = self.ittoc.getMusicBrainzDiscId() print("MusicBrainz disc id %s" % self.mbdiscid) print("MusicBrainz lookup URL %s" % self.ittoc.getMusicBrainzSubmitURL()) self.program.metadata = ( self.program.getMusicBrainz(self.ittoc, self.mbdiscid, release=self.options.release_id, country=self.options.country, prompt=self.options.prompt) ) if not self.program.metadata: # fall back to FreeDB for lookup cddbid = self.ittoc.getCDDBValues() cddbmd = self.program.getCDDB(cddbid) if cddbmd: logger.info('FreeDB identifies disc as %s', cddbmd) # also used by rip cd info if not getattr(self.options, 'unknown', False): logger.critical("unable to retrieve disc metadata, " "--unknown argument not passed") return -1 self.program.result.isCdr = cdrdao.DetectCdr(self.device) if (self.program.result.isCdr and not getattr(self.options, 'cdr', False)): logger.critical("inserted disc seems to be a CD-R, " "--cdr not passed") return -1 # Change working directory before cdrdao's task if getattr(self.options, 'working_directory', False): os.chdir(os.path.expanduser(self.options.working_directory)) if hasattr(self.options, 'output_directory'): out_bpath = self.options.output_directory # Needed to preserve cdrdao's tocfile out_fpath = self.program.getPath(out_bpath, self.options.disc_template, self.mbdiscid, self.program.metadata) else: out_fpath = None # now, read the complete index table, which is slower offset = getattr(self.options, 'offset', 0) self.itable = self.program.getTable(self.runner, self.ittoc.getCDDBDiscId(), self.ittoc.getMusicBrainzDiscId(), self.device, offset, out_fpath) assert self.itable.getCDDBDiscId() == self.ittoc.getCDDBDiscId(), \ "full table's id %s differs from toc id %s" % ( self.itable.getCDDBDiscId(), self.ittoc.getCDDBDiscId()) assert self.itable.getMusicBrainzDiscId() == \ self.ittoc.getMusicBrainzDiscId(), \ "full table's mb id %s differs from toc id mb %s" % ( self.itable.getMusicBrainzDiscId(), self.ittoc.getMusicBrainzDiscId()) if self.program.metadata: self.program.metadata.discid = self.ittoc.getMusicBrainzDiscId() # result self.program.result.cdrdaoVersion = cdrdao.version() self.program.result.cdparanoiaVersion = \ cdparanoia.getCdParanoiaVersion() info = drive.getDeviceInfo(self.device) if info: try: self.program.result.cdparanoiaDefeatsCache = \ self.config.getDefeatsCache(*info) except KeyError as e: logger.debug('got key error: %r', (e, )) self.program.result.artist = self.program.metadata \ and self.program.metadata.artist \ or 'Unknown Artist' self.program.result.title = self.program.metadata \ and self.program.metadata.releaseTitle \ or 'Unknown Title' _, self.program.result.vendor, self.program.result.model, \ self.program.result.release = \ cdio.Device(self.device).get_hwinfo() self.program.result.metadata = self.program.metadata ret = self.doCommand() if (self.options.eject == 'success' and self.eject or self.options.eject == 'always'): utils.eject_device(self.device) return ret
def add_arguments(self): loggers = list(result.getLoggers()) default_offset = None info = drive.getDeviceInfo(self.opts.device) if info: try: default_offset = config.Config().getReadOffset(*info) logger.info("using configured read offset %d", default_offset) except KeyError: pass _CD.add_arguments(self.parser) self.parser.add_argument('-L', '--logger', action="store", dest="logger", default='whipper', help=("logger to use (choose from: '%s" % "', '".join(loggers) + "')")) self.parser.add_argument('-o', '--offset', action="store", dest="offset", default=default_offset, help="sample read offset") self.parser.add_argument('-x', '--force-overread', action="store_true", dest="overread", default=False, help="Force overreading into the " "lead-out portion of the disc. Works only " "if the patched cdparanoia package is " "installed and the drive " "supports this feature. ") self.parser.add_argument('-O', '--output-directory', action="store", dest="output_directory", default=os.curdir, help="output directory; will be included " "in file paths in log") self.parser.add_argument('-W', '--working-directory', action="store", dest="working_directory", help="working directory; whipper will " "change to this directory " "and files will be created relative to " "it when not absolute") self.parser.add_argument('--track-template', action="store", dest="track_template", default=DEFAULT_TRACK_TEMPLATE, help="template for track file naming") self.parser.add_argument('--disc-template', action="store", dest="disc_template", default=DEFAULT_DISC_TEMPLATE, help="template for disc file naming") self.parser.add_argument('-U', '--unknown', action="store_true", dest="unknown", help="whether to continue ripping if " "the CD is unknown", default=False) self.parser.add_argument('--cdr', action="store_true", dest="cdr", help="whether to continue ripping if " "the disc is a CD-R", default=False) self.parser.add_argument('-C', '--cover-art', action="store", dest="cover_art", help="fetch cover art and save it as " "standalone file, embed into FLAC files " "or perform both actions: file, embed, " "complete option values respectively", choices=['file', 'embed', 'complete'], default=None) self.parser.add_argument('-r', '--max-retries', action="store", dest="max_retries", help="number of rip attempts before giving " "up if can't rip a track. This defaults to " "{}; 0 means " "infinity.".format(DEFAULT_MAX_RETRIES), default=DEFAULT_MAX_RETRIES) self.parser.add_argument('-k', '--keep-going', action='store_true', help="continue ripping further tracks " "instead of giving up if a track " "can't be ripped")
def do(self): self.config = config.Config() self.program = program.Program(self.config, record=self.options.record) self.runner = task.SyncRunner() # if the device is mounted (data session), unmount it self.device = self.options.device logger.info('checking device %s', self.device) utils.load_device(self.device) utils.unmount_device(self.device) # first, read the normal TOC, which is fast logger.info("reading TOC...") self.ittoc = self.program.getFastToc(self.runner, self.device) # already show us some info based on this self.program.getRipResult(self.ittoc.getCDDBDiscId()) print("CDDB disc id: %s" % self.ittoc.getCDDBDiscId()) self.mbdiscid = self.ittoc.getMusicBrainzDiscId() print("MusicBrainz disc id %s" % self.mbdiscid) print("MusicBrainz lookup URL %s" % self.ittoc.getMusicBrainzSubmitURL()) self.program.metadata = ( self.program.getMusicBrainz(self.ittoc, self.mbdiscid, release=self.options.release_id, country=self.options.country, prompt=self.options.prompt) ) if not self.program.metadata: # fall back to FreeDB for lookup cddbid = self.ittoc.getCDDBValues() cddbmd = self.program.getCDDB(cddbid) if cddbmd: logger.info('FreeDB identifies disc as %s', cddbmd) # also used by rip cd info if not getattr(self.options, 'unknown', False): logger.critical("unable to retrieve disc metadata, " "--unknown argument not passed") return -1 self.program.result.isCdr = cdrdao.DetectCdr(self.device) if (self.program.result.isCdr and not getattr(self.options, 'cdr', False)): logger.critical("inserted disc seems to be a CD-R, " "--cdr not passed") return -1 # Change working directory before cdrdao's task if self.options.working_directory is not None: os.chdir(os.path.expanduser(self.options.working_directory)) out_bpath = self.options.output_directory.decode('utf-8') # Needed to preserve cdrdao's tocfile out_fpath = self.program.getPath(out_bpath, self.options.disc_template, self.mbdiscid, self.program.metadata) # now, read the complete index table, which is slower self.itable = self.program.getTable(self.runner, self.ittoc.getCDDBDiscId(), self.ittoc.getMusicBrainzDiscId(), self.device, self.options.offset, out_fpath) assert self.itable.getCDDBDiscId() == self.ittoc.getCDDBDiscId(), \ "full table's id %s differs from toc id %s" % ( self.itable.getCDDBDiscId(), self.ittoc.getCDDBDiscId()) assert self.itable.getMusicBrainzDiscId() == \ self.ittoc.getMusicBrainzDiscId(), \ "full table's mb id %s differs from toc id mb %s" % ( self.itable.getMusicBrainzDiscId(), self.ittoc.getMusicBrainzDiscId()) assert self.itable.accuraterip_path() == \ self.ittoc.accuraterip_path(), \ "full table's AR URL %s differs from toc AR URL %s" % ( self.itable.accuraterip_url(), self.ittoc.accuraterip_url()) if self.program.metadata: self.program.metadata.discid = self.ittoc.getMusicBrainzDiscId() # result self.program.result.cdrdaoVersion = cdrdao.getCDRDAOVersion() self.program.result.cdparanoiaVersion = \ cdparanoia.getCdParanoiaVersion() info = drive.getDeviceInfo(self.device) if info: try: self.program.result.cdparanoiaDefeatsCache = \ self.config.getDefeatsCache(*info) except KeyError as e: logger.debug('got key error: %r', (e, )) self.program.result.artist = self.program.metadata \ and self.program.metadata.artist \ or 'Unknown Artist' self.program.result.title = self.program.metadata \ and self.program.metadata.title \ or 'Unknown Title' _, self.program.result.vendor, self.program.result.model, \ self.program.result.release = \ cdio.Device(self.device).get_hwinfo() self.doCommand() if self.options.eject in ('success', 'always'): utils.eject_device(self.device)
def do(self): self.config = config.Config() self.program = program.Program(self.config, record=self.options.record, stdout=sys.stdout) self.runner = task.SyncRunner() # if the device is mounted (data session), unmount it self.device = self.options.device sys.stdout.write('Checking device %s\n' % self.device) utils.load_device(self.device) utils.unmount_device(self.device) # first, read the normal TOC, which is fast self.ittoc = self.program.getFastToc(self.runner, self.options.toc_pickle, self.device) # already show us some info based on this self.program.getRipResult(self.ittoc.getCDDBDiscId()) sys.stdout.write("CDDB disc id: %s\n" % self.ittoc.getCDDBDiscId()) self.mbdiscid = self.ittoc.getMusicBrainzDiscId() sys.stdout.write("MusicBrainz disc id %s\n" % self.mbdiscid) sys.stdout.write("MusicBrainz lookup URL %s\n" % self.ittoc.getMusicBrainzSubmitURL()) self.program.metadata = ( self.program.getMusicBrainz(self.ittoc, self.mbdiscid, release=self.options.release_id, country=self.options.country, prompt=self.options.prompt) ) if not self.program.metadata: # fall back to FreeDB for lookup cddbid = self.ittoc.getCDDBValues() cddbmd = self.program.getCDDB(cddbid) if cddbmd: sys.stdout.write('FreeDB identifies disc as %s\n' % cddbmd) # also used by rip cd info if not getattr(self.options, 'unknown', False): logger.critical("unable to retrieve disc metadata, " "--unknown not passed") return -1 self.program.result.isCdr = cdrdao.DetectCdr(self.device) if (self.program.result.isCdr and not getattr(self.options, 'cdr', False)): logger.critical("inserted disc seems to be a CD-R, " "--cdr not passed") return -1 # now, read the complete index table, which is slower self.itable = self.program.getTable(self.runner, self.ittoc.getCDDBDiscId(), self.ittoc.getMusicBrainzDiscId(), self.device, self.options.offset) assert self.itable.getCDDBDiscId() == self.ittoc.getCDDBDiscId(), \ "full table's id %s differs from toc id %s" % ( self.itable.getCDDBDiscId(), self.ittoc.getCDDBDiscId()) assert self.itable.getMusicBrainzDiscId() == \ self.ittoc.getMusicBrainzDiscId(), \ "full table's mb id %s differs from toc id mb %s" % ( self.itable.getMusicBrainzDiscId(), self.ittoc.getMusicBrainzDiscId()) assert self.itable.accuraterip_path() == \ self.ittoc.accuraterip_path(), \ "full table's AR URL %s differs from toc AR URL %s" % ( self.itable.accuraterip_url(), self.ittoc.accuraterip_url()) if self.program.metadata: self.program.metadata.discid = self.ittoc.getMusicBrainzDiscId() # result self.program.result.cdrdaoVersion = cdrdao.getCDRDAOVersion() self.program.result.cdparanoiaVersion = \ cdparanoia.getCdParanoiaVersion() info = drive.getDeviceInfo(self.device) if info: try: self.program.result.cdparanoiaDefeatsCache = \ self.config.getDefeatsCache(*info) except KeyError as e: logger.debug('Got key error: %r' % (e, )) self.program.result.artist = self.program.metadata \ and self.program.metadata.artist \ or 'Unknown Artist' self.program.result.title = self.program.metadata \ and self.program.metadata.title \ or 'Unknown Title' _, self.program.result.vendor, self.program.result.model, \ self.program.result.release = \ cdio.Device(self.device).get_hwinfo() self.doCommand() if self.options.eject in ('success', 'always'): utils.eject_device(self.device)