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