def organise(source_file, dest_root): ''' Take the source file and organise by artist/album ''' source_mp3 = MP3File(source_file) artist_dir = source_mp3.artist album_dir = source_mp3.album print(artist_dir) print(album_dir) ' check if sub folder 1 exists and create as necessary ' artist_album_dir = dest_root + SEP + artist_dir + SEP + album_dir if (os.path.isdir(artist_album_dir) == False): os.mkdir(artist_album_dir) ' check if sub folder 2 exists and create as necessary ' fileName = _path_leaf(source_file) dest_mp3 = MP3File(artist_album_dir + SEP + filename) ' write file to dest_root/artist_dir/album_dir' dest_mp3.save()
def setRjBuffer(filePath): rj = getRandomRj() if len(filePath) < 1: speech = 'You are listening to '+streamName + \ '. '+streamDescription + '. I am RJ '+rj[1]+'.' prepareRjBufferMp3(speech, rj) else: mp3 = MP3File(filePath) mp3.set_version(VERSION_2) if filePath.find('music/') > -1: speech = 'You are listening to '+streamName+'. I am RJ ' + \ rj[1]+'. Now, You will listen to ' + \ mp3.song+' by ' + mp3.artist+'.' #print(speech) prepareRjBufferMp3(speech, rj) elif filePath.find('news/news.mp3') > -1: speech = "Hello listeners, Its RJ "+rj[1]+". You are listening to "+streamName+". Now you will listen to the latest bulletin from BBC World Service." prepareRjBufferMp3(speech, rj) elif filePath.find('request/') > -1: speech = 'Hello listeners, Its RJ '+rj[1]+ \ '. You are listening to '+streamName+'. We just recieved a song request from ' + \ filePath.replace(requestPath,'').replace('.mp3','') + ' with love. Now you will listen to ' + \ mp3.song+' by ' + mp3.artist+'.' prepareRjBufferMp3(speech, rj)
def getlist(self): self.musiclist = [] for file in os.listdir("music/"): if file.endswith(".mp3"): musicdata = {} filename = 'music/' + file if os.path.isfile(filename): # Get tags mp3 = MP3File(filename) musicdata['filename'] = filename musicdata['data'] = mp3.get_tags() # Get coverdata file = File(filename) if 'APIC:' in file.tags: coverdata = file.tags['APIC:'].data musicdata['cover'] = pil2cairo( Image.open(io.BytesIO(coverdata)), 128, 128) self.musiclist.append(musicdata) self.shufflelist() return self.musiclist
async def download_track(session, track, progress_queue): output_file = os.path.join( output_directory, track['user']['username'], f"{track['title']}.mp3", ) chunk_size = 2**10 async with session.get(track['stream_url'], params={'client_id': client_id}) as response: target = f"{track['user']['username']} - {track['title']}" size = int(response.headers.get('content-length', 0)) or None position = await progress_queue.get() progress_bar = tqdm.tqdm( desc=target, total=size, position=position, leave=False, unit='iB', ascii=True, unit_scale=True, ) with open(output_file, 'wb+') as f: async for chunk in response.content.iter_chunked(chunk_size): f.write(chunk) progress_bar.update(len(chunk)) mp3 = MP3File(output_file) mp3.set_version(VERSION_BOTH) mp3.song = track['title'] mp3.artist = track['user']['username'] mp3.track = f"{track['track_num']}" mp3.album = 'Soundcloud' mp3.save() await progress_queue.put(position)
def getMeta(fileName): audio = MP3(fileName) print(fileName) fileDets = {} if os.path.exists(fileName): mp3 = MP3File(fileName) try: tags = mp3.get_tags()["ID3TagV2"] for value in attrKeys.values(): fileDets[value] = tags[value.lower()] print(tags[value.lower()]) fileDets["Title"] = tags["song"] fileDets["Summary"] = tags["song"] fileDets["Summary"] = tags["song"] fileDets["Authors"] = tags["artist"] fileDets["Duration"] = audio.info.length fileDets["Size"] = audio.info.length fileDets["PubDate"] = None except: fileDets["Album"] = "The Dragon Reborn" fileDets["Title"] = "" fileDets["Summary"] = "" fileDets["Summary"] = "" fileDets["Authors"] = "Wheel of Time" fileDets["Duration"] = audio.info.length fileDets["Size"] = None fileDets["PubDate"] = None return fileDets
def get_ID3v2_tags(mp3_file): """ Extract ID3v2 tags (artist, album, song) from *.mp3. If ID3v2 tags missing or not file permissions equate (artist=None, album=None, song=None). :param mp3_file: some *.mp3 :return: namedtuple(artist, album, song) """ try: audio = MP3File(mp3_file).get_tags().get('ID3TagV2') except AttributeError: audio = None except PermissionError: audio = None tags_mp3 = namedtuple('Tags', 'artist album song') tags = None if not audio: tags = tags_mp3(None, None, None) else: try: artist = del_system_char(audio.get('artist').strip()) except AttributeError: artist = None try: album = del_system_char(audio.get('album').strip()) except AttributeError: album = None try: song = del_system_char(audio.get('song').strip()) except AttributeError: song = None if artist and album and song: tags = tags_mp3(artist, album, song) return tags
def dict_fill_from_bulk_mp3s(dict_input, mp3_location): for song in os.listdir(mp3_location): print('Currently processing dictionary fill for: ' + song) if song.endswith(".mp3"): # Defining starting file location of MP3 song_location = mp3_location + '\\' + song song_start = MP3File(song_location) song_start.set_version(VERSION_2) # Getting artist name and album name from MP3 tags artist_name = song_start.artist album_name = song_start.album else: print('This file is not an MP3! Moving on...') continue if artist_name == [] or album_name == []: print('This MP3 is missing necessary tags! Moving on...') continue # Otherwise goes on to add dictionary entries if artist or album is unique else: artist_check = False # Resets variable that keeps track of whether artist entry already exists # Checks to see if this artist already exists in the dictionary for entry in dict_input: if similar(entry, artist_name) > 0.85: print('There is already a dictionary entry for this artist.') artist_check = True # Variable is updated to represent artist being redundant for this song artist_name = entry break # If the artist entry already exists then... if artist_check: # Checks to see if the album for this artist already exists in the dictionary as well for entry in dict_input[artist_name]: if similar(entry, album_name) > 0.85: print("There is already a dictionary entry for this artist's album. Moving on...") break # If none of the album names are redundant, a new album name entry is created album_name = sanitize(album_name) dict_input[artist_name].append(album_name) print('A new album entry has been created for this artist in the dictionary. Moving on...') # If neither artist entry or album entry exists, this creates both of them else: artist_name = sanitize(artist_name) album_name = sanitize(album_name) dict_input[artist_name] = [album_name] print('A new artist entry with a corresponding album has been created in the dictionary. Moving on...') return dict_input
def myFun(fileName): audFetch = r"C:\Users\Dharmik\Desktop\New\songs\\" + fileName mp3 = MP3File(audFetch) mp3.set_version(VERSION_2) s = mp3.song y = mp3.year a = mp3.artist g = mp3.genre for i in s: if (i == "("): ind = s.index(i) s = s[0:ind] break elif (i == "["): ind = s.index(i) s = s[0:ind] re.sub('[^A-Za-z0-9]+', '', s) print("Song", s) os.rename(audFetch, r"C:\Users\Dharmik\Desktop\New\songs\\" + s + ".mp3") show_info(s, a, g, y)
def import_song(self, path): ext = os.path.splitext(path)[-1].lower() if ext == ".mp3": try: mp3 = MP3File(path) try: tags = mp3.get_tags() except Exception: pass else: song_dict = dict(path=path) try: Song.objects.get(**song_dict) except Song.DoesNotExist: for tag_key, tag_dict in tags.items(): for song_key in ID3_FIELDS: if not song_dict.get(song_key): song_dict.update({song_key: tag_dict.get(song_key)}) try: Song.objects.create(**song_dict) except Exception: pass except Exception: pass
def get_track_features(token): ''' Function that retrieves track features for songs in database. :param token: Oath token of spotify :return: Dict of dicts that contains the features for all songs. ''' # Hardcoded names of directories that contain the songs. folders = ["classical", "rock", "pop", "electronic"] song_info = {folder: {} for folder in folders} # Retrieve song and artist from mp3 file. Loop over all 100 songs per dir. for folder in folders: for index in range(1, 101): mp3 = MP3File("./../../../songs/" + folder + "/" + str(index) + ".mp3") mp3.set_version(VERSION_2) # Retrieve song information from spotify id, song_name = get_track_id(mp3.song, mp3.artist, token) if (id != None): # put audio features in dict. audio_features = add_audio_features(id, token) audio_features["name"] = song_name song_info[folder][str(index)] = audio_features # this sleep prevents the api from being queried too often. sleep(0.10) return song_info
def filter_duplicates(extension, types, path, fileList, size): if extension in types: mp3 = MP3File(path) tags = "empty" try: tags = mp3.get_tags() except UnicodeDecodeError as err: click.echo("\nError retreiving tags, file: {} - error: {}".format( path, err.reason)) except: click.echo("\nBad MP3 tags , file: {}".format(path)) for i in range(9): suffix = "({})".format(i) suffix2 = "_{}.".format(i) if suffix in path or suffix2 in path: track = "empty" name = "empty" if tags['ID3TagV2'] and tags['ID3TagV2']['track']: track = tags['ID3TagV2']['track'] if tags['ID3TagV2'] and tags['ID3TagV2']['song']: name = tags['ID3TagV2']['song'] DUPLICATES.onemore() fileList.append({ "path": path, "size": size, "track": track, "name": name })
def main(): parser = argparse.ArgumentParser() parser.add_argument('directory', help='System path to directory containing files.') parser.add_argument('--rename_files', help='Use this if you want to rename files. \ Useful only if the files haven\'t already been manually renamed.', action='store_true') parser.add_argument('--correct_key_comment', help='Use this if you want to remove the `/` between \ keys added by MixedInKey, and add `N/A` if no key was added (i.e. file was too long).', action='store_true') args = parser.parse_args() correct_key_comment = args.correct_key_comment directory = args.directory rename_files = args.rename_files # First, rename the files themselves to get rid of Album and Track number) if that option was passed: if rename_files: file_list = get_file_list(directory) for file in file_list: rename_file(file, directory) # Next, re-read the files with their new names and update the ID3 tags: file_list = get_file_list(directory) for file in file_list: print(f"Scrubbing ID3 tags for `{file}`.") artist, song = get_info_from_filename(file) file = MP3File(directory + file) delete_unnecessary_tags(file, correct_key_comment) set_necessary_tags(file, artist, song) # Correct the key written to the comment tag if MixedInKey has already been run. if correct_key_comment: correct_comment_tag(file) exit()
def main(): args = def_params() bas_dir = os.path.dirname(os.path.realpath(__file__)) logging.debug("parametry:" + str(args)) mp3 = MP3File(args.file) mp3.set_version(VERSION_1) logging.debug("parametry:" + str(args)) if args.album is not None: mp3.album = args.album if args.artist is not None: mp3.artist = args.artist if args.song is not None: mp3.song = args.song if args.track is not None: # track powinno być number nie literal ! mp3.track = args.track if args.comment is not None: mp3.comment = args.comment else: mp3.comment = "" if args.genre is not None: mp3.genre = args.genre #to jest enum de facto - przyjmijmy że wpisujemy 0 if args.year is not None: mp3.year = args.year mp3.save() pprint(mp3.get_tags())
def get_song_info(self): audio_path = self.fileName try: msg = QMessageBox() fullText = '<table class="tftable" border="0">' try: mp3 = MP3File(audio_path()) tags = mp3.get_tags() self.tags = tags for k, v in tags.items(): for i, t in v.items(): fullText = fullText + '<tr><td>' + str(i) + '</td><td>' + str(t) + '</td></tr>' fullText = fullText + '</table>' msg = QMessageBox() msg.setText(fullText) except TypeError: fullText = fullText + '<tr><td>' + "Lütfen bir şarkı seçiniz!" + '</td><td>' + "" + '</td></tr>' fullText = fullText + '</table>' msg.setText(fullText) msg.about(self, "Title", fullText) except MP3OpenFileError: msg.setIcon(QMessageBox.Information) msg = "Audio file cannot be read" msg.setText("Audio file cannot be read") msg.about(self, "Title", msg) print("Audio file cannot be read")
def write_mp3_tags(fout,targetdir): total_number_of_mp3 = do_initial_scan_for_mp3s(targetdir) current_time = time.time() count = 0 print("Writing out mp3 tags now") f = open(fout,"w+") f_errors = open(fout+".err","w+") f.write('|'.join(tags)+"\n") for root,dirs, files in os.walk(targetdir,topdown=False): for name in files: try: mp3 = MP3File(os.path.join(root,name)) except: continue data = [] for tag in tags: if tag != "filePath": try: data.append(str(mp3.get_tags()['ID3TagV1'][tag])) except: data.append('Not Assigned') data.append(os.path.join(root,name)) #try: f.write('|'.join(data)+"\n") except: f_errors.write(os.path.join(root,name) + "\n")
def searchMusicFile(songName, artistName): global numGenre global path_genre artistName = artistName.lower() songName = songName.lower() g = 0 while g < numGenre: mus_list = os.listdir(path_genre[g]) l = len(mus_list) i = 0 while i < l: mp3 = MP3File(path_genre[g]+mus_list[i]) mp3.set_version(VERSION_2) art = mp3.artist.lower() son = mp3.song.lower() if art == artistName and son == songName: return (path_genre[g] + mus_list[i]) i = i + 1 g = g + 1 return ""
def download(mode, url, num): print(f"Downloading for {mode}") #Options ydl_opts = { 'format': 'bestaudio/best', 'postprocessors': [{ 'key': 'FFmpegExtractAudio', 'preferredcodec': 'mp3', 'preferredquality': '320', }], 'logger': MyLogger(), 'progress_hooks': [my_hook], 'outtmpl': folders[num][mode][0] + '/%(title)s.%(ext)s' } #Download the video and extract all the metadata with youtube_dl.YoutubeDL(ydl_opts) as ydl: info_dict = ydl.extract_info(url, download=True) video_title = info_dict.get('title', None) video_filename = '.'.join( ydl.prepare_filename(info_dict).split('.')[:-1]) + '.mp3' print(video_filename) #Edit mp3 tag. try: print(f"Editing artist tag to {mode.capitalize()}...") mp3 = MP3File(video_filename) mp3.artist = mode.title() mp3.save() insert_album_art(video_filename, info_dict['id']) print("Done!\n") except Exception as e: print("Error at editing mp3 tag.\n") print(e) #Backup if num != 3: try: print(f"Making a backup of {video_title}...") copy(video_filename, folders[num][mode][1]) print("Done!\n") except: print("Error at doing backup.\n") #Upload to google if num != 3: try: print(f"Uploading {video_title} to Google Music\n") print(f'With url {url}') mm = Musicmanager() mm.login(uploader_id='D0:50:99:83:B0:0C') mm.upload(video_filename) print("Done!\n") except Exception as e: print("Error at uploading the song to google:\n" + e)
def get_mp3_tags(file): from mp3_tagger import MP3File if util.get_file_extension(file).lower() != 'mp3': raise FileTypeError('File %s is not an mp3 file') # Create MP3File instance. mp3 = MP3File(file) return {'artist' : mp3.artist, 'author' : mp3.artist, 'song' : mp3.song, 'title' : mp3.song, \ 'album' : mp3.album, 'year' : mp3.year, 'track' : mp3.track, 'genre' : mp3.genre, 'comment' : mp3.comment}
def main(): print("Welcome to AutoTag") time.sleep(1) print("\nBefore using, please back up your music folder") time.sleep(4) print("PLEASE NOTE: ANY NON-AUDIO FILES WILL BE DELETED\n") time.sleep(2) print("MP3 files will be automatically tagged") print("Directories that cannot be tagged will be listed in 'Untagged.txt'") rootPath = os.path.dirname(os.path.realpath(__file__)) flacList = [] dirList = listDirectories() for folder in dirList: trackList, flacList = getFiles(folder, rootPath, flacList) if folder in flacList: continue trackList.sort() mp3 = MP3File(os.path.join(rootPath, folder, trackList[0])) mp3.set_version(VERSION_2) tags = mp3.get_tags() genre = getGenre(folder, tags) year = getYear(folder, tags) for track in trackList: mp3 = MP3File(os.path.join(rootPath, folder, track)) mp3.set_version(VERSION_2) tags = mp3.get_tags() skipFolder = trackTagger(tags, genre, year, folder, mp3, track) if skipFolder: successRate['Fail'] += 1 break trackList, flacList = getFiles(folder, rootPath, flacList) mp3 = MP3File(os.path.join(rootPath, folder, trackList[0])) mp3.set_version(VERSION_2) tags = mp3.get_tags() os.chdir("..") try: os.rename(folder, tags['artist'] + ' - ' + tags['album']) except ValueError as e: if folder not in untagged: untagged.append(" " + folder) successRate['Fail'] += 1 continue if folder not in untagged: successRate['Pass'] += 1 printUntagged()
def _fill_tags(self): mp3 = MP3File(os.path.join(self.download_path, f"{self}.mp3")) mp3.set_version(VERSION_BOTH) mp3.artist = self.author mp3.album = self.album mp3.song = self.name if self.track is not None: mp3.track = str(self.track) mp3.save()
def tag(file, artist="", track="", album=""): mp3 = MP3File(file) if artist: mp3.artist = artist if track: mp3.track = track if album: mp3.album = album mp3.save()
def process(file): print(file) mp3 = MP3File(file) parts = file.split('/') mp3.set_version(VERSION_2) mp3.genre = parts[0] mp3.artist = parts[1] mp3.album = parts[2] mp3.song = parts[3]
def changeMetaTags(newPath, songPath, artist, album): try: mp3 = MP3File(newPath) mp3.artist = artist mp3.album = album mp3.save() os.remove(songPath) except Exception as e: print(e) pass
def main(): parser = argparse.ArgumentParser() parser.add_argument('path', help='System path to file.') args = parser.parse_args() path = args.path # Create MP3File instance. mp3 = MP3File(path) tags = mp3.get_tags() print(json.dumps(tags, indent=2, default=str)) exit()
def fix_specific(filepath): print("Fixing genre for specific song...") mp3 = MP3File(filepath.replace("\\", "")) mp3.set_version(VERSION_2) old_genre = str(mp3.genre) print("Genre to fix: " + old_genre) new_genre = input("Enter new genre: ") mp3.genre = new_genre mp3.save() print("Fixed!")
def __init__(self, path): super(Mp3Info, self).__init__(path) mp3 = MP3File(self.path) tags = mp3.get_tags() for tag_version, tag_dict in tags.items(): for attr_name in self.attrib_list: if not getattr(self, attr_name): setattr(self, attr_name, tag_dict.get(attr_name, None))
def writeTags(self, path): mp3 = MP3File(path) mp3.song = self.data['title'] mp3.track = self.data['number'] if self.album: mp3.artist = self.album.data['artist'] mp3.album = self.album.data['title'] mp3.year = self.album.data['year'] mp3.save()
def salvaID3(self, artista, album, titulo, musicaatual): try: mp3 = MP3File(musicaatual) mp3.artist = artista mp3.song = titulo mp3.album = album print(artista + ' - ' + album + ' ' + ' ' + titulo) mp3.save() except Exception as inst: print(type(inst)) print(artista + ' - ' + album + ' ' + ' ' + titulo)
def on_done(filename): self.adapter.bot.sendChatAction(chat_id=chat_id, action=ChatAction.UPLOAD_AUDIO) mp3 = MP3File(filename) mp3.song = track_name mp3.artist = artists mp3.set_version(VERSION_BOTH) mp3.save() with open(filename, 'rb') as fp: self.adapter.bot.sendAudio(chat_id=chat_id, audio=fp, timeout=60)
def pegaTagsID3(self, musicaatual): try: print("entrando na pegatagsid3 " + musicaatual) mp3 = MP3File(musicaatual) tags = mp3.get_tags() return tags except: print("erro") # tag = mutagen.File(listofsongs[index], easy=True) # tag.add_tags()