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