def _tag_flac(self, trackno): """ Calls the mutagen library to perform metadata changes for FLAC files """ logging.debug("Tagging '%s'" % os.path.join(self.dest_dir_name, self.file_tag_map[trackno][1])) audio = FLAC(os.path.join(self.dest_dir_name, self.file_tag_map[trackno][1])) try: encoding = audio["ENCODING"] except: encoding = "" audio.delete() # add FLAC tag data audio["TITLE"] = self.tracks[trackno][1] audio["ARTIST"] = self.tracks[trackno][0] audio["ALBUM"] = self.title audio["COMPOSER"] = self.artist audio["ORGANIZATION"] = self.label audio["CATALOGNUM"] = self.catno audio["GENRE"] = self.genre audio["YEAR"] = self.year audio["TRACKNUMBER"] = str(trackno) audio["TRACKTOTAL"] = str(len(self.tracks)) audio["DESCRIPTION"] = '::> Don\'t believe the hype! <::' if(len(encoding) != 0): audio["ENCODING"] = encoding audio.pprint() try: audio.save() except: logging.error("Unable to tag '%s'" % self.file_tag_map[trackno][1]) raise DiscogsTaggerError, "Unable to write tag '%s'" % \ self.file_tag_map[trackno][1]
class Song: def __init__(self, path): self._path = path self._noext = '.'.join(path.split('.')[:-1]) if self._path.endswith('.mp3'): try: self._info = MP3(self._path) except mutagen.mp3.HeaderNotFoundError as e: print(path) raise e elif self._path.endswith('.flac'): self._info = FLAC(self._path) else: raise ValueError(f"Unknown file type: {self._path}") @property def title(self): if 'TITLE' in self._info: return str(self._info['TITLE'][0]) if 'TIT2' not in self._info: print(self._info.pprint()) return self._info['TIT2'].text[0] @property def album(self): if 'ALBUM' in self._info: return str(self._info['ALBUM'][0]) if 'TALB' not in self._info: print(self._info.pprint()) return self._info['TALB'].text[0] @property def year(self) -> str: try: return str(self._info['YEAR'][0]) except KeyError: try: return str(self._info['TDOR'][0]) except KeyError: return str(self._info['DATE'][0]) @property def path(self): return self._path def filename(self, remove_ext=True): path = self._path.split('/')[-1] if remove_ext: path = '.'.join(path.split('.')[:-1]) return path @property def track(self): return self._info['TRCK'].text[0] @property def album_mbid(self): return self._info['TXXX:MusicBrainz Album Id'].text[0]
def flac(file_path): audio = FLAC(file_path) print "p p r i n t for %s" % file_path audio.pprint() print "p p r i n t" print audio length = audio.info.length #bitrate = audio.info.bitrate bitrate = 0 return length, bitrate
def flac_process(file_dir, info): audio = FLAC(file_dir) audio["TITLE"] = info['TITLE'] audio["ARTIST"] = info['ARTIST'] audio["ALBUMARIST"] = info['ALBUMARIST'] audio["ALBUM"] = info['ALBUM'] # audio["DATE"] = info['DATE'] audio["GENRE"] = info['GENRE'] audio["TRACKNUMBER"] = info['TRACKNUMBER'] audio.pprint() audio.save()
def flac_process(file_dir, info): audio = FLAC(file_dir) if (('title' in audio.tags) and ('artist' in audio.tags)) == False: audio["TITLE"] = info['TITLE'] audio["ARTIST"] = info['ARTIST'] # audio["ALBUMARIST"] = info['ALBUMARIST'] # audio["ALBUM"] = info['ALBUM'] # audio["DATE"] = info['DATE'] # audio["GENRE"] = info['GENRE'] # audio["TRACKNUMBER"] = info['TRACKNUMBER'] # audio.pprint() # audio.save() audio.pprint() audio.save()
def printTags(): for root, dirs, files, in os.walk( r"C:\Users\talsi\Desktop\Music\AJR\Neotheater (2019)\new"): for name in files: if name.endswith((".mp3", ".flac")): if name.endswith(".flac"): print("it is .flac") audio = FLAC(root + "\\" + name) print(audio.pprint()) else: if name.endswith(".mp3"): print("it is .mp3 and the name of the file is: " + name) audio = ID3(root + "\\" + name) print(audio.pprint())
def dict2flac(d, flac_file, verbose=False): [ntp_timestamp, ntp_timestamp_frac] = d['ntp_timestamp'] #The array containing microseconds since the Bluebox started may well be too long to easily store in metadata #so this will need to be stored as an additional channel #The accelerometer data is 16 bit, but the micros data is 32 bit, however there is only one micros data #for every 16 accelerometer data, so with some manipulation, we can easily store these data in an #additional channel #Because micros are unsigned and accelerometers are signed, we need to do some work when extracting them. micro_channel = np.zeros((d['data'].shape[0], 1), dtype='int16') for idx, m in enumerate(d['micros']): micro_channel[2 * idx] = (m >> 16) & 0xffff micro_channel[2 * idx + 1] = m & 0xffff a = np.append(d['data'], micro_channel, axis=1) soundfile.write(flac_file, a, int(np.round(d['sample_rate']))) if verbose: print(flac_file) audio = FLAC(flac_file) audio["device_id"] = str(d['id']) audio["title"] = '"' + d['title'] + '"' audio["recorded"] = d['recorded'] audio["ntp_timestamp"] = str(ntp_timestamp) audio["ntp_timestamp_frac"] = str(ntp_timestamp_frac) audio["range"] = str(d['range']) audio["sample_rate"] = str(d['sample_rate']) audio["nominal_sample_rate"] = str(d['nominal_sample_rate']) audio["x_scale"] = str(d['x_scale']) audio["y_scale"] = str(d['y_scale']) audio["z_scale"] = str(d['z_scale']) audio["x_offset"] = str(d['x_offset']) audio["y_offset"] = str(d['y_offset']) audio["z_offset"] = str(d['z_offset']) audio.save() if verbose: audio.pprint()
def add_metadata(self, file, sound): # "sound" requires a "freesound_client.get_sound" object # http://wiki.hydrogenaud.io/index.php?title=APE_key try: # Write it audio = FLAC(file) audio["title"] = sound.name audio["Artist"] = sound.username audio["Comment"] = sound.description audio["Publisher"] = "freesound.org" audio["File"] = sound.url # Save it audio.pprint() audio.save() # Read it file_info = mutagen.File(file) log.debug("Result metadata update:") log.debug(file_info) return file_info except Exception as e: log.debug(e) return False
def _tagFiles(self, cue): """ Tags files with the metadata present in cue file """ file_path = cue.image_file_directory if cue.disctotal is not None and int(cue.disctotal) > 1: file_path = os.path.join(file_path, 'cd' + str(cue.discnumber)) for track in cue.tracks: if not track.number == None: src_file_name = cue.discnumber + '-' + str(track.number).zfill( 2) + '.flac' if cue.discnumber is not None else str( track.number).zfill(2) + '.flac' audio = FLAC(os.path.join(file_path, src_file_name)) if not track.title == None: audio["title"] = track.title if cue.performer != None: audio["artist"] = cue.performer if not track.number == None: audio["tracknumber"] = str(track.number) if not cue.title == None: audio["album"] = cue.title if not track.isrc == None: audio["isrc"] = track.isrc if not cue.genre == None: audio["genre"] = cue.genre if not cue.date == None: audio["date"] = cue.date if not cue.discid == None: audio["discid"] = cue.discid if not cue.comment == None: audio["comment"] = cue.comment if not cue.discnumber == None: audio["discnumber"] = cue.discnumber if not cue.disctotal == None: audio["disctotal"] = cue.disctotal # 0th track left blank audio["tracktotal"] = str(len(cue.tracks) - 1) audio.pprint() audio.save()
def setTags( self, tid, path ): t = FLAC( path ) if int( t.get('tidal_rip_version','0') ) < 1: d = self.getTags( tid ) for k in ['title','album','artist','albumartist', 'tracknumber','tracktotal','discnumber','disctotal', 'duration','albumduration', 'date','isrc','barcode','copyright','releasetype']: t[k] = str( d[k] ) for k in ['replaygain_track_gain','replaygain_track_peak']: t[k] = str( d[k] ) t['tidal_rip_version'] = '2' if 0: print('DICT', d) print(t.pprint()) print(t.tags) t.save()
class TFLAC(TestCase): SAMPLE = os.path.join("tests", "data", "silence-44-s.flac") NEW = SAMPLE + ".new" def setUp(self): shutil.copy(self.SAMPLE, self.NEW) self.failUnlessEqual(open(self.SAMPLE).read(), open(self.NEW).read()) self.flac = FLAC(self.NEW) def test_delete(self): self.failUnless(self.flac.tags) self.flac.delete() self.failIf(self.flac.tags) flac = FLAC(self.NEW) self.failIf(flac.tags) def test_module_delete(self): delete(self.NEW) flac = FLAC(self.NEW) self.failIf(flac.tags) def test_info(self): self.failUnlessAlmostEqual(FLAC(self.NEW).info.length, 3.7, 1) def test_keys(self): self.failUnlessEqual(self.flac.keys(), self.flac.tags.keys()) def test_values(self): self.failUnlessEqual(self.flac.values(), self.flac.tags.values()) def test_items(self): self.failUnlessEqual(self.flac.items(), self.flac.tags.items()) def test_vc(self): self.failUnlessEqual(self.flac['title'][0], 'Silence') def test_write_nochange(self): f = FLAC(self.NEW) f.save() self.failUnlessEqual(open(self.SAMPLE).read(), open(self.NEW).read()) def test_write_changetitle(self): f = FLAC(self.NEW) f["title"] = "A New Title" f.save() f = FLAC(self.NEW) self.failUnlessEqual(f["title"][0], "A New Title") def test_write_changetitle_unicode_value(self): f = FLAC(self.NEW) f["title"] = u"A Unicode Title \u2022" f.save() f = FLAC(self.NEW) self.failUnlessEqual(f["title"][0], u"A Unicode Title \u2022") def test_write_changetitle_unicode_key(self): f = FLAC(self.NEW) f[u"title"] = "A New Title" f.save() f = FLAC(self.NEW) self.failUnlessEqual(f[u"title"][0], "A New Title") def test_write_changetitle_unicode_key_and_value(self): f = FLAC(self.NEW) f[u"title"] = u"A Unicode Title \u2022" f.save() f = FLAC(self.NEW) self.failUnlessEqual(f[u"title"][0], u"A Unicode Title \u2022") def test_force_grow(self): f = FLAC(self.NEW) f["faketag"] = ["a" * 1000] * 1000 f.save() f = FLAC(self.NEW) self.failUnlessEqual(f["faketag"], ["a" * 1000] * 1000) def test_force_shrink(self): self.test_force_grow() f = FLAC(self.NEW) f["faketag"] = "foo" f.save() f = FLAC(self.NEW) self.failUnlessEqual(f["faketag"], ["foo"]) def test_add_vc(self): f = FLAC(os.path.join("tests", "data", "no-tags.flac")) self.failIf(f.tags) f.add_tags() self.failUnless(f.tags == []) self.failUnlessRaises(ValueError, f.add_tags) def test_add_vc_implicit(self): f = FLAC(os.path.join("tests", "data", "no-tags.flac")) self.failIf(f.tags) f["foo"] = "bar" self.failUnless(f.tags == [("foo", "bar")]) self.failUnlessRaises(ValueError, f.add_tags) def test_ooming_vc_header(self): # issue 112: Malformed FLAC Vorbis header causes out of memory error # http://code.google.com/p/mutagen/issues/detail?id=112 self.assertRaises(IOError, FLAC, os.path.join('tests', 'data', 'ooming-header.flac')) def test_with_real_flac(self): if not have_flac: return self.flac["faketag"] = "foobar" * 1000 self.flac.save() badval = os.system("tools/notarealprogram 2> %s" % devnull) value = os.system("flac -t %s 2> %s" % (self.flac.filename, devnull)) self.failIf(value and value != badval) def test_save_unknown_block(self): block = MetadataBlock("test block data") block.code = 99 self.flac.metadata_blocks.append(block) self.flac.save() def test_load_unknown_block(self): self.test_save_unknown_block() flac = FLAC(self.NEW) self.failUnlessEqual(len(flac.metadata_blocks), 7) self.failUnlessEqual(flac.metadata_blocks[5].code, 99) self.failUnlessEqual(flac.metadata_blocks[5].data, "test block data") def test_two_vorbis_blocks(self): self.flac.metadata_blocks.append(self.flac.metadata_blocks[1]) self.flac.save() self.failUnlessRaises(IOError, FLAC, self.NEW) def test_missing_streaminfo(self): self.flac.metadata_blocks.pop(0) self.flac.save() self.failUnlessRaises(IOError, FLAC, self.NEW) def test_load_invalid_flac(self): self.failUnlessRaises( IOError, FLAC, os.path.join("tests", "data", "xing.mp3")) def test_save_invalid_flac(self): self.failUnlessRaises( IOError, self.flac.save, os.path.join("tests", "data", "xing.mp3")) def test_pprint(self): self.failUnless(self.flac.pprint()) def test_double_load(self): blocks = list(self.flac.metadata_blocks) self.flac.load(self.flac.filename) self.failUnlessEqual(blocks, self.flac.metadata_blocks) def test_seektable(self): self.failUnless(self.flac.seektable) def test_cuesheet(self): self.failUnless(self.flac.cuesheet) def test_pictures(self): self.failUnless(self.flac.pictures) def test_add_picture(self): f = FLAC(self.NEW) c = len(f.pictures) f.add_picture(Picture()) f.save() f = FLAC(self.NEW) self.failUnlessEqual(len(f.pictures), c + 1) def test_clear_pictures(self): f = FLAC(self.NEW) c1 = len(f.pictures) c2 = len(f.metadata_blocks) f.clear_pictures() f.save() f = FLAC(self.NEW) self.failUnlessEqual(len(f.metadata_blocks), c2 - c1) def test_ignore_id3(self): id3 = ID3() id3.add(TIT2(encoding=0, text='id3 title')) id3.save(self.NEW) f = FLAC(self.NEW) f['title'] = 'vc title' f.save() id3 = ID3(self.NEW) self.failUnlessEqual(id3['TIT2'].text, ['id3 title']) f = FLAC(self.NEW) self.failUnlessEqual(f['title'], ['vc title']) def test_delete_id3(self): id3 = ID3() id3.add(TIT2(encoding=0, text='id3 title')) id3.save(self.NEW, v1=2) f = FLAC(self.NEW) f['title'] = 'vc title' f.save(deleteid3=True) self.failUnlessRaises(ID3NoHeaderError, ID3, self.NEW) f = FLAC(self.NEW) self.failUnlessEqual(f['title'], ['vc title']) def test_mime(self): self.failUnless("audio/x-flac" in self.flac.mime) def test_variable_block_size(self): FLAC(os.path.join("tests", "data", "variable-block.flac")) def test_load_flac_with_application_block(self): FLAC(os.path.join("tests", "data", "flac_application.flac")) def tearDown(self): os.unlink(self.NEW)
class TFLAC(TestCase): SAMPLE = os.path.join(DATA_DIR, "silence-44-s.flac") def setUp(self): self.NEW = get_temp_copy(self.SAMPLE) self.flac = FLAC(self.NEW) def tearDown(self): os.unlink(self.NEW) def test_zero_samples(self): # write back zero sample count and load again self.flac.info.total_samples = 0 self.flac.save() new = FLAC(self.flac.filename) assert new.info.total_samples == 0 assert new.info.bitrate == 0 assert new.info.length == 0.0 def test_bitrate(self): assert self.flac.info.bitrate == 101430 old_file_size = os.path.getsize(self.flac.filename) self.flac.save(padding=lambda x: 9999) new_flac = FLAC(self.flac.filename) assert os.path.getsize(new_flac.filename) > old_file_size assert new_flac.info.bitrate == 101430 def test_padding(self): for pad in [0, 42, 2**24 - 1, 2 ** 24]: self.flac.save(padding=lambda x: pad) new = FLAC(self.flac.filename) expected = min(2**24 - 1, pad) self.assertEqual(new.metadata_blocks[-1].length, expected) def test_save_multiple_padding(self): # we don't touch existing padding blocks on save, but will # replace them in the file with one at the end def num_padding(f): blocks = f.metadata_blocks return len([b for b in blocks if isinstance(b, Padding)]) num_blocks = num_padding(self.flac) self.assertEqual(num_blocks, 1) block = Padding() block.length = 42 self.flac.metadata_blocks.append(block) block = Padding() block.length = 24 self.flac.metadata_blocks.append(block) self.flac.save() self.assertEqual(num_padding(self.flac), num_blocks + 2) new = FLAC(self.flac.filename) self.assertEqual(num_padding(new), 1) self.assertTrue(isinstance(new.metadata_blocks[-1], Padding)) def test_increase_size_new_padding(self): self.assertEqual(self.flac.metadata_blocks[-1].length, 3060) value = u"foo" * 100 self.flac[u"foo"] = [value] self.flac.save() new = FLAC(self.NEW) self.assertEqual(new.metadata_blocks[-1].length, 2752) self.assertEqual(new[u"foo"], [value]) def test_delete(self): self.failUnless(self.flac.tags) self.flac.delete() self.assertTrue(self.flac.tags is not None) self.assertFalse(self.flac.tags) flac = FLAC(self.NEW) self.assertTrue(flac.tags is None) def test_delete_change_reload(self): self.flac.delete() self.flac.tags["FOO"] = ["BAR"] self.flac.save() assert FLAC(self.flac.filename)["FOO"] == ["BAR"] # same with delete failing due to IO etc. with pytest.raises(MutagenError): self.flac.delete(os.devnull) self.flac.tags["FOO"] = ["QUUX"] self.flac.save() assert FLAC(self.flac.filename)["FOO"] == ["QUUX"] def test_module_delete(self): delete(self.NEW) flac = FLAC(self.NEW) self.failIf(flac.tags) def test_info(self): self.failUnlessAlmostEqual(FLAC(self.NEW).info.length, 3.7, 1) def test_keys(self): self.failUnlessEqual( list(self.flac.keys()), list(self.flac.tags.keys())) def test_values(self): self.failUnlessEqual( list(self.flac.values()), list(self.flac.tags.values())) def test_items(self): self.failUnlessEqual( list(self.flac.items()), list(self.flac.tags.items())) def test_vc(self): self.failUnlessEqual(self.flac['title'][0], 'Silence') def test_write_nochange(self): f = FLAC(self.NEW) f.save() with open(self.SAMPLE, "rb") as a: with open(self.NEW, "rb") as b: self.failUnlessEqual(a.read(), b.read()) def test_write_changetitle(self): f = FLAC(self.NEW) if PY3: self.assertRaises( TypeError, f.__setitem__, b'title', b"A New Title") else: f[b"title"] = b"A New Title" f.save() f = FLAC(self.NEW) self.failUnlessEqual(f[b"title"][0], b"A New Title") def test_write_changetitle_unicode_value(self): f = FLAC(self.NEW) if PY3: self.assertRaises( TypeError, f.__setitem__, b'title', u"A Unicode Title \u2022") else: f[b"title"] = u"A Unicode Title \u2022" f.save() f = FLAC(self.NEW) self.failUnlessEqual(f[b"title"][0], u"A Unicode Title \u2022") def test_write_changetitle_unicode_key(self): f = FLAC(self.NEW) f[u"title"] = b"A New Title" if PY3: self.assertRaises(ValueError, f.save) else: f.save() f = FLAC(self.NEW) self.failUnlessEqual(f[u"title"][0], b"A New Title") def test_write_changetitle_unicode_key_and_value(self): f = FLAC(self.NEW) f[u"title"] = u"A Unicode Title \u2022" f.save() f = FLAC(self.NEW) self.failUnlessEqual(f[u"title"][0], u"A Unicode Title \u2022") def test_force_grow(self): f = FLAC(self.NEW) f["faketag"] = ["a" * 1000] * 1000 f.save() f = FLAC(self.NEW) self.failUnlessEqual(f["faketag"], ["a" * 1000] * 1000) def test_force_shrink(self): self.test_force_grow() f = FLAC(self.NEW) f["faketag"] = "foo" f.save() f = FLAC(self.NEW) self.failUnlessEqual(f["faketag"], ["foo"]) def test_add_vc(self): f = FLAC(os.path.join(DATA_DIR, "no-tags.flac")) self.failIf(f.tags) f.add_tags() self.failUnless(f.tags == []) self.failUnlessRaises(ValueError, f.add_tags) def test_add_vc_implicit(self): f = FLAC(os.path.join(DATA_DIR, "no-tags.flac")) self.failIf(f.tags) f["foo"] = "bar" self.failUnless(f.tags == [("foo", "bar")]) self.failUnlessRaises(ValueError, f.add_tags) def test_ooming_vc_header(self): # issue 112: Malformed FLAC Vorbis header causes out of memory error # https://github.com/quodlibet/mutagen/issues/112 self.assertRaises(error, FLAC, os.path.join(DATA_DIR, 'ooming-header.flac')) def test_with_real_flac(self): if not have_flac: return self.flac["faketag"] = "foobar" * 1000 self.flac.save() self.failIf(call_flac("-t", self.flac.filename) != 0) def test_save_unknown_block(self): block = MetadataBlock(b"test block data") block.code = 99 self.flac.metadata_blocks.append(block) self.flac.save() def test_load_unknown_block(self): self.test_save_unknown_block() flac = FLAC(self.NEW) self.failUnlessEqual(len(flac.metadata_blocks), 7) self.failUnlessEqual(flac.metadata_blocks[5].code, 99) self.failUnlessEqual(flac.metadata_blocks[5].data, b"test block data") def test_two_vorbis_blocks(self): self.flac.metadata_blocks.append(self.flac.metadata_blocks[1]) self.flac.save() self.failUnlessRaises(error, FLAC, self.NEW) def test_missing_streaminfo(self): self.flac.metadata_blocks.pop(0) self.flac.save() self.failUnlessRaises(error, FLAC, self.NEW) def test_load_invalid_flac(self): self.failUnlessRaises( error, FLAC, os.path.join(DATA_DIR, "xing.mp3")) def test_save_invalid_flac(self): self.failUnlessRaises( error, self.flac.save, os.path.join(DATA_DIR, "xing.mp3")) def test_pprint(self): self.failUnless(self.flac.pprint()) def test_double_load(self): blocks = list(self.flac.metadata_blocks) self.flac.load(self.flac.filename) self.failUnlessEqual(blocks, self.flac.metadata_blocks) def test_seektable(self): self.failUnless(self.flac.seektable) def test_cuesheet(self): self.failUnless(self.flac.cuesheet) def test_pictures(self): self.failUnless(self.flac.pictures) def test_add_picture(self): f = FLAC(self.NEW) c = len(f.pictures) f.add_picture(Picture()) f.save() f = FLAC(self.NEW) self.failUnlessEqual(len(f.pictures), c + 1) def test_clear_pictures(self): f = FLAC(self.NEW) c1 = len(f.pictures) c2 = len(f.metadata_blocks) f.clear_pictures() f.save() f = FLAC(self.NEW) self.failUnlessEqual(len(f.metadata_blocks), c2 - c1) def test_ignore_id3(self): id3 = ID3() id3.add(TIT2(encoding=0, text='id3 title')) id3.save(self.NEW) f = FLAC(self.NEW) f['title'] = 'vc title' f.save() id3 = ID3(self.NEW) self.failUnlessEqual(id3['TIT2'].text, ['id3 title']) f = FLAC(self.NEW) self.failUnlessEqual(f['title'], ['vc title']) def test_delete_id3(self): id3 = ID3() id3.add(TIT2(encoding=0, text='id3 title')) id3.save(self.NEW, v1=2) f = FLAC(self.NEW) f['title'] = 'vc title' f.save(deleteid3=True) self.failUnlessRaises(ID3NoHeaderError, ID3, self.NEW) f = FLAC(self.NEW) self.failUnlessEqual(f['title'], ['vc title']) def test_save_on_mp3(self): path = os.path.join(DATA_DIR, "silence-44-s.mp3") self.assertRaises(error, self.flac.save, path) def test_mime(self): self.failUnless("audio/x-flac" in self.flac.mime) def test_variable_block_size(self): FLAC(os.path.join(DATA_DIR, "variable-block.flac")) def test_load_flac_with_application_block(self): FLAC(os.path.join(DATA_DIR, "flac_application.flac"))
class TFLAC(TestCase): SAMPLE = os.path.join(DATA_DIR, "silence-44-s.flac") def setUp(self): self.NEW = get_temp_copy(self.SAMPLE) self.flac = FLAC(self.NEW) def tearDown(self): os.unlink(self.NEW) def test_zero_samples(self): # write back zero sample count and load again self.flac.info.total_samples = 0 self.flac.save() new = FLAC(self.flac.filename) assert new.info.total_samples == 0 assert new.info.bitrate == 0 assert new.info.length == 0.0 def test_bitrate(self): assert self.flac.info.bitrate == 101430 old_file_size = os.path.getsize(self.flac.filename) self.flac.save(padding=lambda x: 9999) new_flac = FLAC(self.flac.filename) assert os.path.getsize(new_flac.filename) > old_file_size assert new_flac.info.bitrate == 101430 def test_padding(self): for pad in [0, 42, 2**24 - 1, 2**24]: self.flac.save(padding=lambda x: pad) new = FLAC(self.flac.filename) expected = min(2**24 - 1, pad) self.assertEqual(new.metadata_blocks[-1].length, expected) def test_save_multiple_padding(self): # we don't touch existing padding blocks on save, but will # replace them in the file with one at the end def num_padding(f): blocks = f.metadata_blocks return len([b for b in blocks if isinstance(b, Padding)]) num_blocks = num_padding(self.flac) self.assertEqual(num_blocks, 1) block = Padding() block.length = 42 self.flac.metadata_blocks.append(block) block = Padding() block.length = 24 self.flac.metadata_blocks.append(block) self.flac.save() self.assertEqual(num_padding(self.flac), num_blocks + 2) new = FLAC(self.flac.filename) self.assertEqual(num_padding(new), 1) self.assertTrue(isinstance(new.metadata_blocks[-1], Padding)) def test_increase_size_new_padding(self): self.assertEqual(self.flac.metadata_blocks[-1].length, 3060) value = u"foo" * 100 self.flac[u"foo"] = [value] self.flac.save() new = FLAC(self.NEW) self.assertEqual(new.metadata_blocks[-1].length, 2752) self.assertEqual(new[u"foo"], [value]) def test_delete(self): self.failUnless(self.flac.tags) self.flac.delete() self.assertTrue(self.flac.tags is not None) self.assertFalse(self.flac.tags) flac = FLAC(self.NEW) self.assertTrue(flac.tags is None) def test_module_delete(self): delete(self.NEW) flac = FLAC(self.NEW) self.failIf(flac.tags) def test_info(self): self.failUnlessAlmostEqual(FLAC(self.NEW).info.length, 3.7, 1) def test_keys(self): self.failUnlessEqual(list(self.flac.keys()), list(self.flac.tags.keys())) def test_values(self): self.failUnlessEqual(list(self.flac.values()), list(self.flac.tags.values())) def test_items(self): self.failUnlessEqual(list(self.flac.items()), list(self.flac.tags.items())) def test_vc(self): self.failUnlessEqual(self.flac['title'][0], 'Silence') def test_write_nochange(self): f = FLAC(self.NEW) f.save() with open(self.SAMPLE, "rb") as a: with open(self.NEW, "rb") as b: self.failUnlessEqual(a.read(), b.read()) def test_write_changetitle(self): f = FLAC(self.NEW) if PY3: self.assertRaises(TypeError, f.__setitem__, b'title', b"A New Title") else: f[b"title"] = b"A New Title" f.save() f = FLAC(self.NEW) self.failUnlessEqual(f[b"title"][0], b"A New Title") def test_write_changetitle_unicode_value(self): f = FLAC(self.NEW) if PY3: self.assertRaises(TypeError, f.__setitem__, b'title', u"A Unicode Title \u2022") else: f[b"title"] = u"A Unicode Title \u2022" f.save() f = FLAC(self.NEW) self.failUnlessEqual(f[b"title"][0], u"A Unicode Title \u2022") def test_write_changetitle_unicode_key(self): f = FLAC(self.NEW) f[u"title"] = b"A New Title" if PY3: self.assertRaises(ValueError, f.save) else: f.save() f = FLAC(self.NEW) self.failUnlessEqual(f[u"title"][0], b"A New Title") def test_write_changetitle_unicode_key_and_value(self): f = FLAC(self.NEW) f[u"title"] = u"A Unicode Title \u2022" f.save() f = FLAC(self.NEW) self.failUnlessEqual(f[u"title"][0], u"A Unicode Title \u2022") def test_force_grow(self): f = FLAC(self.NEW) f["faketag"] = ["a" * 1000] * 1000 f.save() f = FLAC(self.NEW) self.failUnlessEqual(f["faketag"], ["a" * 1000] * 1000) def test_force_shrink(self): self.test_force_grow() f = FLAC(self.NEW) f["faketag"] = "foo" f.save() f = FLAC(self.NEW) self.failUnlessEqual(f["faketag"], ["foo"]) def test_add_vc(self): f = FLAC(os.path.join(DATA_DIR, "no-tags.flac")) self.failIf(f.tags) f.add_tags() self.failUnless(f.tags == []) self.failUnlessRaises(ValueError, f.add_tags) def test_add_vc_implicit(self): f = FLAC(os.path.join(DATA_DIR, "no-tags.flac")) self.failIf(f.tags) f["foo"] = "bar" self.failUnless(f.tags == [("foo", "bar")]) self.failUnlessRaises(ValueError, f.add_tags) def test_ooming_vc_header(self): # issue 112: Malformed FLAC Vorbis header causes out of memory error # https://github.com/quodlibet/mutagen/issues/112 self.assertRaises(error, FLAC, os.path.join(DATA_DIR, 'ooming-header.flac')) def test_with_real_flac(self): if not have_flac: return self.flac["faketag"] = "foobar" * 1000 self.flac.save() self.failIf(call_flac("-t", self.flac.filename) != 0) def test_save_unknown_block(self): block = MetadataBlock(b"test block data") block.code = 99 self.flac.metadata_blocks.append(block) self.flac.save() def test_load_unknown_block(self): self.test_save_unknown_block() flac = FLAC(self.NEW) self.failUnlessEqual(len(flac.metadata_blocks), 7) self.failUnlessEqual(flac.metadata_blocks[5].code, 99) self.failUnlessEqual(flac.metadata_blocks[5].data, b"test block data") def test_two_vorbis_blocks(self): self.flac.metadata_blocks.append(self.flac.metadata_blocks[1]) self.flac.save() self.failUnlessRaises(error, FLAC, self.NEW) def test_missing_streaminfo(self): self.flac.metadata_blocks.pop(0) self.flac.save() self.failUnlessRaises(error, FLAC, self.NEW) def test_load_invalid_flac(self): self.failUnlessRaises(error, FLAC, os.path.join(DATA_DIR, "xing.mp3")) def test_save_invalid_flac(self): self.failUnlessRaises(error, self.flac.save, os.path.join(DATA_DIR, "xing.mp3")) def test_pprint(self): self.failUnless(self.flac.pprint()) def test_double_load(self): blocks = list(self.flac.metadata_blocks) self.flac.load(self.flac.filename) self.failUnlessEqual(blocks, self.flac.metadata_blocks) def test_seektable(self): self.failUnless(self.flac.seektable) def test_cuesheet(self): self.failUnless(self.flac.cuesheet) def test_pictures(self): self.failUnless(self.flac.pictures) def test_add_picture(self): f = FLAC(self.NEW) c = len(f.pictures) f.add_picture(Picture()) f.save() f = FLAC(self.NEW) self.failUnlessEqual(len(f.pictures), c + 1) def test_clear_pictures(self): f = FLAC(self.NEW) c1 = len(f.pictures) c2 = len(f.metadata_blocks) f.clear_pictures() f.save() f = FLAC(self.NEW) self.failUnlessEqual(len(f.metadata_blocks), c2 - c1) def test_ignore_id3(self): id3 = ID3() id3.add(TIT2(encoding=0, text='id3 title')) id3.save(self.NEW) f = FLAC(self.NEW) f['title'] = 'vc title' f.save() id3 = ID3(self.NEW) self.failUnlessEqual(id3['TIT2'].text, ['id3 title']) f = FLAC(self.NEW) self.failUnlessEqual(f['title'], ['vc title']) def test_delete_id3(self): id3 = ID3() id3.add(TIT2(encoding=0, text='id3 title')) id3.save(self.NEW, v1=2) f = FLAC(self.NEW) f['title'] = 'vc title' f.save(deleteid3=True) self.failUnlessRaises(ID3NoHeaderError, ID3, self.NEW) f = FLAC(self.NEW) self.failUnlessEqual(f['title'], ['vc title']) def test_save_on_mp3(self): path = os.path.join(DATA_DIR, "silence-44-s.mp3") self.assertRaises(error, self.flac.save, path) def test_mime(self): self.failUnless("audio/x-flac" in self.flac.mime) def test_variable_block_size(self): FLAC(os.path.join(DATA_DIR, "variable-block.flac")) def test_load_flac_with_application_block(self): FLAC(os.path.join(DATA_DIR, "flac_application.flac"))
class TFLAC(TestCase): SAMPLE = os.path.join("tests", "data", "silence-44-s.flac") NEW = SAMPLE + ".new" def setUp(self): shutil.copy(self.SAMPLE, self.NEW) self.failUnlessEqual(open(self.SAMPLE, "rb").read(), open(self.NEW, "rb").read()) self.flac = FLAC(self.NEW) def test_delete(self): self.failUnless(self.flac.tags) self.flac.delete() self.failIf(self.flac.tags) flac = FLAC(self.NEW) self.failIf(flac.tags) def test_module_delete(self): delete(self.NEW) flac = FLAC(self.NEW) self.failIf(flac.tags) def test_info(self): self.failUnlessAlmostEqual(FLAC(self.NEW).info.length, 3.7, 1) def test_keys(self): self.failUnlessEqual( list(self.flac.keys()), list(self.flac.tags.keys())) def test_values(self): self.failUnlessEqual( list(self.flac.values()), list(self.flac.tags.values())) def test_items(self): self.failUnlessEqual( list(self.flac.items()), list(self.flac.tags.items())) def test_vc(self): self.failUnlessEqual(self.flac['title'][0], 'Silence') def test_write_nochange(self): f = FLAC(self.NEW) f.save() self.failUnlessEqual(open(self.SAMPLE, "rb").read(), open(self.NEW, "rb").read()) def test_write_changetitle(self): f = FLAC(self.NEW) if PY3: self.assertRaises( TypeError, f.__setitem__, b'title', b"A New Title") else: f[b"title"] = b"A New Title" f.save() f = FLAC(self.NEW) self.failUnlessEqual(f[b"title"][0], b"A New Title") def test_write_changetitle_unicode_value(self): f = FLAC(self.NEW) if PY3: self.assertRaises( TypeError, f.__setitem__, b'title', u"A Unicode Title \u2022") else: f[b"title"] = u"A Unicode Title \u2022" f.save() f = FLAC(self.NEW) self.failUnlessEqual(f[b"title"][0], u"A Unicode Title \u2022") def test_write_changetitle_unicode_key(self): f = FLAC(self.NEW) f[u"title"] = b"A New Title" if PY3: self.assertRaises(ValueError, f.save) else: f.save() f = FLAC(self.NEW) self.failUnlessEqual(f[u"title"][0], b"A New Title") def test_write_changetitle_unicode_key_and_value(self): f = FLAC(self.NEW) f[u"title"] = u"A Unicode Title \u2022" f.save() f = FLAC(self.NEW) self.failUnlessEqual(f[u"title"][0], u"A Unicode Title \u2022") def test_force_grow(self): f = FLAC(self.NEW) f["faketag"] = ["a" * 1000] * 1000 f.save() f = FLAC(self.NEW) self.failUnlessEqual(f["faketag"], ["a" * 1000] * 1000) def test_force_shrink(self): self.test_force_grow() f = FLAC(self.NEW) f["faketag"] = "foo" f.save() f = FLAC(self.NEW) self.failUnlessEqual(f["faketag"], ["foo"]) def test_add_vc(self): f = FLAC(os.path.join("tests", "data", "no-tags.flac")) self.failIf(f.tags) f.add_tags() self.failUnless(f.tags == []) self.failUnlessRaises(ValueError, f.add_tags) def test_add_vc_implicit(self): f = FLAC(os.path.join("tests", "data", "no-tags.flac")) self.failIf(f.tags) f["foo"] = "bar" self.failUnless(f.tags == [("foo", "bar")]) self.failUnlessRaises(ValueError, f.add_tags) def test_ooming_vc_header(self): # issue 112: Malformed FLAC Vorbis header causes out of memory error # http://code.google.com/p/mutagen/issues/detail?id=112 self.assertRaises(IOError, FLAC, os.path.join('tests', 'data', 'ooming-header.flac')) def test_with_real_flac(self): if not have_flac: return self.flac["faketag"] = "foobar" * 1000 self.flac.save() badval = os.system("tools/notarealprogram 2> %s" % devnull) value = os.system("flac -t %s 2> %s" % (self.flac.filename, devnull)) self.failIf(value and value != badval) def test_save_unknown_block(self): block = MetadataBlock(b"test block data") block.code = 99 self.flac.metadata_blocks.append(block) self.flac.save() def test_load_unknown_block(self): self.test_save_unknown_block() flac = FLAC(self.NEW) self.failUnlessEqual(len(flac.metadata_blocks), 7) self.failUnlessEqual(flac.metadata_blocks[5].code, 99) self.failUnlessEqual(flac.metadata_blocks[5].data, b"test block data") def test_two_vorbis_blocks(self): self.flac.metadata_blocks.append(self.flac.metadata_blocks[1]) self.flac.save() self.failUnlessRaises(IOError, FLAC, self.NEW) def test_missing_streaminfo(self): self.flac.metadata_blocks.pop(0) self.flac.save() self.failUnlessRaises(IOError, FLAC, self.NEW) def test_load_invalid_flac(self): self.failUnlessRaises( IOError, FLAC, os.path.join("tests", "data", "xing.mp3")) def test_save_invalid_flac(self): self.failUnlessRaises( IOError, self.flac.save, os.path.join("tests", "data", "xing.mp3")) def test_pprint(self): self.failUnless(self.flac.pprint()) def test_double_load(self): blocks = list(self.flac.metadata_blocks) self.flac.load(self.flac.filename) self.failUnlessEqual(blocks, self.flac.metadata_blocks) def test_seektable(self): self.failUnless(self.flac.seektable) def test_cuesheet(self): self.failUnless(self.flac.cuesheet) def test_pictures(self): self.failUnless(self.flac.pictures) def test_add_picture(self): f = FLAC(self.NEW) c = len(f.pictures) f.add_picture(Picture()) f.save() f = FLAC(self.NEW) self.failUnlessEqual(len(f.pictures), c + 1) def test_clear_pictures(self): f = FLAC(self.NEW) c1 = len(f.pictures) c2 = len(f.metadata_blocks) f.clear_pictures() f.save() f = FLAC(self.NEW) self.failUnlessEqual(len(f.metadata_blocks), c2 - c1) def test_ignore_id3(self): id3 = ID3() id3.add(TIT2(encoding=0, text='id3 title')) id3.save(self.NEW) f = FLAC(self.NEW) f['title'] = 'vc title' f.save() id3 = ID3(self.NEW) self.failUnlessEqual(id3['TIT2'].text, ['id3 title']) f = FLAC(self.NEW) self.failUnlessEqual(f['title'], ['vc title']) def test_delete_id3(self): id3 = ID3() id3.add(TIT2(encoding=0, text='id3 title')) id3.save(self.NEW, v1=2) f = FLAC(self.NEW) f['title'] = 'vc title' f.save(deleteid3=True) self.failUnlessRaises(ID3NoHeaderError, ID3, self.NEW) f = FLAC(self.NEW) self.failUnlessEqual(f['title'], ['vc title']) def test_mime(self): self.failUnless("audio/x-flac" in self.flac.mime) def test_variable_block_size(self): FLAC(os.path.join("tests", "data", "variable-block.flac")) def test_load_flac_with_application_block(self): FLAC(os.path.join("tests", "data", "flac_application.flac")) def tearDown(self): os.unlink(self.NEW)
#hey imma parse ur boxes ok import csv from mutagen.flac import FLAC #discogs.user_agent = 'CrystalDiscogsBot/0.1 +http://www.crystal-lp.com' with open('boxes.csv', 'r') as boxes: spamreader = csv.reader(boxes) print 'Hello, world!' rowdata = [] for row in spamreader: rowdata.append(row) rowInput = 14 for row in rowdata: if row[0] == str(rowInput): print 'Match!' print 'RealRow:',row audio = FLAC('fong1.flac') audio['title'] = row[0] audio['artist'] = row[1] audio['album'] = row[2] audio.pprint() audio.save() break else: print 'No match found.' print
def __init__(self,filesrc): folderpaths = [path for (path, folders, files) in os.walk(filesrc)] filenames = [files for (path, folders, files) in os.walk(filesrc)] for i in range(len(folderpaths)): for j in range(len(filenames[i])): if(i==0): filenames[i][j] = folderpaths[i] + filenames[i][j] else: filenames[i][j] = folderpaths[i] + "/"+ filenames[i][j] for i in range(len(folderpaths)): for j in range(len(filenames[i])): if len(filenames[i]) == 0: continue temp = i src = filenames[i][j] mime = magic.open(magic.MAGIC_MIME) mime.load() mime = mime.file(src).split(";")[0] mp3Type = ['audio/mpeg', 'audio/mpeg3', 'audio/x-mpeg', 'audio/x-mpeg-3'] flacType = ['audio/x-flac', 'audio/flac'] oggType = ['application/ogg', 'audio/vorbis', 'audio/x-vorbis', 'application/ogg', 'application/x-ogg', 'application/octet-stream', 'audio/ogg', 'video/ogg'] wmaType = ['video/x-ms-asf','audio/x-ms-wma', 'audio/x-ms-wmv', 'audio/x-wma', 'video/x-wmv', 'application/octet-stream'] found = 0 filetype = "" if found==0: for i in range(len(mp3Type)): if mime == mp3Type[i]: audio = MP3(src) found = 1 filetype = "mp3" break for i in range(len(flacType)): if mime == flacType[i]: audio = FLAC(src) found = 1 filetype = "flac" break for i in range(len(oggType)): if mime == oggType[i]: audio = OggVorbis(src) found = 1 filetype = "ogg" break for i in range(len(wmaType)): if mime == wmaType[i]: audio = ASF(src) found = 1 filetype = "wma" if found!=1: print "Data type is not found." return filedict = dict() if filetype == "mp3": audioprop = audio.pprint().split("\n") fileprop = audioprop[0].split(", ") #fileprop: u'MPEG 1 layer 3, 320000 bps, 44100 Hz, 246.73 seconds (audio/mp3)' filedict['Audio Codec'] = fileprop[0] filedict['Bitrate'] = fileprop[1] filedict['Sample Rate'] = fileprop[2] filedict['Length'] = fileprop[3].split(" (")[0] audioprop = audioprop[1:] for i in audioprop: values = i.split("=") filedict[values[0]] = values[1] if filedict.has_key("UFID"): filedict["Unique File Identifier"] = filedict["UFID"] del filedict["UFID"] if filedict.has_key("TIT1"): filedict["Content group description"] = filedict["TIT1"] del filedict["TIT1"] if filedict.has_key("TIT2"): filedict["Title"] = filedict["TIT2"] del filedict["TIT2"] if filedict.has_key("TIT3"): filedict["Subtitle/Description refinement"] = filedict["TIT3"] del filedict["TIT3"] if filedict.has_key("TPE1"): filedict["Artist"] = filedict["TPE1"] del filedict["TPE1"] if filedict.has_key("TPE2"): filedict["Band"] = filedict["TPE2"] del filedict["TPE2"] if filedict.has_key("TPE3"): filedict["Conductor"] = filedict["TPE3"] del filedict["TPE3"] if filedict.has_key("TPE4"): filedict["Remixer"] = filedict["TPE4"] del filedict["TPE4"] if filedict.has_key("TCOM"): filedict["Composer"] = filedict["TCOM"] del filedict["TCOM"] if filedict.has_key("TEXT"): filedict["Lyricist"] = filedict["TEXT"] del filedict["TEXT"] if filedict.has_key("TLAN"): filedict["Audio Language"] = filedict["TLAN"] del filedict["TLAN"] if filedict.has_key("TCON"): filedict["Genre"] = filedict["TCON"] del filedict["TCON"] if filedict.has_key("TALB"): filedict["Album"] = filedict["TALB"] del filedict["TALB"] if filedict.has_key("TPOS"): filedict["Part of set"] = filedict["TPOS"] del filedict["TPOS"] if filedict.has_key("TRCK"): filedict["Track Number"] = filedict["TRCK"] del filedict["TRCK"] if filedict.has_key("TSRC"): filedict["International Standard Recording Code (ISRC)"] = filedict["TSRC"] del filedict["TSRC"] if filedict.has_key("TYER"): filedict["Recording Year"] = filedict["TYER"] del filedict["TYER"] if filedict.has_key("TDAT"): filedict["Recording Date (DDMM)"] = filedict["TDAT"] del filedict["TDAT"] if filedict.has_key("TDRC"): filedict["Recording Time"] = filedict["TDRC"] del filedict["TDRC"] if filedict.has_key("TRDA"): filedict["Recording Dates"] = filedict["TRDA"] del filedict["TRDA"] if filedict.has_key("TMED"): filedict["Source Media Type"] = filedict["TMED"] del filedict["TMED"] if filedict.has_key("TFLT"): filedict["File Type"] = filedict["TFLT"] del filedict["TFLT"] if filedict.has_key("TBPM"): filedict["Beats per minute"] = filedict["TBPM"] del filedict["TBPM"] if filedict.has_key("TCOP"): filedict["Copyright"] = filedict["TCOP"] del filedict["TCOP"] if filedict.has_key("TPUB"): filedict["Publisher"] = filedict["TPUB"] del filedict["TPUB"] if filedict.has_key("TENC"): filedict["Encoder"] = filedict["TENC"] del filedict["TENC"] if filedict.has_key("TSSE"): filedict["Encoder settings"] = filedict["TSSE"] del filedict["TSSE"] if filedict.has_key("TOFN"): filedict["Original Filename"] = filedict["TOFN"] del filedict["TOFN"] if filedict.has_key("TLEN"): filedict["Audio Length(ms)"] = filedict["TLEN"] del filedict["TLEN"] if filedict.has_key("TSIZ"): filedict["Audio Data size (bytes)"] = filedict["TSIZ"] del filedict["TSIZ"] if filedict.has_key("TDLY"): filedict["Audio Delay (ms)"] = filedict["TDLY"] del filedict["TDLY"] if filedict.has_key("TKEY"): filedict["Starting Key"] = filedict["TKEY"] del filedict["TKEY"] if filedict.has_key("TOAL"): filedict["Original Album"] = filedict["TOAL"] del filedict["TOAL"] if filedict.has_key("TOPE"): filedict["Original Artist/Perfomer"] = filedict["TOPE"] del filedict["TOPE"] if filedict.has_key("TOLY"): filedict["Original Lyricist"] = filedict["TOLY"] del filedict["TOLY"] if filedict.has_key("TORY"): filedict["Original Release Year"] = filedict["TORY"] del filedict["TORY"] if filedict.has_key("TXXX"): filedict["User-defined Text"] = filedict["TXXX"] del filedict["TXXX"] if filedict.has_key("WOAF"): filedict["Official File Information"] = filedict["WOAF"] del filedict["WOAF"] if filedict.has_key("WOAR"): filedict["Official Artist/Performer Information"] = filedict["WOAR"] del filedict["WOAR"] if filedict.has_key("WOAS"): filedict["Official Source Information"] = filedict["WOAS"] del filedict["WOAS"] if filedict.has_key("WCOM"): filedict["Commercial Information"] = filedict["WCOM"] del filedict["WCOM"] if filedict.has_key("WCOP"): filedict["Copyright Information"] = filedict["WCOP"] del filedict["WCOP"] if filedict.has_key("WPUB"): filedict["Official Publisher Information"] = filedict["WPUB"] del filedict["WPUB"] if filedict.has_key("WXXX"): filedict["User-defined URL"] = filedict["WXXX"] del filedict["WXXX"] if filedict.has_key("IPLS"): filedict["Involved people list"] = filedict["IPLS"] del filedict["IPLS"] if filedict.has_key("MCDI"): filedict["Binary dump of CD's TOC"] = filedict["MCDI"] del filedict["MCDI"] if filedict.has_key("ETCO"): filedict["Event timing codes"] = filedict["ETCO"] del filedict["ETCO"] if filedict.has_key("MLLT"): filedict["MPEG location lookup table"] = filedict["MLLT"] del filedict["MLLT"] if filedict.has_key("SYTC"): filedict["Synced tempo codes"] = filedict["SYTC"] del filedict["SYTC"] if filedict.has_key("USLT"): filedict["Unsychronised lyrics/text transcription"] = filedict["USLT"] del filedict["USLT"] if filedict.has_key("SYLT"): filedict["Synchronised lyrics/text"] = filedict["SYLT"] del filedict["SYLT"] if filedict.has_key("COMM"): filedict["Comment"] = filedict["COMM"] del filedict["COMM"] if filedict.has_key("RVRB"): filedict["Reverb"] = filedict["RVRB"] del filedict["RVRB"] if filedict.has_key("APIC"): filedict["Attached Picture"] = filedict["APIC"] del filedict["APIC"] if filedict.has_key("GEOB"): filedict["General Encapsulated Object"] = filedict["GEOB"] del filedict["GEOB"] if filedict.has_key("PCNT"): filedict["Play counter"] = filedict["PCNT"] del filedict["PCNT"] if filedict.has_key("POPM"): filedict["Popularimeter"] = filedict["POPM"] del filedict["POPM"] if filedict.has_key("RBUF"): filedict["Recommended buffer size"] = filedict["RBUF"] del filedict["RBUF"] if filedict.has_key("Frame"): filedict["Encrypted meta frame"] = filedict["Frame"] del filedict["Frame"] if filedict.has_key("AENC"): filedict["Audio encryption"] = filedict["AENC"] del filedict["AENC"] if filedict.has_key("LINK"): filedict["Linked information"] = filedict["LINK"] del filedict["LINK"] for i in filedict: print i, ": ",filedict[i] if filetype == "flac": audioprop = audio.pprint().split("\n") fileprop = audioprop[0].split(", ") #fileprop: u'MPEG 1 layer 3, 320000 bps, 44100 Hz, 246.73 seconds (audio/mp3)' tempdict = dict() tempdict['Audio Codec'] = fileprop[0] tempdict['Length'] = fileprop[1] tempdict['Sample Rate'] = fileprop[2].split(" (")[0] audioprop = audioprop[1:] for i in audioprop: values = i.split("=") filedict[values[0]] = values[1] if filedict.has_key("title"): tempdict["Title"] = filedict["title"] if filedict.has_key("date"): tempdict["Year"] = filedict["date"] if filedict.has_key("composer"): tempdict["Composer"] = filedict["composer"] if filedict.has_key("style"): tempdict["Style"] = filedict["style"] if filedict.has_key("album"): tempdict["Album"] = filedict["album"] if filedict.has_key("genre"): tempdict["Genre"] = filedict["genre"] if filedict.has_key("artist"): tempdict["Artist"] = filedict["artist"] if filedict.has_key("rating"): tempdict["Rating"] = filedict["rating"] if filedict.has_key("tracknumber"): tempdict["Track Number"] = filedict["tracknumber"] if filedict.has_key("totaltracks"): tempdict["Total Tracks"] = filedict["totaltracks"] if filedict.has_key("discnumber"): tempdict["Disc Number"] = filedict["discnumber"] if filedict.has_key("totaldiscs"): tempdict["Total Discs"] = filedict["totaldiscs"] filedict.clear() for i in tempdict: print i, ": ", tempdict[i] if filetype == "ogg": audioprop = audio.pprint().split("\n") fileprop = audioprop[0].split(", ") #fileprop: u'MPEG 1 layer 3, 320000 bps, 44100 Hz, 246.73 seconds (audio/mp3)' tempdict = dict() tempdict['Audio Codec'] = fileprop[0] tempdict['Length'] = fileprop[1] tempdict['Bitrate'] = fileprop[2].split(" (")[0] audioprop = audioprop[1:] for i in audioprop: values = i.split("=") filedict[values[0]] = values[1] if filedict.has_key("title"): tempdict["Title"] = filedict["title"] if filedict.has_key("date"): tempdict["Year"] = filedict["date"] if filedict.has_key("composer"): tempdict["Composer"] = filedict["composer"] if filedict.has_key("style"): tempdict["Style"] = filedict["style"] if filedict.has_key("album"): tempdict["Album"] = filedict["album"] if filedict.has_key("genre"): tempdict["Genre"] = filedict["genre"] if filedict.has_key("artist"): tempdict["Artist"] = filedict["artist"] if filedict.has_key("rating"): tempdict["Rating"] = filedict["rating"] if filedict.has_key("tracknumber"): tempdict["Track Number"] = filedict["tracknumber"] if filedict.has_key("totaltracks"): tempdict["Total Tracks"] = filedict["totaltracks"] if filedict.has_key("discnumber"): tempdict["Disc Number"] = filedict["discnumber"] if filedict.has_key("totaldiscs"): tempdict["Total Discs"] = filedict["totaldiscs"] filedict.clear() for i in tempdict: print i, ": ", tempdict[i] """if filetype == "wma": tempdict = dict() filedict = audio tempdict["Audio Codec"] = "Wma" if filedict.has_key("Author"): tempdict["Artist"] = filedict["Author"] if filedict.has_key('Title'): tempdict['Title'] = filedict['Title'] if filedict.has_key("'WM/AlbumArtist'"): tempdict["Artist"] = filedict["'WM/AlbumArtist'"] if filedict.has_key("WM/AlbumTitle"): tempdict["Album"] = filedict["WM/AlbumTitle"] if filedict.has_key("WM/Composer"): tempdict["Composer"] = filedict["WM/Composer"] if filedict.has_key("WM/Genre"): tempdict["Genre"] = filedict["WM/Genre"] if filedict.has_key("'WM/Lyrics'"): tempdict["Lyrics"] = filedict["'WM/Lyrics'"] if filedict.has_key("WM/Provider"): tempdict["Provider"] = filedict["WM/Provider"] if filedict.has_key("WM/Publisher"): tempdict["Publisher"] = filedict["WM/Publisher"] if filedict.has_key("WM/TrackNumber"): tempdict["Track Number"] = filedict["WM/TrackNumber"] if filedict.has_key("WM/Track"): tempdict["Disc Number"] = filedict["WM/Track"] if filedict.has_key("WM/Year"): tempdict["Year"] = filedict["WM/Year"] filedict.clear() for i in tempdict: if tempdict[i] == print i , ":", tempdict[i] """ i = temp print "------------------------------"
flac_file = filename.replace('.wav', '.flac') assert os.path.exists(flac_file), \ "%s file was not converted to %s" % (filename, flac_file) os.chmod(flac_file, stat.S_IRUSR|stat.S_IWUSR|stat.S_IRGRP|stat.S_IROTH) audio = FLAC(flac_file) audio['title'] = "%s (%s)" % (metadata['track_name'], metadata['mix_name']) audio['artist'] = metadata['artist'] audio['album'] = metadata['release'] audio['date'] = metadata['release_date'][0] audio['genre'] = metadata['genre'] log(audio.pprint()) audio.save() except MissingMetadataError as exception : log("Could not find (or missing) track information: %s. Skipping" % exception.message) except AssertionError as exception : log(exception) except Exception as exception : log("Hey you found a bug! Bugs really suck, I'm sorry.\r\n"\ "We have to skip this file, but you can file an issue at\r\n"\ "https://github.com/cdolivei/beatport2flac/issues\r\n" "with the track name and this message : %s" % repr(exception)) finally: if artwork != None: os.remove(artwork)
# audiofile.tag.save() prefix = r".mp3" for file in os.listdir( r"C:\Users\Charles Zhang\Desktop\Music-Downloader-master"): # print(os.path.splitext(file)) fileext = os.path.splitext(file)[1] if (fileext == '.mp3'): audio = ID3(file) print(mutagen.File(file).tags) audio["title"] = mutagen.id3.TextFrame(encoding=3, text=[u"hahahaah"]) audio.add(TIT2(encoding=3, text=u"An example")) audio.save() # mp3audio = MP3(file) # mp3audio["title"] = mutagen.id3.TextFrame( # encoding=3, text=[u"hahahaah"]) # mp3audio.pprint() # mp3audio.save() print(file) elif (fileext == '.flac'): audio = FLAC(file) audio["title"] = u"An example" audio.pprint() audio.save() print(file)