def copy_tags(filejoin, filenames):
""" Copia los tags de filenames a join """
extension = os.path.splitext(filejoin)[1]
if extension == '.flac':
tags_ori = FLAC(filenames[0])
tags_joi = FLAC(filejoin)
elif extension == '.ogg':
tags_ori = OggVorbis(filenames[0])
tags_joi = OggVorbis(filejoin)
else:
return
for item in tags_ori.items():
tags_joi[item[0]] = item[1]
# falta añadir lo del título... pero primero lo borramos
for ori in filenames[1:]:
if extension == '.flac':
tags_ori = FLAC(ori)
elif extension == '.ogg':
tags_ori = OggVorbis(ori)
last_track = tags_ori['tracknumber']
last_discnumber = tags_ori['discnumber']
print tags_ori['title']
tags_joi['title'] = tags_joi['title'] + tags_ori['title']
tags_joi['gapless_join'] = str(len(filenames))
tags_joi['gapless_last_track'] = last_track
tags_joi['gapless_last_discnumber'] = last_discnumber
tags_joi.save()
def get_local_record_metadata(artist, album, record_dir):
songs = []
cd_count = 0
album_length = 0
track_count = 0
dictionary = dict()
dictionary.update({'artist': artist})
dictionary.update({'album': album})
for root, dirs, files in os.walk(record_dir):
if files:
for file in files:
songs.append(f'{root}/{file}')
cd_count += len(dirs)
for song in songs:
extension = pathlib.Path(song).suffix
if extension == '.flac':
track_count += 1
metadata = FLAC(song)
for item in metadata.items():
if item[0] == 'tracknumber':
track_number = int(item[1].pop())
min, sec = divmod(metadata.info.length, 60)
song_length = "%d:%02d" % (min, sec)
album_length += metadata.info.length
dictionary.update({'album_length': album_length})
dictionary.update({'track_count': track_count})
return dictionary
def main(args):
"""
"""
# This is nonsense, don't need to pass that argument twice
scanner = scan.Scanner()
if not scanner.scan_album(args.album):
sys.stderr.write('Invalid Album!\n')
sys.exit(1)
# Construct an album representation
# (This function will be moved to the lib)
m = const.REGEX_ALBUM_FOLDER.match(args.album).groupdict()
if not m:
# A bit reduntant, but better safe than sorry
sys.stderr.write("Could not read album folder\n")
sys.exit(1)
files = map(lambda fn: os.path.join(args.album, fn),
sorted(filter(const.REGEX_TRACK_FILENAME.match,
os.listdir(args.album)
)
)
)
show = ''
for fn in files:
audio = FLAC(fn)
# Maybe create a util function for this purpose
audio_dict = dict([(k,v[0]) for k,v in audio.items()])
show += TPL_TRACK_SHOW.format(**audio_dict)
head = TPL_ALBUM_SHOW.format(**audio_dict)
show = head + TPL_SEPARATOR(len(head)-1) + show
print show.strip('\n')
def main():
# get command line options
options = get_options()
bitrate = options.bitrate
source_dir = re.sub('\/+$', '', options.flac_dir)
# Process files in directory specified via -d option (not recursive).
flac_meta = {}
for file in glob.iglob("%s/*.flac" % source_dir):
raw_flac_meta = FLAC(file)
# meta data allows for multiple items per tag key; hence the
# join()
flac_meta = {}
for k, v in raw_flac_meta.items():
flac_meta[k] = ' '.join(v).encode(DEFAULT_ENCODING, 'replace')
create_ogg_vorbis(flac_meta, file, bitrate)
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)
print " Converting file " + sFileBase + sFileExt + " to " + dDir
command = "sox \"" +sFile + "\" \"" + dFile + "\""
print " " + command
os.popen(command)
#Read flac tags from FLAC file
flacTags = FLAC(sFile)
try:
mp3 = MP3(dFile)
except:
print( dFile + "does not exist, or cannot be opened as mp3")
break
iso = 'iso-8859-1'
for key, value in flacTags.items():
if key == 'album': mp3['TALB']=mutagen.id3.TALB(encoding=3,text=[value[0]])
elif key == 'artist': mp3['TPE1']=mutagen.id3.TPE1(encoding=3,text=[value[0]])
elif key == 'title': mp3['TIT2']=mutagen.id3.TIT2(encoding=3,text=[value[0]])
elif key == 'albumartist': mp3['TPE2']=mutagen.id3.TPE2(encoding=3,text=[value[0]])
elif key == 'album artist': mp3['TPE2']=mutagen.id3.TPE2(encoding=3,text=[value[0]])
elif key == 'date': mp3['TYER']=mutagen.id3.TYER(encoding=3,text=[value[0]])
elif key == 'tracknumber': mp3['TRCK']=mutagen.id3.TRCK(encoding=3,text=[value[0]])
mp3.save()
# Get the picture tag from the flac file and store it
# in the flac dir and the mp3 dir and the mp3 file.
pictures = flacTags.pictures
noOfPictures = 0
for pic in pictures:
noOfPictures = noOfPictures + 1
value = first_track[org_key]
album_meta_dict[new_key] = value
# Let's generate some album-level YAML metadata files!
album_yaml = yaml.dump(album_meta_dict)
dst_album_meta_file_path = dst_album_dir_path / "directory.yml"
with dst_album_meta_file_path.open(mode='w') as f:
f.write(album_yaml)
# For each FLAC file, read its tags
track_meta_dicts = []
for src_track_path in src_track_paths:
track_file_name = src_track_path.name
track = FLAC(str(src_track_path))
track_meta_dict = {}
for tag, value in track.items():
# Skip album level tags
if tag in album_tags:
continue
# Skip ignored tags
if tag in ignored:
continue
if tag in track_tag_renames:
tag = track_tag_renames[tag]
track_meta_dict[tag] = value
track_meta_dicts.append(track_meta_dict)
dst_track_file_path = dst_album_dir_path / track_file_name
dst_track_file_path.touch(exist_ok=True)
tracks_yaml = yaml.dump(track_meta_dicts)
def set_release_metadata(artist_name, album_name, record_id):
translation = {'/': '-'}
table = str.maketrans(translation)
record = get_local_record_list(artist_name, album_name.translate(table))
record_dir = record['record_dir']
try:
release = musicbrainzngs.get_release_by_id(record_id,
includes=[
'recordings',
])
release = release['release']
except:
release = musicbrainzngs.get_release_by_id(record_id)
try:
album = release['title']
except KeyError:
album = 'not defined'
try:
date = release['date']
except KeyError:
date = 'not defined'
try:
country = release['country']
except KeyError:
country = 'not defined'
try:
mediumtotal = release['medium-count']
except KeyError:
mediumtotal = 0
tracknumber = 1
for i in range(1, mediumtotal + 1):
if mediumtotal > 1:
base_dir = record_dir + f'/CD{i}/'
base_dir_art = record_dir + '/'
else:
base_dir = record_dir + '/'
base_dir_art = record_dir + '/'
try:
pic = Picture()
with open(f'{base_dir_art}fanart.jpg', "rb") as f:
pic.data = f.read()
pic.mime = u"image/jpeg"
pic.width = 1000
pic.height = 1000
pic.depth = 16
except:
logger.warning('No Fan Art Available!')
songs = os.listdir(base_dir)
for song in songs:
fullpath = base_dir + song
extension = pathlib.Path(fullpath).suffix
if extension == '.flac':
metadata = FLAC(fullpath)
for item in metadata.items():
if item[0] == 'tracknumber':
tracknumber = int(item[1].pop())
records = filter(lambda x: int(x['position']) == i,
release['medium-list'])
for recording in records:
tracktotal = recording['track-count']
for track in recording['track-list']:
if int(track['number']) == tracknumber:
tracktitle = track['recording']['title'].translate(
table)
trackid = track['recording']['id']
track_musicbrainz = musicbrainzngs.get_recording_by_id(
trackid, includes=[
'artists',
])
artist = track_musicbrainz['recording'][
'artist-credit-phrase']
metadata.delete()
metadata.clear_pictures()
if pic:
metadata.add_picture(pic)
metadata["Album"] = album
metadata["Albumartist"] = artist_name
metadata["Artist"] = artist_name
metadata["Country"] = country
metadata["Date"] = date
metadata["Discnumber"] = str(i)
metadata["Title"] = tracktitle
metadata["Tracktotal"] = str(tracktotal)
metadata["Tracknumber"] = str(tracknumber)
metadata.save()
logger.info(f'old name: {song}')
if mediumtotal != 1:
logger.info(
f'new name: {artist} - {album.translate(table)} - CD{i} - {tracknumber:02} - {tracktitle}.flac'
)
os.rename(
fullpath,
f'{base_dir}{artist} - {album.translate(table)} - CD{i} - {tracknumber:02} - {tracktitle}.flac'
)
else:
logger.info(
f'new name: {artist} - {album.translate(table)} - {tracknumber:02} - {tracktitle}.flac'
)
os.rename(
fullpath,
f'{base_dir}{artist} - {album.translate(table)} - {tracknumber:02} - {tracktitle}.flac'
)
