def try_writemeta(vid, ext): filepath = os.path.join(path, 'output/file', ext, vid) if os.path.isdir(filepath): files = [ file for file in next(os.walk(filepath))[2] if file.endswith(ext) ] if len(files) > 0: filename = files[0] if ext in ('mp3', ): logging.info(f'Trying to write metadata to {vid}.{ext}') info = get_raw_ytinfo(vid) meta = EasyID3(os.path.join(filepath, filename)) meta['title'] = filename[:-(len(ext) + 1)] if info is not None: if info['artist']: meta['artist'] = info['artist'] meta['albumartist'] = info['artist'] if info['album']: meta['album'] = info['album'] meta.save() logging.info(f'Metadata {info} written into {vid}.{ext}')
def addtags(filename, json_data): try: audio = MP4(filename) audio['\xa9nam'] = unicode(json_data['song']) audio['\xa9ART'] = unicode(json_data['primary_artists']) audio['\xa9alb'] = unicode(json_data['album']) audio['aART'] = unicode(json_data['singers']) audio['\xa9wrt'] = unicode(json_data['music']) audio['\xa9gen'] = unicode(json_data['language']) audio['purl'] = unicode(json_data['album_url']) audio['\xa9day'] = unicode(json_data['year']) audio['\xa9cmt'] = 'starring : {}'.format(unicode(json_data['starring'])) audio['desc'] = parseHastags(json_data) cover_url = json_data['image'][:-11] + '500x500.jpg' fd = urllib.request.urlopen(cover_url) cover = MP4Cover(fd.read(), getattr(MP4Cover, 'FORMAT_PNG' if cover_url.endswith('png') else 'FORMAT_JPEG')) fd.close() audio['covr'] = [cover] audio.save() #‘\xa9lyr’ – lyrics except: os.rename(filename, filename[:-3]+'mp3') filename = filename[:-3] + 'mp3' try: audio = ID3(filename) except ID3NoHeaderError: audio = ID3() audio.add(TPE1(encoding=3, text=unicode(json_data['singers']))) audio.save(filename) audio = EasyID3(filename) audio['title'] = unicode(json_data['song']) audio['albumartist'] = unicode(json_data['primary_artists']) audio['album'] = unicode(json_data['album']) #audio['aART'] = unicode(json_data['singers']) audio['copyright'] = unicode(json_data['music']) #audio['copyright'] = unicode(json_data['starring']) audio['genre'] = unicode(json_data['label']) audio['date'] = unicode(json_data['year']) audio.save()
def parse(self, filename: Path) -> Metadata: """Extract the metadata from an MP3 file""" #print(filename) try: mp3_data = io.BytesIO(open(filename, 'rb').read()) except IOError as err: raise InvalidMP3Exception(err) mp3info = EasyID3(mp3_data) try: artist = mp3info["artist"] title = mp3info["title"] except KeyError as err: raise InvalidMP3Exception( f"File: {filename.name} does not both title and artist info") if len(artist) == 0 or len(title) == 0: raise InvalidMP3Exception( f"File: {filename.name} does not both title and artist info") metadata = { "artist": artist[0], "title": title[0], } try: metadata["album"] = str(mp3info["album"][0]) except KeyError: metadata["album"] = filename.parent.name del mp3info mp3_data.seek(0, io.SEEK_END) filesize = mp3_data.tell() mp3_data.seek(0) seg = AudioSegment.from_mp3(mp3_data) # duration is in milliseconds metadata["duration"] = len(seg) # bitrate is in Kbps metadata["bitrate"] = int(round(8.0 * filesize / float(metadata["duration"]))) metadata["sample_width"] = seg.sample_width * 8 metadata["channels"] = seg.channels # sample rate is in Hz metadata["sample_rate"] = seg.frame_rate return Metadata(**metadata) # type: ignore
def encode_tracks(self): """ Using mutagen this encodes the .MP3 files so that iTunes and other players can know what Artist, album, etc are. """ print("Encoding...") i = 0 for track in self.__album_data['track_titles']: file_name = self.__file_path + track + ".mp3" try: file_to_encode = EasyID3(file_name) except mutagen.id3.ID3NoHeaderError: print("\nFile didnt have ID3 tag, tagging now\n") file_to_encode = mutagen.File(file_name, easy=True) file_to_encode.add_tags() # add the mp3 tags to the audio files file_to_encode['tracknumber'] = str(i + 1) file_to_encode['title'] = track file_to_encode['artist'] = self.__album_data['artist'] file_to_encode['album'] = self.__album_data['title'] file_to_encode['date'] = self.__album_data['release_date'][2] file_to_encode.save() file_to_encode = MP3(file_name) print(self.__album_data['cover']) cover_data = open(self.__album_data['cover'], 'rb').read() file_to_encode.tags.add( APIC( encoding=3, mime='image/jpeg', type=3, desc=u'Cover', data=cover_data ) ) file_to_encode.save() i += 1 print("\nEncoding finished!\n")
def addTagsToMP3(file_path, mp3_file_path, file_ext): """Gets the existing tags from the mp4 file and saves them to the mp3 Arguments: mp4_file_path {str} -- Path for MP4 file mp3_file_path {str} -- Path for MP3 file """ original_file_tags = None mp3_tags = EasyID3(mp3_file_path) if file_ext == "m4a": original_file_tags = EasyMP4(file_path) for k, v in original_file_tags.items(): found_tag = EXTENSION_MAPPING.get(k, None) if found_tag is not None: resulting_tag = CONVERSION_TABLE[found_tag]["mp3"] mp3_tags[resulting_tag] = [v] print("Added tag {0}:{1} to mp3 {2}".format( resulting_tag, v, mp3_file_path)) elif file_ext in ["wma", "wmv"]: original_file_tags = ASF(file_path).tags for k, v in original_file_tags.items(): found_tag = EXTENSION_MAPPING.get(k, None) if found_tag is not None: resulting_tag = CONVERSION_TABLE[found_tag]["mp3"] if file_ext in ["wma", "wmv"]: if resulting_tag == "composer": if mp3_tags.get(resulting_tag, None): mp3_tags[resulting_tag] = ["{0}, {1}"].format( mp3_tags[resulting_tag][0], v[0].value) else: mp3_tags[resulting_tag] = [v[0].value] else: mp3_tags[resulting_tag] = [v[0].value] print("Added tag {0}:{1} to mp3 {2}".format( resulting_tag, v[0], mp3_file_path)) else: return mp3_tags.save(mp3_file_path) print("MP3 tags saved to {0}".format(mp3_file_path))
def gather_audio_get_tag_info(audiofile): ''' function to intially extract info from the tags ''' from mutagen.easyid3 import EasyID3 from mutagen.mp3 import MP3 import time import datetime from datetime import datetime import unicodedata import sys, traceback title = '' broadcastDate = '' episodeNumber = 0 length = 60 try: id3 = EasyID3(audiofile) mp3 = MP3(audiofile) length = mp3.info.length broadcastDate = unicodedata.normalize( 'NFKD', mp3["COMM::'XXX'"].text[0]).encode('ascii', 'ignore') if broadcastDate[2] == '-': broadcastDate = '19' + broadcastDate title = unicodedata.normalize('NFKD', id3['title'][0]).encode( 'ascii', 'ignore') episodeNumber = unicodedata.normalize('NFKD', id3['tracknumber'][0]).encode( 'ascii', 'ignore') logger.info('title: %s date: %s track: %s lenght: %s' % (title, broadcastDate, episodeNumber, length)) except: traceback.print_exc(file=sys.stdout) print 'died in gather_audio_get_tag_info' return title, broadcastDate, episodeNumber, length
def add_tags(self, filepath: str, track: dict): try: tags = EasyID3(filepath) except ID3NoHeaderError: tags = mutagen.File(filepath, easy=True) tags.add_tags() tags["tracknumber"] = str( track["trackNumber"]).encode("utf-8").decode("utf-8") tags["title"] = track["title"] tags["artist"] = track["artist"] tags["album"] = track["album"] tags["discnumber"] = str( track["discNumber"]).encode("utf-8").decode("utf-8") tags["genre"] = track["genre"] tags["composer"] = track["composer"] tags["albumartist"] = track["albumArtist"] if "beatsPerMinute" in track and not track["beatsPerMinute"] == 0: tags["bpm"] = str( track["beatsPerMinute"]).encode("utf-8").decode("utf-8") # TODO store Year. will have to use standard ID3 instead of easy tags.save(v2_version=3)
def get_tags(fname): m = extre.search(fname) if m is None: raise ValueError('Unknown file type.') ext = m.group(1).lower() tags = {} if ext == 'mp3': try: info = EasyID3(fname) tags = list(info.iteritems()) except ID3NoHeaderError: raise ValueError('No ID3 tags.') elif ext == 'ogg': info = OggVorbis(fname) tags = list(info.iteritems()) elif ext == 'flac': info = FLAC(fname) tags = list(info.iteritems()) elif ext == 'm4a': info = EasyMP4(fname) tags = list(info.iteritems()) return tags
def generate_music(self): if 'attachments' in self.post: log.info('[AP] Извлечение аудио...') log.info('[AP] Данная функция находится в стадии тестирования.') session.http.cookies.update(dict(remixmdevice=self.remixmdevice)) for attachment in self.post['attachments']: if attachment['type'] == 'audio': n = 0 post_url = 'https://m.vk.com/wall%(owner_id)s_%(id)s' % self.post soup = BeautifulSoup( session.http.get(post_url).text, 'html.parser') track_list = [ decode_audio_url(track.get('value'), api_vk.users.get()[0]['id']) for track in soup.find_all(type='hidden') if 'mp3' in track.get('value') ] dur_list = [ dur.get('data-dur') for dur in soup.find_all('div') if dur.get('data-dur') ] name = sub( r"[/\"?:|<>*]", '', attachment['audio']['artist'] + ' - ' + attachment['audio']['title'] + '.mp3') try: file = download(track_list[n], out=name) except urllib.error.URLError: continue try: music = EasyID3(file) except id3.ID3NoHeaderError: music = File(file, easy=True) music.add_tags() music['title'] = attachment['audio']['title'] music['artist'] = attachment['audio']['artist'] music.save() del music self.tracks.append((name, dur_list[n])) n += 1
def insertIntoDB(self, songlist): ' Insert these songs into the database ' for song in songlist: audio = MP3(song) id3 = EasyID3(song) ' Check artist, title and album for this song ' try: artist = str(id3['artist'][0]) except KeyError: artist = None try: title = str(id3['title'][0]) except KeyError: title = None try: album = str(id3['album'][0]) except KeyError: album = None ' Check length and bitrate of the song ' length = audio.info.length bitrate = audio.info.bitrate self.insertSong(artist, title, album, song, length, bitrate)
def iterate_in_folder(path): ln = 0 num = 0 for item in os.listdir(path): if S_ISDIR(os.stat(os.path.join(path, item))[ST_MODE]): iterate_in_folder(os.path.join(path, item)) elif item.endswith("mp3"): audio = MP3(os.path.join(path, item)) print(str(item) + " " + str(audio.info.length)) try: mp3 = MP3(os.path.join(path, item)) mp3.delete() mp3.save() audio = EasyID3(os.path.join(path, item)) audio["artist"] = item[:item.index("-") - 1] audio['genre'] = '' audio['title'] = item[:item.index(".mp3")] audio['date'] = '' audio['album'] = '' audio.save(v2_version=3) except ValueError: print('error occured')
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()) # ! 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) audioFile.save(v2_version=3)
def c_record_audio(self, ): """docstring for c_asset_audio""" #raise Exception([self.cleaned_data['asset_contenttype'], self.cleaned_data['asset_contenttypesub'] ]) keys_to_extract = ['artist', 'title', 'length'] if self.cleaned_data[ 'record_contenttype'] == 'audio' and self.cleaned_data[ 'record_contenttypesub'] not in Audio.FILE_TYPES: msg = u'Invalid audio type. Audio file should be in mp3 format.' self._errors['audio'] = self.error_class([msg]) raise forms.ValidationError(msg) if self.cleaned_data['record_contenttypesub'] in Audio.FILE_TYPES: self.cleaned_data['length'] = 10 from mutagen.easyid3 import EasyID3 audio = self.cleaned_data['audio'] song = EasyID3(audio.temporary_file_path()) if not song: msg = u'Could not upload the audio file you submitted' self._errors['audio'] = self.error_class([msg]) raise forms.ValidationError(msg) if not song.has_key('artist') or not song.has_key('title'): msg = u'Song should have following at least following tags: title, artist, length' self._errors['audio'] = self.error_class([msg]) raise forms.ValidationError(msg) from mutagen.mp3 import MP3 au = MP3(audio.temporary_file_path()) #### to extract artist:au['TPE1'].text[0], title: au['TIT2'].text[0], album: au['TALB'].text[0] if au.info.length: self.cleaned_data['length'] = au.info.length else: self.cleaned_data['length'] = 10000 msg = u'Could not get the length of the song. Please edit your song tags' self._errors['audio'] = self.error_class([msg]) raise forms.ValidationError(msg) return True
def EditFile(self, mp3File, force=False): ''' return true to process the next file, False to quit. ''' try: self.meta = fileDestination.Metadata(EasyID3(mp3File)) except mutagen.id3.ID3NoHeaderError: f = mutagen.File(mp3File, easy=True) f.add_tags() self.meta = fileDestination.Metadata(f) # if self.args is not empty, pass along any settings that we # were given from the command line: for attr, val in self.args.items(): self.meta[attr] = val if force: self.meta.Save() return True while 1: print "\n" # print as much of the path & file as we can without wrapping. print mp3File[-80:] print metadataFormat.format(self.meta) choice = GetInput("Enter item to edit [0 = next, q = quit]: ", str, "0") if "0" == choice: self.meta.Save() return True elif "q" == choice.lower(): self.meta.Save() return False else: # reset to zero-based so we can index into the list of attributes. try: choice = int(choice) - 1 field = kFields[choice] self.EditAttribute(*field) except (IndexError, ValueError): continue
def change_tags(root, file): audio = EasyID3(file) try: # ['tracknumber'] returns list with a string in format # 'track/total' i.e. '01/16' track = audio['tracknumber'][0].split('/')[0] except KeyError: track = '00' no_tracks.append((root, file)) if len(track) == 1: track = '0' + track title = audio['title'][0] period_loc = file.rfind('.') extension = file[period_loc + 1:] new_title = ' '.join([track, title]) if len(new_title) + 7 > 260: # 260 is max length allowed for Windows files last_space = new_title.rfind('.') new_title = new_title[:last_space] new_title = new_title.replace('"', "'") new_title = re.sub(r'[\/:*?<>|]', '_', new_title) new_title = '.'.join([new_title, extension]) try: print(new_title) except UnicodeEncodeError: print("can't be printed") if new_title != file: try: os.rename(file, new_title) except FileExistsError: duplicates.append((root, file)) os.remove(root + "\\" + file)
def update_metadata(self, file_path=None): if file_path == None: file_path = self.file_name # Too lazy to read the spec, more efficient just to use ID3 to do # textual metadata and album art, but ¯\_(ツ)_/¯ audio = EasyID3(file_path) audio['title'] = self.title audio['album'] = self.album audio['tracknumber'] = str(self.track_num) audio.save() if self.coverfile: audio = ID3(file_path) with open(self.coverfile, 'rb') as f: audio['APIC'] = APIC( encoding=3, # 3 is for utf-8 mime='image/jpeg', # image/jpeg or image/png type=3, # 3 is for the cover image desc=u'Cover', data=f.read() ) audio.save()
def get_meta(file_path): local_meta = {} audio = EasyID3(file_path) for key in __get_all_keys(): if key == 'audio': local_meta[key] = audio elif key == 'path': local_meta[key] = file_path elif key == 'filename': local_meta[key] = os.path.split(file_path)[1] elif key == 'title': local_meta[key] = __get_audio_meta(audio, key) elif key == 'artist': local_meta[key] = __get_audio_meta(audio, key) elif key == 'album': local_meta[key] = __get_audio_meta(audio, key) elif key == 'performer': local_meta[key] = __get_audio_meta(audio, key) elif key == 'composer': local_meta[key] = __get_audio_meta(audio, key) elif key == 'genre': local_meta[key] = __get_audio_meta(audio, key) return local_meta
def do(self): path = os.path.abspath(Secrets.SONG_DIRECTORY) files = os.listdir(path) for file in files: try: print(file) song = EasyID3(path + "/" + file) response = song genre, exist = Genre.objects.get_or_create( title=response["genre"][0].title()) artist_obj = self.get_artist_id(response['artist'][0], genre) album_obj, exist = Album.objects.get_or_create( album_name=response['album'][0], date=response["date"][0][0:4], artist_id=artist_obj) obj, exist = Song.objects.get_or_create( name=response['title'][0], target=self.upload_file_path(response['title'][0], file), album_id=album_obj) except Exception as e: print(e)
def checkdir(self, path, submit): import os, sys import traceback from mutagen.easyid3 import EasyID3 from traceback import print_exc from mutagen.mp3 import MP3 print "Scanning", path t = [] i=0 for path, dirs, files in os.walk(path): files.sort() for fn in files: if not fn.lower().endswith('.mp3'): continue ffn = os.path.join(path, fn) try: mp3 = MP3(ffn) except KeyboardInterrupt: raise except Exception, err: rep.error(ffn) else: if mp3.tags is None: print "ERROR: No mp3 tags here" else: # print ffn id3 = EasyID3(ffn) if id3: # print id3["title"], id3["artist"] t2 = TrackInfo(i) t2.name = id3["title"] t2.artist = id3["artist"] t2.album = id3["album"] t2.length = mp3.info.length t2.bitrate = mp3.info.bitrate t2.path = ffn t.append(t2) i += 1
def create_info_str(piece, files): info_str = f'"{piece}"' try: # if artist can be read from first file add it to info_str info_str += f' by {EasyID3(files[0])["artist"][0]}' except KeyError: # else just pass pass try: # if album can be read from first file add it to info_str info_str += f' from album "{EasyID3(files[0])["album"][0]}" ' except KeyError: # else just pass pass try: # if length can be read from files sum it up and add it to info_str play_time = 0 for entry in files: play_time += int(EasyID3(entry)["length"][0]) info_str += f' ({get_time_str_from_ms(play_time)})' except KeyError: # else just pass pass return info_str
def read_tags(self): m = EasyID3(self.file_path) self.tag = MusicTag() self.tag.title = self.try_get_tag('title', m) self.tag.album = self.try_get_tag('album', m) self.tag.artist = self.try_get_tag('artist', m) try: self.tag.track = int(self.try_get_tag('tracknumber', m)) except: # try to parse the track number from the file name import re title_re = re.compile("""(?P<number>[0-9]{1,3}) ?-? ?.+\.mp3""") m = title_re.match(self.filename) if m: self.tag.track = int(m.group("number")) else: print("Track number not found in tag") self.tag.generate_hash()
def get_tag(file): """ Returns the id3 tag information for the given file, if possible :param file: File whose id3 information is desired :return: dictionary of the form: {id3 tag : id3 value} """ return_dict = dict() if file.endswith(".mp3"): audio = MP3(file) return_dict["length"] = audio.info.length return_dict["bitrate"] = audio.info.bitrate audio = EasyID3(file) for (key, value) in audio.iteritems(): if len(value) == 1: return_dict[key] = filter(lambda x: x in string.printable, value[0]) else: return_dict[key] = [ filter(lambda x: x in string.printable, localString) for localString in value ] return return_dict
def tag_mp3(source_file, artist, title, url="", album="", year="", comment="", genres=""): try: audio = EasyID3(source_file) except mutagen.id3.ID3NoHeaderError: audio = mutagen.File(source_file, easy=True) audio.add_tags() audio["artist"] = artist audio["title"] = title audio["genre"] = genres audio["website"] = url audio["copyright"] = "Deep South Sounds" audio["album"] = album audio.save(v1=2)
def _get_tags(self, file_path, tag=taglib): tag = tag or mutagen _logger.debug('Scanning file "%s"', file_path) try: song = tag.File(file_path) if not song: raise except: _logger.warning('Error while opening file "%s"', file_path, exc_info=True) return False, {} if tag.__name__ == "taglib": return song, song.tags else: try: song_tags = EasyID3(file_path) or {} except: song_tags = song.tags or {} song_tags = {k.upper(): v for k, v in song_tags.items()} return song, song_tags
def addFiles(self): files, _ = QFileDialog.getOpenFileNames( self, self.tr("Select Music Files"), QDesktopServices.storageLocation(QDesktopServices.MusicLocation), self.tr("Media Files (*.mp3 *.mp4 *.aac)") ) if not files: return for mediafile in files: title = "unknown" artist, album, year = "", "", "" try: tag = EasyID3(mediafile) title = tag['title'][0] artist = tag['artist'][0] album = tag['album'][0] year = tag['date'][0] except: pass titleItem = QTableWidgetItem(title) titleItem.setFlags(titleItem.flags() ^ Qt.ItemIsEditable) artistItem = QTableWidgetItem(artist) artistItem.setFlags(artistItem.flags() ^ Qt.ItemIsEditable) albumItem = QTableWidgetItem(album) albumItem.setFlags(albumItem.flags() ^ Qt.ItemIsEditable) yearItem = QTableWidgetItem(year) yearItem.setFlags(yearItem.flags() ^ Qt.ItemIsEditable) currentRow = self.musicTable.rowCount() self.musicTable.insertRow(currentRow) self.musicTable.setItem(currentRow, 0, titleItem) self.musicTable.setItem(currentRow, 1, artistItem) self.musicTable.setItem(currentRow, 2, albumItem) self.musicTable.setItem(currentRow, 3, yearItem) self.engine.play_list_add(files) self.play_action()
def writeMP3Tags(filename, tags, imageUrl): handle = MP3(filename, ID3=EasyID3) handle.delete() # label is not supported by easyID3, so we add it EasyID3.RegisterTextKey("label", "TPUB") # tracknumber and total tracks is one tag for ID3 tags['tracknumber'] = f'{str(tags["tracknumber"])}/{str(tags["totaltracks"])}' del tags['totaltracks'] for key, val in tags.items(): handle[key] = str(val) handle.save() if imageUrl: image = getCoverArt(imageUrl, filename, 1500) # TODO: write to temp folder? handle= MP3(filename) handle["APIC"] = mutagen.id3.APIC( encoding=3, # 3 is for utf-8 mime='image/png', type=3, # 3 is for the cover image data=image) handle.save() return True
def embed_mp3(music_file, meta_tags): """Embed metadata to MP3 files.""" # EasyID3 is fun to use ;) audiofile = EasyID3(music_file) audiofile['artist'] = meta_tags['artists'][0]['name'] audiofile['albumartist'] = meta_tags['artists'][0]['name'] audiofile['album'] = meta_tags['album']['name'] audiofile['title'] = meta_tags['name'] audiofile['tracknumber'] = [meta_tags['track_number'], meta_tags['total_tracks']] audiofile['discnumber'] = [meta_tags['disc_number'], 0] audiofile['date'] = meta_tags['release_date'] audiofile['originaldate'] = meta_tags['release_date'] audiofile['media'] = meta_tags['type'] audiofile['author'] = meta_tags['artists'][0]['name'] audiofile['lyricist'] = meta_tags['artists'][0]['name'] audiofile['arranger'] = meta_tags['artists'][0]['name'] audiofile['performer'] = meta_tags['artists'][0]['name'] audiofile['website'] = meta_tags['external_urls']['spotify'] audiofile['length'] = str(meta_tags['duration_ms'] / 1000) if meta_tags['publisher']: audiofile['encodedby'] = meta_tags['publisher'] if meta_tags['genre']: audiofile['genre'] = meta_tags['genre'] if meta_tags['copyright']: audiofile['copyright'] = meta_tags['copyright'] if meta_tags['isrc']: audiofile['isrc'] = meta_tags['external_ids']['isrc'] audiofile.save(v2_version=3) audiofile = ID3(music_file) try: albumart = urllib.request.urlopen(meta_tags['album']['images'][0]['url']) audiofile["APIC"] = APIC(encoding=3, mime='image/jpeg', type=3, desc=u'Cover', data=albumart.read()) albumart.close() except IndexError: pass audiofile.save(v2_version=3) return True
def set_tags(filename, title, album_name, artist_name, index, cover): audio = eyed3.load(filename) if (audio.tag == None): audio.initTag() audio.tag.title = title audio.tag.album = album_name audio.tag.artist = artist_name if cover: audio.tag.images.set(3, open(cover, 'rb').read(), 'image/jpeg') audio.tag.save() audio = EasyID3(filename) audio["tracknumber"] = str(index) audio.save()
def updateTags( fullFileName, podName ): id3Tag = None # try open tags, if fails, create new try: id3Tag = EasyID3( fullFileName ) except: id3Tag = mutagen.File( fullFileName, easy = True ) if id3Tag == None: syslog.syslog( syslog.LOG_ERR, "Failed to create id3 tags" ) return id3Tag.add_tags() # extract file name without extension from full file name fileName = os.path.split( fullFileName )[ 1 ] title = os.path.splitext( fileName )[ 0 ] id3Tag[ "title" ] = unicode("{}".format( title ), "utf-8") id3Tag[ "artist" ] = unicode("{}".format( podName ), "utf-8") id3Tag.save()
def GetMetadataFields(f): ''' opens the file named 'f', then returns a dict with values for the following metadata contained in the file: artistalbum title tracknumber genre bitrate date length ''' audio = MP3(f) try: meta = EasyID3(f) except mutagen.id3.ID3NoHeaderError: meta = {} metaDict = {} metaFields = "artist album title tracknumber genre date".split() for field in metaFields: try: metaDict[field] = meta[field][0] except KeyError: metaDict[field] = u"" try: length = MsToMinSec(meta['length'][0]) except KeyError: length = u"--:--" metaDict['length'] = length metaDict['bitrate'] = audio.info.bitrate # the tracknumber value may be in the format 'x/y' -- we only want the 'x' if metaDict['tracknumber']: metaDict['tracknumber'] = GetTrackNumber(metaDict['tracknumber']) return metaDict