def gen_tag(self, track, fake_art=False):
tag = Tag()
if track.has_key('album'):
tag.album = track['album']
if track.has_key('artist'):
tag.artist = track['artist']
if track.has_key('title'):
tag.title = track['title']
if track.has_key('discNumber'):
tag.disc_num = int(track['discNumber'])
if track.has_key('trackNumber'):
tag.track_num = int(track['trackNumber'])
if track.has_key('genre'):
tag.genre = track['genre']
if track.has_key(
'albumArtist') and track['albumArtist'] != track['artist']:
tag.album_artist = track['albumArtist']
if track.has_key('year') and int(track['year']) != 0:
tag.recording_date = track['year']
if track.has_key('albumArtRef'):
art = None
if self.__art is None:
if fake_art:
art = '\0' * self.__art_size
else:
if self.load_art():
art = self.__art
else:
art = None
else:
art = self.__art
if art is not None:
tag.images.set(0x03, art, 'image/jpeg', u'Front cover')
return tag
def parser_mp3(self):
"""
处理mp3的head部分
:return:
"""
tag = Tag()
tag.remove(self.file_path)
def testChapters():
test_file = "/tmp/chapters.id3"
t = Tag()
ch1 = t.chapters.set(b"c1", (0, 200))
ch2 = t.chapters.set(b"c2", (200, 300))
ch3 = t.chapters.set(b"c3", (300, 375))
ch4 = t.chapters.set(b"c4", (375, 600))
assert len(t.chapters) == 4
for i, c in enumerate(iter(t.chapters), 1):
if i != 2:
c.title = "Chapter %d" % i
c.subtitle = "Subtitle %d" % i
c.user_url = "http://example.com/%d" % i
t.save(test_file)
try:
t2 = eyed3.load(test_file).tag
finally:
os.remove(test_file)
assert len(t2.chapters) == 4
for i in range(1, 5):
c = t2.chapters.get(str("c%d" % i).encode("latin1"))
if i == 2:
assert c.title is None
assert c.subtitle is None
assert c.user_url is None
else:
assert c.title == "Chapter %d" % i
assert c.subtitle == "Subtitle %d" % i
assert c.user_url == "http://example.com/%d" % i
def testChapters():
test_file = "/tmp/chapters.id3"
t = Tag()
ch1 = t.chapters.set("c1", (0, 200))
ch2 = t.chapters.set("c2", (200, 300))
ch3 = t.chapters.set("c3", (300, 375))
ch4 = t.chapters.set("c4", (375, 600))
assert_equal(len(t.chapters), 4)
for i, c in enumerate(iter(t.chapters), 1):
if i != 2:
c.title = u"Chapter %d" % i
c.subtitle = u"Subtitle %d" % i
c.user_url = "http://example.com/%d" % i
t.save(test_file)
try:
t2 = eyed3.load(test_file).tag
finally:
os.remove(test_file)
assert_equal(len(t2.chapters), 4)
for i in range(1, 5):
c = t2.chapters.get("c%d" % i)
if i == 2:
assert_is_none(c.title)
assert_is_none(c.subtitle)
assert_is_none(c.user_url)
else:
assert_equal(c.title, u"Chapter %d" % i)
assert_equal(c.subtitle, u"Subtitle %d" % i)
assert_equal(c.user_url, u"http://example.com/%d" % i)
def testChapters():
test_file = "/tmp/chapters.id3"
t = Tag()
ch1 = t.chapters.set(b"c1", (0, 200))
ch2 = t.chapters.set(b"c2", (200, 300))
ch3 = t.chapters.set(b"c3", (300, 375))
ch4 = t.chapters.set(b"c4", (375, 600))
assert len(t.chapters) == 4
for i, c in enumerate(iter(t.chapters), 1):
if i != 2:
c.title = "Chapter %d" % i
c.subtitle = "Subtitle %d" % i
c.user_url = "http://example.com/%d" % i
t.save(test_file)
try:
t2 = eyed3.load(test_file).tag
finally:
os.remove(test_file)
assert len(t2.chapters) == 4
for i in range(1, 5):
c = t2.chapters.get(str("c%d" % i).encode("latin1"))
if i == 2:
assert c.title is None
assert c.subtitle is None
assert c.user_url is None
else:
assert c.title == "Chapter %d" % i
assert c.subtitle == "Subtitle %d" % i
assert c.user_url == "http://example.com/%d" % i
def test_XDOR_TDOR_Conversions():
test_file = "/tmp/xdortdrc.id3"
tag = Tag()
# 2.3 frames to 2.4
frame = frames.DateFrame(b"XDOR", "1990-06-24")
tag.frame_set[b"XDOR"] = frame
try:
tag.save(test_file) # v2.4 is the default
tag = eyed3.load(test_file).tag
assert tag.version == ID3_V2_4
assert len(tag.frame_set) == 1
del tag.frame_set[b"TDOR"]
assert len(tag.frame_set) == 0
finally:
os.remove(test_file)
tag = Tag()
# 2.4 frames to 2.3
frame = frames.DateFrame(b"TDRC", "2012-10-21")
tag.frame_set[frame.id] = frame
try:
tag.save(test_file, version=eyed3.id3.ID3_V2_3)
tag = eyed3.load(test_file).tag
assert tag.version == ID3_V2_3
assert len(tag.frame_set) == 2
del tag.frame_set[b"TYER"]
del tag.frame_set[b"TDAT"]
assert len(tag.frame_set) == 0
finally:
os.remove(test_file)
def test_XDOR_TDOR_Conversions():
test_file = "/tmp/xdortdrc.id3"
tag = Tag()
# 2.3 frames to 2.4
frame = frames.DateFrame(b"XDOR", "1990-06-24")
tag.frame_set[b"XDOR"] = frame
try:
tag.save(test_file) # v2.4 is the default
tag = eyed3.load(test_file).tag
assert tag.version == ID3_V2_4
assert len(tag.frame_set) == 1
del tag.frame_set[b"TDOR"]
assert len(tag.frame_set) == 0
finally:
os.remove(test_file)
tag = Tag()
# 2.4 frames to 2.3
frame = frames.DateFrame(b"TDRC", "2012-10-21")
tag.frame_set[frame.id] = frame
try:
tag.save(test_file, version=eyed3.id3.ID3_V2_3)
tag = eyed3.load(test_file).tag
assert tag.version == ID3_V2_3
assert len(tag.frame_set) == 2
del tag.frame_set[b"TYER"]
del tag.frame_set[b"TDAT"]
assert len(tag.frame_set) == 0
finally:
os.remove(test_file)
def __gen_tag(self):
log.info("Creating tag idv3...")
self.__tag = Tag()
self.__tag.album = self.__data['album']
self.__tag.artist = self.__data['artist']
if self.__data.has_key('album'):
self.__tag.album = self.__data['album']
if self.__data.has_key('artist'):
self.__tag.artist = self.__data['artist']
if self.__data.has_key('title'):
self.__tag.title = self.__data['title']
if self.__data.has_key('discNumber'):
self.__tag.disc_num = int(self.__data['discNumber'])
if self.__data.has_key('trackNumber'):
self.__tag.track_num = int(self.__data['trackNumber'])
if self.__data.has_key('genre'):
self.__tag.genre = self.__data['genre']
if self.__data.has_key('albumArtist') and self.__data[
'albumArtist'] != self.__data['artist']:
self.__tag.album_artist = self.__data['albumArtist']
if self.__data.has_key('year') and int(self.__data['year']) != 0:
self.__tag.recording_date = self.__data['year']
if self.album and self.album.art:
self.__tag.images.set(0x03, self.album.art, 'image/jpeg',
u'Front cover')
tmpfd, tmpfile = tempfile.mkstemp()
os.close(tmpfd)
self.__tag.save(tmpfile, ID3_V2_4)
tmpfd = open(tmpfile, "r")
self.__rendered_tag = tmpfd.read()
tmpfd.close()
os.unlink(tmpfile)
def testTagPrivates():
tag = Tag()
# No private frames
assert len(tag.privates) == 0
for i in tag.privates:
assert not("Expected no privates")
try:
img = tag.privates[0]
except IndexError:
pass #expected
else:
assert not("Expected IndexError for no privates")
assert (tag.privates.get(b"") is None)
tag = Tag()
tag.privates.set(b"\xab\xcd", b"owner1")
assert (len(tag.privates) == 1)
assert (tag.privates[0].owner_id == b"owner1")
assert (tag.privates[0].owner_data == b"\xab\xcd")
assert (tag.privates.get(b"owner1").owner_id == b"owner1")
assert (tag.privates.get(b"owner1").owner_data == b"\xab\xcd")
tag.privates.set(b"\xba\xdc", b"owner2")
assert (len(tag.privates) == 2)
assert (tag.privates[1].owner_id == b"owner2")
assert (tag.privates[1].owner_data == b"\xba\xdc")
assert (tag.privates.get(b"owner2").owner_id == b"owner2")
assert (tag.privates.get(b"owner2").owner_data == b"\xba\xdc")
# This is an update (same description)
tag.privates.set(b"\x00\x00\x00", b"owner1")
assert (len(tag.privates) == 2)
assert (tag.privates[0].owner_id == b"owner1")
assert (tag.privates[0].owner_data == b"\x00\x00\x00")
assert (tag.privates.get(b"owner1").owner_id == b"owner1")
assert (tag.privates.get(b"owner1").owner_data == b"\x00\x00\x00")
count = 0
for f in tag.privates:
count += 1
assert (count == 2)
# Remove
priv = tag.privates.remove(b"owner1")
assert (priv.owner_id == b"owner1")
assert (priv.owner_data == b"\x00\x00\x00")
assert (len(tag.privates) == 1)
priv = tag.privates.remove(b"owner2")
assert (priv.owner_id == b"owner2")
assert (priv.owner_data == b"\xba\xdc")
assert (len(tag.privates) == 0)
assert tag.objects.remove("Callahan") is None
def testNumStringConvert():
t = Tag()
t.track_num = "1"
assert t.track_num == (1, None)
t.disc_num = ("2", "6")
assert t.disc_num == (2, 6)
def testTagPrivates():
tag = Tag()
# No private frames
assert_equal(len(tag.privates), 0)
for i in tag.privates:
assert_false("Expected no privates")
try:
img = tag.privates[0]
except IndexError:
pass #expected
else:
assert_false("Expected IndexError for no privates")
assert_is_none(tag.privates.get(u""))
tag = Tag()
tag.privates.set(b"\xab\xcd", "owner1")
assert_equal(len(tag.privates), 1)
assert_equal(tag.privates[0].owner_id, "owner1")
assert_equal(tag.privates[0].owner_data, b"\xab\xcd")
assert_equal(tag.privates.get("owner1").owner_id, "owner1")
assert_equal(tag.privates.get("owner1").owner_data, b"\xab\xcd")
tag.privates.set(b"\xba\xdc", "owner2")
assert_equal(len(tag.privates), 2)
assert_equal(tag.privates[1].owner_id, "owner2")
assert_equal(tag.privates[1].owner_data, b"\xba\xdc")
assert_equal(tag.privates.get("owner2").owner_id, "owner2")
assert_equal(tag.privates.get("owner2").owner_data, b"\xba\xdc")
# This is an update (same description)
tag.privates.set(b"\x00\x00\x00", "owner1")
assert_equal(len(tag.privates), 2)
assert_equal(tag.privates[0].owner_id, "owner1")
assert_equal(tag.privates[0].owner_data, b"\x00\x00\x00")
assert_equal(tag.privates.get("owner1").owner_id, "owner1")
assert_equal(tag.privates.get("owner1").owner_data, b"\x00\x00\x00")
count = 0
for f in tag.privates:
count += 1
assert_equal(count, 2)
# Remove
priv = tag.privates.remove("owner1")
assert_equal(priv.owner_id, "owner1")
assert_equal(priv.owner_data, b"\x00\x00\x00")
assert_equal(len(tag.privates), 1)
priv = tag.privates.remove("owner2")
assert_equal(priv.owner_id, "owner2")
assert_equal(priv.owner_data, b"\xba\xdc")
assert_equal(len(tag.privates), 0)
assert_is_none(tag.objects.remove(u"Callahan"))
def __init__(self):
self.regex = r""
self.t = Tag()
self.parser = argparse.ArgumentParser(description='A Python Script to clean/format mp3 file metadata',
prog='mp3clean', usage='python %(prog)s.py [options]',
formatter_class=argparse.ArgumentDefaultsHelpFormatter,
epilog="And that's how its done")
self.args = None
self.t_map = {'Title': 'title', 'Album': 'album', 'Artist': 'artist', 'AlbumArtist': 'album_artist',
'Genre': 'genre.name'}
def testReadOnly():
assert_false(Tag.read_only)
t = Tag()
assert_false(t.read_only)
t.read_only = True
assert_raises(RuntimeError, t.save)
assert_raises(RuntimeError, t._saveV1Tag, None)
assert_raises(RuntimeError, t._saveV2Tag, None, None, None)
def gen_tag(self, track, fake_art=False):
tag = Tag()
if track.has_key('album'):
tag.album = track['album']
if track.has_key('artist'):
tag.artist = track['artist']
if track.has_key('title'):
tag.title = track['title']
if track.has_key('discNumber'):
tag.disc_num = int(track['discNumber'])
if track.has_key('trackNumber'):
tag.track_num = int(track['trackNumber'])
if track.has_key('genre'):
tag.genre = track['genre']
if track.has_key('albumArtist') and track['albumArtist'] != track['artist']:
tag.album_artist = track['albumArtist']
if track.has_key('year') and int(track['year']) != 0:
tag.recording_date = track['year']
if track.has_key('albumArtRef'):
art = None
if self.__art is None:
if fake_art:
art = '\0' * self.__art_size
else:
if self.load_art():
art = self.__art
else:
art = None
else:
art = self.__art
if art is not None:
tag.images.set(0x03, art, 'image/jpeg', u'Front cover')
return tag
def main():
"Entry point"
args = docopt(__doc__, version="mp3chaps 0.1")
tag = Tag()
tag.parse(args["<filename>"])
if args["-l"]:
list_chaps(tag)
elif args["-i"]:
add_chapters(tag, args["<filename>"])
elif args["-r"]:
remove_chaps(tag)
def test_issue382_genres(audiofile):
"""Tags always written in v2.3 format, always including ID.
https://github.com/nicfit/eyeD3/issues/382
"""
tag = Tag()
tag.genre = "Dubstep"
assert tag.genre.id == 189
assert tag.genre.name == "Dubstep"
audiofile.tag = tag
tag.save()
new_audiofile = eyed3.load(audiofile.path)
# Prior versions would be `(189)Dubstep`, now no index.
assert new_audiofile.tag.frame_set[b"TCON"][0].text == "Dubstep"
def testTableOfContents():
test_file = "/tmp/toc.id3"
t = Tag()
assert_equal(len(t.table_of_contents), 0)
toc_main = t.table_of_contents.set("main",
toplevel=True,
child_ids=["c1", "c2", "c3", "c4"],
description=u"Table of Conents")
assert_is_not_none(toc_main)
assert_equal(len(t.table_of_contents), 1)
toc_dc = t.table_of_contents.set("director-cut",
toplevel=False,
ordered=False,
child_ids=["d3", "d1", "d2"])
assert_is_not_none(toc_dc)
assert_equal(len(t.table_of_contents), 2)
toc_dummy = t.table_of_contents.set("test")
assert_equal(len(t.table_of_contents), 3)
t.table_of_contents.remove(toc_dummy.element_id)
assert_equal(len(t.table_of_contents), 2)
t.save(test_file)
try:
t2 = eyed3.load(test_file).tag
finally:
os.remove(test_file)
assert_equal(len(t.table_of_contents), 2)
assert_equal(t2.table_of_contents.get("main").toplevel, True)
assert_equal(t2.table_of_contents.get("main").ordered, True)
assert_equal(
t2.table_of_contents.get("main").description, toc_main.description)
assert_equal(
t2.table_of_contents.get("main").child_ids, toc_main.child_ids)
assert_equal(
t2.table_of_contents.get("director-cut").toplevel, toc_dc.toplevel)
assert_equal(t2.table_of_contents.get("director-cut").ordered, False)
assert_equal(
t2.table_of_contents.get("director-cut").description,
toc_dc.description)
assert_equal(
t2.table_of_contents.get("director-cut").child_ids, toc_dc.child_ids)
def testTagUserUrls():
tag = Tag()
assert (len(tag.user_url_frames) == 0)
uuf1 = tag.user_url_frames.set(b"http://yo.yo.com/")
assert (tag.user_url_frames.get(u"").url == b"http://yo.yo.com/")
utf2 = tag.user_url_frames.set(b"http://run.dmc.org", u"URL")
assert (tag.user_url_frames.get(u"URL").url == b"http://run.dmc.org")
assert len(tag.user_url_frames) == 2
utf3 = tag.user_url_frames.set(b"http://my.adidas.com", u"")
assert (tag.user_url_frames.get(u"").url == b"http://my.adidas.com")
assert (len(tag.user_url_frames) == 2)
assert (id(uuf1) == id(utf3))
assert (tag.user_url_frames[0] == uuf1)
assert (tag.user_url_frames[1] == utf2)
assert (tag.user_url_frames.get(u"") == uuf1)
assert (tag.user_url_frames.get(u"URL") == utf2)
tag.user_url_frames.remove(u"")
assert (len(tag.user_url_frames) == 1)
tag.user_url_frames.remove(u"URL")
assert (len(tag.user_url_frames) == 0)
tag.user_url_frames.set(b"Foobazz", u"Desc2")
assert (len(tag.user_url_frames) == 1)
def testTagCdId():
tag = Tag()
assert_equal(tag.cd_id, None)
tag.cd_id = b"\x01\x02"
assert_equal(tag.cd_id, b"\x01\x02")
tag.cd_id = b"\xff" * 804
assert_equal(tag.cd_id, b"\xff" * 804)
try:
tag.cd_id = b"\x00" * 805
except ValueError:
pass # expected
else:
assert_false("CD id is too long, expected ValueError")
def testTagCdId():
tag = Tag()
assert tag.cd_id is None
tag.cd_id = b"\x01\x02"
assert tag.cd_id == b"\x01\x02"
tag.cd_id = b"\xff" * 804
assert tag.cd_id == b"\xff" * 804
try:
tag.cd_id = b"\x00" * 805
except ValueError:
pass # expected
else:
assert not("CD id is too long, expected ValueError")
def testTagUserUrls():
tag = Tag()
assert_equal(len(tag.user_url_frames), 0)
uuf1 = tag.user_url_frames.set("http://yo.yo.com/")
assert_equal(tag.user_url_frames.get(u"").url, "http://yo.yo.com/")
utf2 = tag.user_url_frames.set("http://run.dmc.org", u"URL")
assert_equal(tag.user_url_frames.get(u"URL").url, u"http://run.dmc.org")
assert_equal(len(tag.user_url_frames), 2)
utf3 = tag.user_url_frames.set("http://my.adidas.com", u"")
assert_equal(tag.user_url_frames.get(u"").url, "http://my.adidas.com")
assert_equal(len(tag.user_url_frames), 2)
assert_equal(id(uuf1), id(utf3))
assert_equal(tag.user_url_frames[0], uuf1)
assert_equal(tag.user_url_frames[1], utf2)
assert_equal(tag.user_url_frames.get(u""), uuf1)
assert_equal(tag.user_url_frames.get(u"URL"), utf2)
tag.user_url_frames.remove(u"")
assert_equal(len(tag.user_url_frames), 1)
tag.user_url_frames.remove(u"URL")
assert_equal(len(tag.user_url_frames), 0)
tag.user_url_frames.set("Foobazz", u"Desc2")
assert_equal(len(tag.user_url_frames), 1)
def testTagConstructor():
t = Tag()
assert_is_none(t.file_info)
assert_is_not_none(t.header)
assert_is_not_none(t.extended_header)
assert_is_not_none(t.frame_set)
assert_equal(len(t.frame_set), 0)
def testTagCdId():
tag = Tag()
assert tag.cd_id is None
tag.cd_id = b"\x01\x02"
assert tag.cd_id == b"\x01\x02"
tag.cd_id = b"\xff" * 804
assert tag.cd_id == b"\xff" * 804
try:
tag.cd_id = b"\x00" * 805
except ValueError:
pass # expected
else:
assert not ("CD id is too long, expected ValueError")
def testTagConstructor():
t = Tag()
assert t.file_info is None
assert t.header is not None
assert t.extended_header is not None
assert t.frame_set is not None
assert len(t.frame_set) == 0
def testTagUserTextFrames():
tag = Tag()
assert_equal(len(tag.user_text_frames), 0)
utf1 = tag.user_text_frames.set(u"Custom content")
assert_equal(tag.user_text_frames.get(u"").text, u"Custom content")
utf2 = tag.user_text_frames.set(u"Content custom", u"Desc1")
assert_equal(tag.user_text_frames.get(u"Desc1").text, u"Content custom")
assert_equal(len(tag.user_text_frames), 2)
utf3 = tag.user_text_frames.set(u"New content", u"")
assert_equal(tag.user_text_frames.get(u"").text, u"New content")
assert_equal(len(tag.user_text_frames), 2)
assert_equal(id(utf1), id(utf3))
assert_equal(tag.user_text_frames[0], utf1)
assert_equal(tag.user_text_frames[1], utf2)
assert_equal(tag.user_text_frames.get(u""), utf1)
assert_equal(tag.user_text_frames.get(u"Desc1"), utf2)
tag.user_text_frames.remove(u"")
assert_equal(len(tag.user_text_frames), 1)
tag.user_text_frames.remove(u"Desc1")
assert_equal(len(tag.user_text_frames), 0)
tag.user_text_frames.set(u"Foobazz", u"Desc2")
assert_equal(len(tag.user_text_frames), 1)
def testTagUserTextFrames():
tag = Tag()
assert (len(tag.user_text_frames) == 0)
utf1 = tag.user_text_frames.set(u"Custom content")
assert (tag.user_text_frames.get(u"").text == u"Custom content")
utf2 = tag.user_text_frames.set(u"Content custom", u"Desc1")
assert (tag.user_text_frames.get(u"Desc1").text == u"Content custom")
assert (len(tag.user_text_frames) == 2)
utf3 = tag.user_text_frames.set(u"New content", u"")
assert (tag.user_text_frames.get(u"").text == u"New content")
assert (len(tag.user_text_frames) == 2)
assert (id(utf1) == id(utf3))
assert (tag.user_text_frames[0] == utf1)
assert (tag.user_text_frames[1] == utf2)
assert (tag.user_text_frames.get(u"") == utf1)
assert (tag.user_text_frames.get(u"Desc1") == utf2)
tag.user_text_frames.remove(u"")
assert (len(tag.user_text_frames) == 1)
tag.user_text_frames.remove(u"Desc1")
assert (len(tag.user_text_frames) == 0)
tag.user_text_frames.set(u"Foobazz", u"Desc2")
assert (len(tag.user_text_frames) == 1)
def testReadOnly():
assert not (Tag.read_only)
t = Tag()
assert not (t.read_only)
t.read_only = True
with pytest.raises(RuntimeError):
t.save()
with pytest.raises(RuntimeError):
t._saveV1Tag(None)
with pytest.raises(RuntimeError):
t._saveV2Tag(None, None, None)
def testTableOfContents():
test_file = "/tmp/toc.id3"
t = Tag()
assert (len(t.table_of_contents) == 0)
toc_main = t.table_of_contents.set(b"main",
toplevel=True,
child_ids=[b"c1", b"c2", b"c3", b"c4"],
description=u"Table of Conents")
assert toc_main is not None
assert (len(t.table_of_contents) == 1)
toc_dc = t.table_of_contents.set(b"director-cut",
toplevel=False,
ordered=False,
child_ids=[b"d3", b"d1", b"d2"])
assert toc_dc is not None
assert (len(t.table_of_contents) == 2)
toc_dummy = t.table_of_contents.set(b"test")
assert (len(t.table_of_contents) == 3)
t.table_of_contents.remove(toc_dummy.element_id)
assert (len(t.table_of_contents) == 2)
t.save(test_file)
try:
t2 = eyed3.load(test_file).tag
finally:
os.remove(test_file)
assert len(t.table_of_contents) == 2
assert t2.table_of_contents.get(b"main").toplevel
assert t2.table_of_contents.get(b"main").ordered
assert t2.table_of_contents.get(
b"main").description == toc_main.description
assert t2.table_of_contents.get(b"main").child_ids == toc_main.child_ids
assert (
t2.table_of_contents.get(b"director-cut").toplevel == toc_dc.toplevel)
assert not t2.table_of_contents.get(b"director-cut").ordered
assert (t2.table_of_contents.get(b"director-cut").description ==
toc_dc.description)
assert (t2.table_of_contents.get(b"director-cut").child_ids ==
toc_dc.child_ids)
def testReleaseDate_v23_v24():
"""v23 does not have release date, only original release date."""
date = Date.parse("1980-07-03")
date2 = Date.parse("1926-07-05")
year = Date(1966)
tag = Tag()
assert tag.version == ID3_DEFAULT_VERSION
tag.version = ID3_V2_3
assert tag.version == ID3_V2_3
# Setting release date sets original release date
# v2.3 TORY get the year, XDOR get the full date; getter prefers XDOR
tag.release_date = "2020-03-08"
assert b"TORY" in tag.frame_set
assert b"XDOR" in tag.frame_set
assert tag.release_date == Date.parse("2020-03-08")
assert tag.original_release_date == Date(year=2020, month=3, day=8)
# Setting original release date sets release date
tag.original_release_date = year
assert tag.original_release_date == Date(1966)
assert tag.release_date == Date.parse("1966")
assert b"TORY" in tag.frame_set
# Year only value should clean up XDOR
assert b"XDOR" not in tag.frame_set
# Version convert to 2.4 converts original release date only
tag.release_date = date
assert b"TORY" in tag.frame_set
assert b"XDOR" in tag.frame_set
assert tag.original_release_date == date
assert tag.release_date == date
tag.version = ID3_V2_4
assert tag.original_release_date == date
assert tag.release_date is None
# v2.4 has both date types
tag.release_date = date2
assert tag.original_release_date == date
assert tag.release_date == date2
assert b"TORY" not in tag.frame_set
assert b"XDOR" not in tag.frame_set
# Convert back to 2.3 loses release date, only the year is copied to TORY
tag.version = ID3_V2_3
assert b"TORY" in tag.frame_set
assert b"XDOR" in tag.frame_set
assert tag.original_release_date == date
assert tag.release_date == Date.parse(str(date))
def testTagBPM():
tag = Tag()
assert (tag.bpm is None)
tag.bpm = 150
assert (tag.bpm == 150)
assert (tag.frame_set[b"TBPM"])
tag.bpm = 180
assert (tag.bpm == 180)
assert (tag.frame_set[b"TBPM"])
assert (len(tag.frame_set[b"TBPM"]) == 1)
tag.bpm = 190.5
assert type(tag.bpm) is int
assert tag.bpm == 191
assert len(tag.frame_set[b"TBPM"]) == 1
def testTagBPM():
tag = Tag()
assert_is_none(tag.bpm)
tag.bpm = 150
assert_equal(tag.bpm, 150)
assert_true(tag.frame_set[b"TBPM"])
tag.bpm = 180
assert_equal(tag.bpm, 180)
assert_true(tag.frame_set[b"TBPM"])
assert_equal(len(tag.frame_set[b"TBPM"]), 1)
tag.bpm = 190.5
assert_true(type(tag.bpm) is int)
assert_equal(tag.bpm, 191)
assert_equal(len(tag.frame_set[b"TBPM"]), 1)
def testTagBPM():
tag = Tag()
assert (tag.bpm is None)
tag.bpm = 150
assert (tag.bpm == 150)
assert (tag.frame_set[b"TBPM"])
tag.bpm = 180
assert (tag.bpm == 180)
assert (tag.frame_set[b"TBPM"])
assert (len(tag.frame_set[b"TBPM"]) == 1)
tag.bpm = 190.5
assert type(tag.bpm) is int
assert tag.bpm == 191
assert len(tag.frame_set[b"TBPM"]) == 1
def testTagGenre():
from eyed3.id3 import Genre
tag = Tag()
assert_is_none(tag.genre)
try:
tag.genre = "Not Unicode"
except TypeError:
pass # expected
else:
assert_false("Non unicode genre, expected TypeError")
gobj = Genre(u"Hardcore")
tag.genre = u"Hardcore"
assert_equal(tag.genre.name, u"Hardcore")
assert_equal(tag.genre, gobj)
tag.genre = 130
assert_equal(tag.genre.id, 130)
assert_equal(tag.genre.name, u"Terror")
tag.genre = 0
assert_equal(tag.genre.id, 0)
assert_equal(tag.genre.name, u"Blues")
tag.genre = None
assert_is_none(tag.genre)
assert_is_none(tag.frame_set["TCON"])
def testTagGenre():
from eyed3.id3 import Genre
tag = Tag()
assert (tag.genre is None)
try:
tag.genre = b"Not Unicode"
except TypeError:
pass # expected
else:
assert not ("Non unicode genre, expected TypeError")
gobj = Genre(u"Hardcore")
tag.genre = u"Hardcore"
assert (tag.genre.name == u"Hardcore")
assert (tag.genre == gobj)
tag.genre = 130
assert tag.genre.id == 130
assert tag.genre.name == u"Terror"
tag.genre = 0
assert tag.genre.id == 0
assert tag.genre.name == u"Blues"
tag.genre = None
assert tag.genre is None
assert tag.frame_set[b"TCON"] is None
def testTagPublisher():
t = Tag()
assert (t.publisher is None)
try:
t.publisher = b"not unicode"
except TypeError:
pass #expected
else:
assert not("Expected TypeError when setting non-unicode publisher")
t.publisher = "Dischord"
assert t.publisher == "Dischord"
t.publisher = "Infinity Cat"
assert t.publisher == "Infinity Cat"
t.publisher = None
assert t.publisher is None
def music_naming(path_to_file, music_performer, music_title):
logger.info(path_to_file)
audiofile = Tag()
logger.info(audiofile)
audiofile.parse(path_to_file)
audiofile.artist = f"{music_performer}"
audiofile.title = f"{music_title}"
audiofile.save()
logger.info(
f'New audio attribute: Artist: {audiofile.artist}, Title: {audiofile.title}'
)
def testTableOfContents():
test_file = "/tmp/toc.id3"
t = Tag()
assert (len(t.table_of_contents) == 0)
toc_main = t.table_of_contents.set(b"main", toplevel=True,
child_ids=[b"c1", b"c2", b"c3", b"c4"],
description="Table of Conents")
assert toc_main is not None
assert (len(t.table_of_contents) == 1)
toc_dc = t.table_of_contents.set(b"director-cut", toplevel=False,
ordered=False,
child_ids=[b"d3", b"d1", b"d2"])
assert toc_dc is not None
assert (len(t.table_of_contents) == 2)
toc_dummy = t.table_of_contents.set(b"test")
assert (len(t.table_of_contents) == 3)
t.table_of_contents.remove(toc_dummy.element_id)
assert (len(t.table_of_contents) == 2)
t.save(test_file)
try:
t2 = eyed3.load(test_file).tag
finally:
os.remove(test_file)
assert len(t.table_of_contents) == 2
assert t2.table_of_contents.get(b"main").toplevel
assert t2.table_of_contents.get(b"main").ordered
assert t2.table_of_contents.get(b"main").description == toc_main.description
assert t2.table_of_contents.get(b"main").child_ids == toc_main.child_ids
assert (t2.table_of_contents.get(b"director-cut").toplevel ==
toc_dc.toplevel)
assert not t2.table_of_contents.get(b"director-cut").ordered
assert (t2.table_of_contents.get(b"director-cut").description ==
toc_dc.description)
assert (t2.table_of_contents.get(b"director-cut").child_ids ==
toc_dc.child_ids)
def testReadOnly():
assert not(Tag.read_only)
t = Tag()
assert not(t.read_only)
t.read_only = True
with pytest.raises(RuntimeError):
t.save()
with pytest.raises(RuntimeError):
t._saveV1Tag(None)
with pytest.raises(RuntimeError):
t._saveV2Tag(None, None, None)
class ID3Tagger(object):
def __init__(self, filepath):
self.filepath = filepath
self.tag = Tag()
def parse(self):
self.tag.parse(self.filepath)
return self
def save(self):
try:
self.tag.save(self.filepath, version=ID3_V2_4, encoding="utf8")
except TagException:
pass
try:
self.tag.save(self.filepath, version=ID3_V2_3, encoding="utf8")
except TagException:
pass
# Loss of the release date month and day.
# Loss of the comment with description.
try:
self.tag.save(self.filepath, version=ID3_V1_1, encoding="utf8")
except (TagException, UnicodeEncodeError):
pass
# Loses what v1.1 loses, and the track #
try:
self.tag.save(self.filepath, version=ID3_V1_0, encoding="utf8")
except (TagException, UnicodeEncodeError):
pass
def __getattr__(self, name):
return getattr(self.tag, name)
def __setattr__(self, name, value):
if name in ['filepath', 'tag']:
self.__dict__[name] = value
else:
setattr(self.tag, name, value)
def testTagGenre():
from eyed3.id3 import Genre
tag = Tag()
assert (tag.genre is None)
try:
tag.genre = b"Not Unicode"
except TypeError:
pass # expected
else:
assert not("Non unicode genre, expected TypeError")
gobj = Genre("Hardcore")
tag.genre = "Hardcore"
assert (tag.genre.name == "Hardcore")
assert (tag.genre == gobj)
tag.genre = 130
assert tag.genre.id == 130
assert tag.genre.name == "Terror"
tag.genre = 0
assert tag.genre.id == 0
assert tag.genre.name == "Blues"
tag.genre = None
assert tag.genre is None
assert tag.frame_set[b"TCON"] is None
def testSortOrderConversions():
test_file = "/tmp/soconvert.id3"
tag = Tag()
# 2.3 frames to 2.4
for fid in [b"XSOA", b"XSOP", b"XSOT"]:
frame = frames.TextFrame(fid)
frame.text = fid.decode("ascii")
tag.frame_set[fid] = frame
try:
tag.save(test_file) # v2.4 is the default
tag = eyed3.load(test_file).tag
assert (tag.version == ID3_V2_4)
assert (len(tag.frame_set) == 3)
del tag.frame_set[b"TSOA"]
del tag.frame_set[b"TSOP"]
del tag.frame_set[b"TSOT"]
assert (len(tag.frame_set) == 0)
finally:
os.remove(test_file)
tag = Tag()
# 2.4 frames to 2.3
for fid in [b"TSOA", b"TSOP", b"TSOT"]:
frame = frames.TextFrame(fid)
frame.text = str(fid)
tag.frame_set[fid] = frame
try:
tag.save(test_file, version=eyed3.id3.ID3_V2_3)
tag = eyed3.load(test_file).tag
assert (tag.version == ID3_V2_3)
assert (len(tag.frame_set) == 3)
del tag.frame_set[b"XSOA"]
del tag.frame_set[b"XSOP"]
del tag.frame_set[b"XSOT"]
assert (len(tag.frame_set) == 0)
finally:
os.remove(test_file)
def testTagPlayCount():
tag = Tag()
assert (tag.play_count is None)
tag.play_count = 0
assert tag.play_count == 0
tag.play_count = 1
assert tag.play_count == 1
tag.play_count += 1
assert tag.play_count == 2
tag.play_count -= 1
assert tag.play_count == 1
tag.play_count *= 5
assert tag.play_count == 5
tag.play_count = None
assert tag.play_count is None
try:
tag.play_count = -1
except ValueError:
pass # expected
else:
assert not("Invalid play count, expected ValueError")
def gen_tag(self, track, fake_art=False):
tag = Tag()
if track.has_key('album'):
tag.album = track['album']
if track.has_key('artist'):
tag.artist = " / ".join(track['artist'])
if len(track['artist']) == 2:
print track['artist']
if track.has_key('title'):
tag.title = track['title']
if track.has_key('discNumber') and self.show_discnum:
tag.disc_num = int(track['discNumber'])
if track.has_key('trackNumber'):
tag.track_num = int(track['trackNumber'])
if track.has_key('genre'):
tag.genre = track['genre']
if track.has_key('albumArtist') and (len(track['artist']) != 1 or track['albumArtist'] != track['artist'][0]):
tag.setTextFrame('TPE2', track['albumArtist'])
if track.has_key('year') and int(track['year']) != 0:
tag.recording_date = track['year']
if track.has_key('albumArtRef'):
art = None
if self.__art is None:
if fake_art:
art = '\0' * self.__art_size
else:
if self.load_art():
art = self.__art
else:
art = None
else:
art = self.__art
if art is not None:
tag.images.set(0x03, art, 'image/jpeg', u'Front cover')
return tag
def testTagDiscNum():
tag = Tag()
assert (tag.disc_num == (None, None))
tag.disc_num = 7
assert (tag.disc_num == (7, None))
tag.disc_num = (7, None)
assert (tag.disc_num == (7, None))
tag.disc_num = (7, 15)
assert (tag.frame_set[frames.DISCNUM_FID][0].text == "07/15")
assert (tag.disc_num == (7, 15))
tag.disc_num = (7, 150)
assert (tag.frame_set[frames.DISCNUM_FID][0].text == "007/150")
assert (tag.disc_num == (7, 150))
tag.disc_num = (1, 7)
assert (tag.frame_set[frames.DISCNUM_FID][0].text == "01/07")
assert (tag.disc_num == (1, 7))
tag.disc_num = None
assert (tag.disc_num == (None, None))
tag.disc_num = None, None
def testTagDates():
tag = Tag()
tag.release_date = 2004
assert tag.release_date == Date(2004)
tag.release_date = None
assert tag.release_date is None
tag = Tag()
for date in [Date(2002), Date(2002, 11, 26), Date(2002, 11, 26),
Date(2002, 11, 26, 4), Date(2002, 11, 26, 4, 20),
Date(2002, 11, 26, 4, 20), Date(2002, 11, 26, 4, 20, 10)]:
tag.encoding_date = date
assert (tag.encoding_date == date)
tag.encoding_date = str(date)
assert (tag.encoding_date == date)
tag.release_date = date
assert (tag.release_date == date)
tag.release_date = str(date)
assert (tag.release_date == date)
tag.original_release_date = date
assert (tag.original_release_date == date)
tag.original_release_date = str(date)
assert (tag.original_release_date == date)
tag.recording_date = date
assert (tag.recording_date == date)
tag.recording_date = str(date)
assert (tag.recording_date == date)
tag.tagging_date = date
assert (tag.tagging_date == date)
tag.tagging_date = str(date)
assert (tag.tagging_date == date)
try:
tag._setDate(2.4)
except TypeError:
pass # expected
else:
assert not("Invalid date type, expected TypeError")
def testSetNumExceptions():
t = Tag()
with pytest.raises(ValueError) as ex:
t.track_num = (1, 2, 3)
with pytest.raises(TypeError) as ex:
t.track_num = "1"
def testTagUrls():
tag = Tag()
url = "http://example.com/"
url2 = "http://sample.com/"
tag.commercial_url = url
assert (tag.commercial_url == url)
tag.commercial_url = url2
assert (tag.commercial_url == url2)
tag.commercial_url = None
assert (tag.commercial_url is None)
tag.copyright_url = url
assert (tag.copyright_url == url)
tag.copyright_url = url2
assert (tag.copyright_url == url2)
tag.copyright_url = None
assert (tag.copyright_url is None)
tag.audio_file_url = url
assert (tag.audio_file_url == url)
tag.audio_file_url = url2
assert (tag.audio_file_url == url2)
tag.audio_file_url = None
assert (tag.audio_file_url is None)
tag.audio_source_url = url
assert (tag.audio_source_url == url)
tag.audio_source_url = url2
assert (tag.audio_source_url == url2)
tag.audio_source_url = None
assert (tag.audio_source_url is None)
tag.artist_url = url
assert (tag.artist_url == url)
tag.artist_url = url2
assert (tag.artist_url == url2)
tag.artist_url = None
assert (tag.artist_url is None)
tag.internet_radio_url = url
assert (tag.internet_radio_url == url)
tag.internet_radio_url = url2
assert (tag.internet_radio_url == url2)
tag.internet_radio_url = None
assert (tag.internet_radio_url is None)
tag.payment_url = url
assert (tag.payment_url == url)
tag.payment_url = url2
assert (tag.payment_url == url2)
tag.payment_url = None
assert (tag.payment_url is None)
tag.publisher_url = url
assert (tag.publisher_url == url)
tag.publisher_url = url2
assert (tag.publisher_url == url2)
tag.publisher_url = None
assert (tag.publisher_url is None)
# Frame ID enforcement
with pytest.raises(ValueError):
tag._setUrlFrame("WDDD", "url")
with pytest.raises(ValueError):
tag._getUrlFrame("WDDD")
def __init__(self, filepath):
self.filepath = filepath
self.tag = Tag()
def testTagMainProps():
tag = Tag()
# No version yet
assert tag.version == ID3_DEFAULT_VERSION
assert not(tag.isV1())
assert tag.isV2()
assert tag.artist is None
tag.artist = "Autolux"
assert tag.artist == "Autolux"
assert len(tag.frame_set) == 1
tag.artist = ""
assert len(tag.frame_set) == 0
tag.artist = "Autolux"
assert tag.album is None
tag.album = "Future Perfect"
assert tag.album == "Future Perfect"
assert tag.album_artist is None
tag.album_artist = "Various Artists"
assert (tag.album_artist == "Various Artists")
assert (tag.title is None)
tag.title = "Robots in the Garden"
assert (tag.title == "Robots in the Garden")
assert (tag.track_num == (None, None))
tag.track_num = 7
assert (tag.track_num == (7, None))
tag.track_num = (7, None)
assert (tag.track_num == (7, None))
tag.track_num = (7, 15)
assert (tag.frame_set[frames.TRACKNUM_FID][0].text == "07/15")
assert (tag.track_num == (7, 15))
tag.track_num = (7, 150)
assert (tag.frame_set[frames.TRACKNUM_FID][0].text == "007/150")
assert (tag.track_num == (7, 150))
tag.track_num = (1, 7)
assert (tag.frame_set[frames.TRACKNUM_FID][0].text == "01/07")
assert (tag.track_num == (1, 7))
tag.track_num = None
assert (tag.track_num == (None, None))
tag.track_num = None, None
# This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/> ################################################################################ from eyed3.id3 import Tag from eyed3.id3 import ID3_V1_0, ID3_V1_1, ID3_V2_3, ID3_V2_4 import logging from eyed3 import log log.setLevel(logging.DEBUG) t = Tag() t.artist = u"M.O.P." t.title = u"How About Some Hardcore" t.album = u"To The Death" t.genre = u"Hip-Hop" t.track_num = (3,5) t.disc_num = (1,1) t.original_release_date = "1994-04-07" t.release_date = "1994-04-07" t.encoding_date = "2002-03" t.recording_date = 1996 t.tagging_date = "2012-2-5" t.comments.set(u"Gritty, yo!") t.comments.set(u"Brownsville, Brooklyn", u"Origin")
