def metadata( file_name, artist, title ): # easyID3 and ID3 are used to write metadata tags and apply album art found using sacad audio = EasyID3(file_name) audio['artist'] = artist audio['title'] = title audio.save() audio = ID3(file_name) with open(artist + " - " + title + ".jpg", 'rb') as albumart: audio['APIC'] = APIC(encoding=3, mime='image/jpeg', type=3, desc=u'Cover', data=albumart.read()) audio.save()
def write_id3_tags(self, filename, meta): print "Encoding . . . " audio = MP3(filename) audio["TIT2"] = TIT2(encoding=3, text=["title"]) audio.save() audio = EasyID3(filename) audio["tracknumber"] = meta['track'] audio["title"] = meta['title'] audio["artist"] = meta['artist'] audio["album"] = meta['album'] audio["date"] = meta['date'] audio.save() print "Done encoding . . . "
def add_to_list(self): directory = askopenfilenames() for song_dir in directory: print(song_dir) self.playlist.append(song_dir) self.output.delete(0.0, END) for key, item in enumerate(self.playlist): song = EasyID3(item) song_data = (str(key + 1) + ' : ' + song['title'][0] + ' - ' + song['artist'][0]) self.output.insert(END, song_data + '\n')
def apply_tags(file_path, tag_list): """ Using mutagen, apply the tags to the file. """ if file_path.endswith(".mp3"): muta = EasyID3(file_path) elif file_path.endswith(".m4a"): muta = EasyMP4(file_path) else: muta = File(file_path) for key in tag_list: muta.update({key: tag_list[key]}) muta.save()
def get_file_tag(f): system_tag = None if f.endswith(types["mp3"]["ext"]): system_tag = EasyID3(f) elif f.endswith(types["flac"]["ext"]): system_tag = FLAC(f) elif f.endswith(types["ogg"]["ext"]): system_tag = OggVorbis(f) out_tag = MusicTag(title=system_tag["title"][0], title_number=system_tag["tracknumber"][0], album=system_tag["album"][0], artist=system_tag["artist"][0], album_artist=system_tag["albumartist"][0]) return out_tag
def compare(music_file, metadata): """Check if the input music file title matches the expected title.""" already_tagged = False try: if music_file.endswith('.mp3'): audiofile = EasyID3(music_file) # fetch track title metadata already_tagged = audiofile['title'][0] == metadata['name'] elif music_file.endswith('.m4a'): tags = {'title': '\xa9nam'} audiofile = MP4(music_file) # fetch track title metadata already_tagged = audiofile[tags['title']] == metadata['name'] except (KeyError, TypeError): pass return already_tagged
def updateMP3Info(fileName, like): try: meta = EasyID3(fileName) except error: meta = mutagen.File(fileName, easy=True) meta.add_tags() meta['title'] = like.title meta['artist'] = like.user meta.save() if(like.artworkURL is not None): addArtwork(fileName, like) else: print("Artwork Skipped")
def GetTags(sourcePath): global title global artist global date global album fileType = os.path.splitext(sourcePath)[1] metadata = None if (fileType == ".flac"): metadata = FLAC(sourcePath) elif (fileType == ".mp3"): metadata = EasyID3(sourcePath) title = metadata["title"][0] artist = metadata["artist"][0] date = metadata["date"][0] album = metadata["album"][0] print("Finished getting tags")
def get_pieces_from_sets(sets): """ takes a list of set filenames, reads the directories from those sets and then gets all the pieces which are in those directories """ directories = [] pieces = {} prefix = '' for path in sets: # utf-8 is important with open('../directories/' + path, encoding='utf-8') as input_file: lines = input_file.readlines() for line in lines: if line.startswith('prefix='): # set prefix to non-empty string prefix = line[7:-1] # ignore commented or empty lines elif not ((line[0] == '#') or (line == '\n')): directories.append(prefix + line.replace('\n', '')) for directory in directories: # ID3-title (piece-specific, not per-movement) of last file # ('' if new directory, used to decide whether we found a new piece) id3 = '' for filename in sorted(os.listdir(directory)): if '.mp3' in filename: # ignore non-mp3 files audio = EasyID3(os.path.join(directory, filename)) try: id3_text = audio['title'][0] except KeyError: print( os.path.join(directory, filename) + ' does not have a TIT2 ID3 tag') continue n_id3 = id3_text[:id3_text.find(' - ')] if ( ' - ' in id3_text) else id3_text # ID3-title of current file n_id3 = n_id3.strip() # remove any spaces at beginning/end if n_id3 != id3: # seems to be a new piece id3 = n_id3 # set new ID3-title because new piece # new piece so we need to create a new empty list that we # can append files to pieces[id3] = [] pieces[id3].append( '"' + os.path.join(directory, filename) + '"') # quotes needed for windows file name handling return pieces
def sendAudio(chat_id, audio, lang, music, image=None, youtube=False): sleep(0.8) bot.sendChatAction(chat_id, "upload_audio") try: url = "https://api.telegram.org/bot" + token + "/sendAudio" if os.path.isfile(audio): audio = open(audio, "rb") try: tag = EasyID3(audio.name) duration = MP3(audio.name).info.length except mutagen.id3._util.ID3NoHeaderError: tag = FLAC(audio.name) duration = tag.info.length data = { "chat_id": chat_id, "duration": duration, "performer": tag['artist'], "title": tag['title'] } file = {"audio": audio, "thumb": requests.get(image).content} try: request = requests.post(url, params=data, files=file) except: request = requests.post(url, params=data, files=file) if request.status_code == 413: sendMessage( chat_id, translate( lang, "The song " + tag['artist'] + " - " + tag['title'] + " is too big to be sent")) else: if youtube == False: audio = request.json()['result']['audio']['file_id'] write_db( "INSERT INTO DWSONGS(id, query, quality) values('%s', '%s', '%s')" % (music, audio, qualit[chat_id])) else: bot.sendAudio(chat_id, audio) except telepot.exception.TelegramError: sendMessage( chat_id, translate(lang, "Sorry the track doesn't seem readable on Deezer :(")) except: sendMessage( chat_id, translate(lang, "Sorry for some reason I can't send the track"))
def make_tags(podcast, attribs, path, filename, episode): # Tag the episode with ID3 metadata print(f"-- Tagging {filename}") try: try: tags = EasyID3(f"{path}/{filename}") except: tags = mutagen.File(f"{path}/{filename}", easy=True) except: print( f"############ Unable to open {path}/{filename} for tagging ############" ) sys.exit() tags['title'] = episode.get('title', filename) tags['artist'] = attribs.get('artist', podcast) tags['album'] = attribs.get('album', podcast) tags['author'] = attribs.get('author', podcast) # tags['comments'] = episode.metadata['comments'] # tags['creative_commons'] = episode.metadata['creative_commons'] # tags['enclosure_url'] = episode.metadata['enclosure_url'] # tags['enclosure_type'] = episode.metadata['enclosure_type'] # tags['enclosure_length'] = episode.metadata['enclosure_length'] # tags['enclosure_type'] = episode.metadata['enclosure_type'] # tags['guid'] = episode.metadata['guid'] # tags['itunes_author_name'] = episode.metadata['itunes_author_name'] # tags['itunes_block'] = episode.metadata['itunes_block'] # tags['itunes_closed_captioned'] = episode.metadata['itunes_closed_captioned'] # tags['itunes_duration'] = episode.metadata['itunes_duration'] # tags['itunes_explicit'] = episode.metadata['itunes_explicit'] # tags['itune_image'] = episode.metadata['itune_image'] # tags['itunes_order'] = episode.metadata['itunes_order'] # tags['itunes_subtitle'] = episode.metadata['itunes_subtitle'] # tags['itunes_summary'] = episode.metadata['itunes_summary'] # tags['link'] = episode.metadata['link'] # tags['published_date'] = episode.metadata['published_date'] # tags['title'] = episode.metadata['title'] genres = attribs.get('genres', []) genres.append('Podcast') tags['genre'] = ','.join(genres) if attribs.get('track_num'): tags['tracknumber'] = str(attribs.get('track_num')) tags.save() return
def download_music(url, index=None): url_hash = hashlib.md5(url.encode()).hexdigest() if index: url_hash = url_hash + "-" + str(index) path = var.config.get('bot', 'tmp_folder') + url_hash + ".%(ext)s" mp3 = path.replace(".%(ext)s", ".mp3") if os.path.isfile(mp3): audio = EasyID3(mp3) video_title = audio["title"][0] else: if index: ydl_opts = { 'format': 'bestaudio/best', 'outtmpl': path, 'writethumbnail': True, 'updatetime': False, 'playlist_items': str(index), 'postprocessors': [{ 'key': 'FFmpegExtractAudio', 'preferredcodec': 'mp3', 'preferredquality': '192'}, {'key': 'FFmpegMetadata'}] } else: ydl_opts = { 'format': 'bestaudio/best', 'outtmpl': path, 'noplaylist': True, 'writethumbnail': True, 'updatetime': False, 'postprocessors': [{ 'key': 'FFmpegExtractAudio', 'preferredcodec': 'mp3', 'preferredquality': '192'}, {'key': 'FFmpegMetadata'}] } video_title = "" with youtube_dl.YoutubeDL(ydl_opts) as ydl: for i in range(2): try: info_dict = ydl.extract_info(url) video_title = info_dict['title'] except youtube_dl.utils.DownloadError: pass else: break return mp3, video_title
def fix_names(self): API_key = "ebd06f4e0ef7f4affadd430237a839b1" art_url = "http://ws.audioscrobbler.com/2.0/?method=album.getinfo&api_key=" + API_key + "&artist=" + self.artistName + "&album=" + self.albumName + "&format=json" res = requests.get(art_url) res = json.loads(res.text) # Sanitize titles for title in self.songs: bad_chars = '<>:"/\|?*' for c in bad_chars: title = title.replace(c, ';') title = title.replace('.', '') # Rename files os.chdir('./' + self.artistName.replace('+', ' ') + '/' + self.albumName.replace('+', ' ') + '/') for filename in sorted(os.listdir('./')): self.files.append(filename) print("\n\nAdding Album art and renaming songs.... ") http = urllib3.PoolManager() albumart = http.request('GET', res['album']['image'][-2]['#text']).data for i in range(0, len(self.songs)): data = EasyID3(self.files[i]) data['title'] = self.songs[i] data['album'] = self.albumName data['tracknumber'] = str(i + 1) data['albumartist'] = self.artistName data['artist'] = self.artistName data.save() data = ID3(self.files[i]) data['APIC'] = APIC( encoding=3, # 3 is for utf-8 mime='image/png', # image/jpeg or image/png type=3, # 3 is for the cover image desc=u'Cover', data=albumart) data.save() os.rename(self.files[i], self.songs[i] + '.mp3') print("\nSuccessfully downloaded album \"" + self.albumName + "\" by " + self.artistName)
def _score_songs_and_titles_in_sentence(self, sentence): file_set_to_search = os.listdir(self._music_folderpath) splitted_sentence = sentence.split(" ") scores_for_songs = {} scores_for_assumed_titles = {} for file_name in file_set_to_search: try: file_name = self._music_folderpath + "/" + file_name audio_file = EasyID3(file_name) audio_file_title = audio_file[ LocalStorageForMusic.METADATA_KEY_TITLE][0] audio_file_artist = audio_file[ LocalStorageForMusic.METADATA_KEY_ARTIST][0] # At this point, it is safe to assume the file is an audio format. # Therefore we can assign it a place in scores_for_song_titles dictionary. score_for_song = {} for assumed_title_begin_index in range(len(splitted_sentence)): for assumed_title_end_index in range( assumed_title_begin_index, len(splitted_sentence)): assumed_title = " ".join(splitted_sentence[ assumed_title_begin_index:assumed_title_end_index + 1]) assumed_title_score = self._score_title_same_as_heard_title( audio_file_title, assumed_title) score_for_song[assumed_title] = assumed_title_score scores_for_assumed_titles[assumed_title] = ( scores_for_assumed_titles[assumed_title] if assumed_title in scores_for_assumed_titles else 0.0) + assumed_title_score score_data_for_song = { self.KEY_SONG_TITLE: audio_file_title, self.KEY_SONG_ARTIST: audio_file_artist, self.KEY_SONG_SCORE: score_for_song } scores_for_songs[audio_file] = score_data_for_song except: continue # We have to adjust the scores according to the assumed title being a real title by passing it through a certain # model. This model should reduce the score for including words which would not preferably exist in song titles. return scores_for_songs, scores_for_assumed_titles
def read_artists(path): artist_set = set() total_count = 0 unreadable_count = 0 for root, dirs, files in os.walk(path, topdown=False): file_count = 0 for file_count, filename in enumerate(files, start=1): path = root + "/" + filename ext = os.path.splitext(path)[1] # skip some common file extensions that may be found in music folders if filename.startswith( ".") or ext == ".jpg" or ext == ".m3u" or ext == ".txt": continue try: # guess the file type by extension. this is faster than looking at file contents if ext == ".m4v" or ext == ".mp4" or ext == ".m4a": audio = EasyMP4(path) elif ext == ".ogg": audio = OggVorbis(path) elif ext == ".flac": audio = FLAC(path) else: audio = EasyID3(path) except Exception as e: Logger.debug(e) # try slower magic number/tag lookup if filename based guess doesn't work. audio = mutagen.File(path, easy=True) if audio is not None and 'artist' in audio: for artist in audio['artist']: if len(artist) != 0 and not artist.lower().startswith( "various") and not artist.lower().startswith( "unknown"): artist_set.add(artist) else: unreadable_count += 1 total_count += file_count Logger.info("Total files %i, Total unreadable %i", total_count, unreadable_count) Logger.info("Total artist count %i", len(artist_set)) Logger.debug(artist_set) return artist_set
def sendAudio( chat_id, audio, link = None, image = None, youtube = False ): sleep(default_time) try: if os.path.isfile(audio): bot.sendChatAction(chat_id, "upload_audio") try: tag = EasyID3(audio) duration = int(MP3(audio).info.length) except ID3NoHeaderError: tag = FLAC(audio) duration = int(tag.info.length) if os.path.getsize(audio) < telegram_audio_api_limit: file_id = bot.sendAudio( chat_id, open(audio, "rb"), thumb = open(image.url, "rb"), duration = duration, performer = tag['artist'][0], title = tag['title'][0], caption = "@Music_Geeks" )['audio']['file_id'] if not youtube: quality = fast_split(audio) link = "track/%s" % link.split("/")[-1] write_db( insert_query % ( link, file_id, quality ) ) else: sendMessage(chat_id, "Song too big :(") else: bot.sendAudio(chat_id, audio, caption = "@Music_Geeks") except error.BadRequest: sendMessage(chat_id, "Sorry the track %s doesn't seem readable on Deezer :(" % link)
def create_link_song(source, base_folder): """Make song Filename fitting to the database structure this ensures that duplicate songs don't clutter mp3 players' album views""" dest = "" try: song = source.decode(sys.getfilesystemencoding()) except: song = make_compat_str(source) song = song.encode('ascii', 'ignore') song_file = {} try: song_file = EasyID3(song) except: song_file['artist'] = "Unknown" song_file['album'] = "Unknown" try: src = song target = base_folder try: artist = ''.join(song_file['artist']) if (artist == ""): artist = ''.join(song_file['author']) if (artist == ""): artist = ''.join(song_file['performer']) if (artist == ""): artist = ''.join(song_file['composer']) except KeyError, exception_reason: artist = u"Unknown Artist" artist = (binascii.crc32(artist.encode('utf-8')) & 0xffffffff) artist = "%x" % (artist) target = os.path.join(target, artist) if not os.path.isdir(target): os.makedirs(target) try: album = ''.join(song_file['album']) except KeyError, exception_reason: album = u"Unknown Album"
def _score_songs_and_artists_in_sentence(self, sentence): file_set_to_search = os.listdir(self._music_folderpath) splitted_sentence = sentence.split(" ") scores_for_songs = {} scores_for_assumed_artists = {} for file_name in file_set_to_search: try: file_name = self._music_folderpath + "/" + file_name audio_file = EasyID3(file_name) audio_file_title = audio_file[ LocalStorageForMusic.METADATA_KEY_TITLE][0] audio_file_artist = audio_file[ LocalStorageForMusic.METADATA_KEY_ARTIST][0] # At this point, it is safe to assume the file is an audio format. # Therefore we can assign it a place in scores_for_song_titles dictionary. score_for_song = {} for assumed_artist_begin_index in range( len(splitted_sentence)): for assumed_artist_end_index in range( assumed_artist_begin_index, len(splitted_sentence)): assumed_artist = " ".join( splitted_sentence[assumed_artist_begin_index: assumed_artist_end_index + 1]) assumed_artist_score = self._score_artist_same_as_heard_artist( audio_file_artist, assumed_artist) score_for_song[assumed_artist] = assumed_artist_score scores_for_assumed_artists[assumed_artist] = ( scores_for_assumed_artists[assumed_artist] if assumed_artist in scores_for_assumed_artists else 0.0) + assumed_artist_score score_data_for_song = { self.KEY_SONG_TITLE: audio_file_title, self.KEY_SONG_ARTIST: audio_file_artist, self.KEY_SONG_SCORE: score_for_song } scores_for_songs[audio_file] = score_data_for_song except: continue return scores_for_songs, scores_for_assumed_artists
def __init__(self, filename, newtracklength, albumname='', trackname='', performer='', genre='', albumyear=''): assert_str(filename) if IO.file_exists(filename): self.fileName = filename if filename.endswith('.mp3'): self.EasyID3 = EasyID3(filename) self.mp3 = MP3(filename) assert_int_or_float(newtracklength) self.newTrackLength = newtracklength assert_str(trackname) if trackname != '': self.trackName = trackname else: self.trackName = str(tryGet(self.EasyID3, 'title')[0]) assert_str(performer) if performer != '': self.performer = performer else: self.performer = str(tryGet(self.EasyID3, 'artist')[0]) assert_str(albumname) if albumname != '': self.albumName = albumname else: self.albumName = str(tryGet(self.EasyID3, 'album')[0]) assert_str(genre) if genre != '': self.albumGenre = genre else: self.albumGenre = str(tryGet(self.EasyID3, 'genre')[0]) assert_str(albumyear) if albumyear != '': self.albumYear = albumyear else: self.albumYear = str(tryGet(self.EasyID3, 'date')[0]) self.trackLength = self.mp3.info.length else: raise ValueError('File should be an mp3, bitch!') else: raise ValueError('Enter a valid file name, bitch!')
def set_id3_data(self, convertedFilePath, songObj): # embed song details # ! we save tags as both ID3 v2.3 and v2.4 # ! The simple ID3 tags audioFile = EasyID3(convertedFilePath) # ! Get rid of all existing ID3 tags (if any exist) audioFile.delete() # ! song name audioFile['title'] = songObj.get_song_name() audioFile['titlesort'] = songObj.get_song_name() # ! track number audioFile['tracknumber'] = str(songObj.get_track_number()) # ! disc number audioFile['discnumber'] = str(songObj.get_disc_number()) # ! genres (pretty pointless if you ask me) # ! we only apply the first available genre as ID3 v2.3 doesn't support multiple # ! genres and ~80% of the world PC's run Windows - an OS with no ID3 v2.4 support genres = songObj.get_genres() if len(genres) > 0: audioFile['genre'] = genres[0] # ! all involved artists audioFile['artist'] = songObj.get_contributing_artists() # ! album name audioFile['album'] = songObj.get_album_name() # ! album artist (all of 'em) audioFile['albumartist'] = songObj.get_album_artists() # ! album release date (to what ever precision available) audioFile['date'] = songObj.get_album_release() audioFile['originaldate'] = songObj.get_album_release() # ! save as both ID3 v2.3 & v2.4 as v2.3 isn't fully features and # ! windows doesn't support v2.4 until later versions of Win10 audioFile.save(v2_version=3) # ! setting the album art audioFile = ID3(convertedFilePath) rawAlbumArt = urlopen(songObj.get_album_cover_url()).read() audioFile['APIC'] = AlbumCover(encoding=3, mime='image/jpeg', type=3, desc='Cover', data=rawAlbumArt) # ! setting the lyrics lyrics = songObj.get_lyrics() USLTOutput = USLT(encoding=3, lang=u'eng', desc=u'desc', text=lyrics) audioFile["USLT::'eng'"] = USLTOutput audioFile.save(v2_version=3)
def showMusic(): globPath = argv[-1] directory, glob = path.split(globPath) for (top, dirs, files) in walk(directory): for file in files: if fnmatch(file, glob): # "Normalizing the path just for safety" # This makes sure all of the path separators are correct for the OS etc.. mp3FilePath = path.normpath(path.join(top, file)) try: media = EasyID3(mp3FilePath) data = { tagName:tagValue[0] for tagName,tagValue in media.items()} args = [f.lstrip("-").split("=") for f in argv if f.startswith("--")] tag, value = [(x,y) for x,y in args][0] for tag,val in args: # match expression with arguments if re.match("^(The)*\s*\w.+", val): if data["artist"] == val: tmplt = "Found: {artist} {album} {title}" print(tmplt.format(**data)) if data["title"] == val: tmplt = "Found: {artist} {album} {title}" print(tmplt.format(**data)) if data["album"] == val: tmplt = "Found: {artist} {album} {title}" print(tmplt.format(**data)) except Exception as e: print("Could not read: " + file + " " + str(e)) print("Usage: LAB5.py [--artist=\"artistname\"] [--song=\"songname\"] [--album=\"albumname\"] fileGlob")
def tag_and_copy(self, audio_data, tmpdirname): dest_path = path.join(self.playlist_path_location, audio_data.filename) filepath = path.join(tmpdirname, audio_data.filename) # if artist and audio -> use id3 tags if self.audio_transform and audio_data.artist is not None: try: meta = EasyID3(filepath) except mutagen.id3.ID3NoHeaderError: meta = mutagen.File(filepath, easy=True) meta["title"] = audio_data.tagtitle meta["artist"] = audio_data.artist meta.save() # copy audio file (no need to remove files in tmpdir) if not path.exists(dest_path): log.debug(f'Moving {filepath} -> {dest_path}') shutil.copyfile(filepath, dest_path)
def main(delete, title_artist, title_only, min_bitrate, directory): songs = getMP3s(directory) for song in songs: try: loaded = EasyID3(song) if ("title" in loaded and "artist" in loaded): bitrate = MP3(song).info.bitrate / 1000 if (min_bitrate >= bitrate): ## Ensure minimum bitrate is reached deleteSong(song, "Bitrate below: " + str(min_bitrate)) continue title = sanitizeString(str(loaded["title"][0])) renamed = [ '', '', '', '.mp3' ] ## Since we're only dealing with mp3s at the moment. if (not title_only ): ## Thus, we'll have the title and the artist somewhere. renamed[1] = ' - ' if (not title_artist): ## Thus, the artist string comes first renamed[0] = sanitizeString(str( loaded["artist"][0])) * (not title_only) renamed[2] = title else: ## Thus, the title string comes first renamed[0] = title renamed[2] = sanitizeString(str( loaded["artist"][0])) * (not title_only) renamed = os.path.join(directory, ''.join(renamed)) os.rename(song, renamed) print(getPathEnd(song) + " ==> " + getPathEnd(renamed)) except ID3NoHeaderError: if (delete): deleteSong(song, "ID3NoHeaderError exception") continue except error: if (delete): deleteSong(song, "MutagenError exception") continue except: exception = sys.exc_info()[0].__name__ print(exception + " exception for song: " + song)
def addID3Tags(filename, config, title, desc): """Add ID3 tags.""" logger.info("Adding ID3 tags...") # Get reference to tags, add them if not found try: metaData = EasyID3(filename) except mutagen.id3.ID3NoHeaderError: metaData = MP3(filename, ID3=EasyID3) metaData.add_tags() # Set tags metaData['title'] = title metaData['artist'] = unicode(config['episodeAuthor']) metaData['date'] = unicode(str(datetime.datetime.now().year)) metaData['album'] = unicode(config['rssTitle']) metaData.save()
def initialize_meta(self): try: self.meta = EasyID3(self.filePath) except MutagenError: class meta: def __init__(self): pass def get(self, prop, default): return default def pprint(self): return {} self.meta = meta() pass
def split_song(album, tracksStarts, index, track, FOLDER): print("\t{}) {}".format(str(index+1), track)) start = tracksStarts[index] end = tracksStarts[index+1] duration = end-start track_path = '{}/{:02d} - {}.mp3'.format(FOLDER, index+1, track) album[start:][:duration].export(track_path, format="mp3") print("\t\tTagging") song = EasyID3(track_path) if ARTIST: song['artist'] = ARTIST if ALBUM: song['album'] = ALBUM song['title'] = track song['tracknumber'] = str(index+1) song.save()
def download_track(title, link, artist, album, tracknum, year, path): print("Downloading " + title) filename = "./downloads/" + path + "/" + title + ".mp3" file = open(filename, "wb") file.write(requests.get(link).content) file.close() mp3 = MP3(filename) if mp3.tags is None: mp3.add_tags() mp3.save() audio = EasyID3(filename) audio["artist"] = u"" + artist audio["title"] = u"" + title audio["album"] = u"" + album audio["tracknumber"] = u"" + str(tracknum) audio["date"] = u"" + year audio.save()
def test_save_meta(self): # Given audio_src = os.path.join(TEST_DATA_DIR, 'file_example_MP3_700KB.mp3') audio_dst = os.path.join(self.out_dir, 'test.mp3') art_srt = os.path.join(TEST_DATA_DIR, 'SampleJPGImage_50kbmb.jpg') shutil.copy(audio_src, audio_dst) # When save_meta(audio_dst, self.info_obj, art_srt) # Then meta = EasyID3(audio_dst) for meta_key, meta_val in self.info_obj.id3_meta.items(): self.assertEqual(meta[meta_key][0], meta_val) meta = ID3(audio_dst) self.assertTrue(meta['APIC:Cover'])
def addMetadata(fileName,thumbnail,title,artist,album): """ Add metadata and thumbnail to mp3 and mp4 files (TODO for mp4). Parameters: ---------- fileName : str Source file with complete path. thumbnail : str Name of the thumbnail image file with full path. title : str artist : str album : str Usage: ----- utils.convertFileFormat(source,target,deleteSource=True) Returns: ------- title : str artist : str album : str """ if ('.mp3' in fileName): audio = MP3(fileName,ID3=ID3) audio.tags.add(APIC(mime='image/jpeg',type=3,desc=u'Cover',data=open(thumbnail,'rb').read())) audio.save() os.remove(thumbnail) # ADD TITLE AND ALBUM NAME audio = EasyID3(fileName) audio['title'] = title audio['artist'] = artist audio['album'] = album audio.save() elif ('.mp4' in fileName): video = MP4(fileName) tags = video.tags tags['\xa9nam'] = title tags['\xa9ART'] = artist tags['\xa9alb'] = album with open(thumbnail,'rb') as f: tags["covr"] = [MP4Cover(f.read(), imageformat=MP4Cover.FORMAT_JPEG)] tags.save(fileName) os.remove(thumbnail)
def processFile(self, path): try: mp3info = EasyID3(path) except Exception as e: return print(path) info = mp3info.pprint() name = self.getId3Info(mp3info, "title", info) trackNum = self.getId3Info(mp3info, "tracknumber", info) artist = self.getId3Info(mp3info, "performer", info) album = self.getId3Info(mp3info, "album", info) gender = self.getId3Info(mp3info, "genre", info) year = self.getId3Info(mp3info, "date", info) artist = dh.artistId(artist) gender = dh.genderId(gender) album = dh.albumId(album, year, artist, gender) album = dh.songId(name, trackNum, artist, album)