def fix_music(): ''' Searches for '.mp3' files in directory and checks whether they already contain album art and album name tags or not. ''' files = [f for f in listdir('.') if f[-4:] == '.mp3'] for file_name in files: tags = File(file_name) if 'APIC:Cover' in tags.keys() and 'TALB' in tags.keys( ): #Checks whether there is album art and album name print("%s already has tags " % tags["TIT2"]) elif not ('APIC:Cover' in tags.keys()) and 'TALB' in tags.keys(): album = tags["TALB"].text[0] print("........................\n") print("%s Adding metadata" % file_name) try: albumart = albumsearch.img_search_google(album) except Exception: albumart = albumsearch.img_search_bing(album) add_albumart(albumart, file_name) else: print("........................\n") print("%s Adding metadata" % file_name) try: artist, album, song_name, lyrics, match_bool, score = get_details_spotify( file_name) # Try finding details through spotify except Exception: artist, album, song_name, lyrics, match_bool, score = get_details_letssingit( file_name) # Use bad scraping method as last resort try: print('*Trying to extract album art from Google.com') albumart = albumsearch.img_search_google(album) except Exception: print('*Trying to extract album art from Bing.com') albumart = albumsearch.img_search_bing(album) if match_bool: add_albumart(albumart, file_name) add_details(file_name, song_name, artist, album, lyrics) else: print("*Couldn't find appropriate details of your song") with open("musicrepair_log.txt", "a") as problems: problems.write(str(file_name) + '\n') #log song that couldn't be repaired print("\nMatch score : %s%s" % (round(score * 10, 1), "/10.0")) print("........................\n\n")
def getSongInfo(inputFile): info = {} # detect format and type of tags file = File(inputFile) """ if 'APIC:' in file.keys(): artwork = file.tags['APIC:'].data # access APIC frame and grab the image with open('./image.jpg', 'wb') as img: img.write(artwork) # write artwork to new image """ # check for album art existence if "APIC:" in file.keys(): artwork = file.tags["APIC:"].data # access APIC frame and grab the image # extract image info["image"] = artwork # extract title info["title"] = str(file["TIT2"][0]) # extract artist info["artist"] = str(file["TPE1"][0]) # extract album info["album"] = str(file["TALB"][0]) if "TDRC" in file.keys(): # extract year info["year"] = str(file["TDRC"][0]) if "TCON" in file.keys(): # extract genre info["genre"] = str(file["TCON"][0]) if "TPUB" in file.keys(): # extract publisher info["publisher"] = str(file["TPUB"][0]) # extract length / duration info["length"] = str(round(file.info.length / 60, 2)) return info
def fix_music(rename_format, norename, files): """ Checks whether files already contain album art and album name tags or not. If not, calls other functions to add album art, details. """ for file_path in files: tags = File(file_path) #Gets file name and removes .mp3 for better search results file_name = basename(file_path)[:-4] # Checks whether there is album art and album name if 'APIC:Cover' in tags.keys() and 'TALB' in tags.keys(): log.log('%s already has tags ' % tags["TIT2"]) elif not ('APIC:Cover' in tags.keys()) and 'TALB' in tags.keys(): album = tags["TALB"].text[0] log.log(LOG_LINE_SEPERATOR) log.log(file_path) log.log('> Adding metadata') add_albumart(album, file_path) else: log.log(LOG_LINE_SEPERATOR) log.log(file_path) log.log('> Adding metadata') try: artist, album, song_name, lyrics = get_details_spotify( file_name) add_albumart(artist + ' ' + album, file_path) add_details(file_path, song_name, artist, album, lyrics) except Exception: log.log_error("* Couldn't find metadata from Spotify") try: if not norename: song_title = rename_format.format(title=song_name + '-', artist=artist + '-', album=album + '-') song_title = song_title[:-1] if song_title.endswith( '-') else song_title rename( file_path, path.dirname(file_path) + '/{song_title}.mp3'.format(song_title=song_title)) except Exception: pass
def fix_cover(audio: File): """ Transfers album cover from audio key APIC:XXXX to APIC: Example audio['APIC: Payday 2.jpg'] = APIC() becomes audio['APIC:'] = APIC() """ restart = False for k in audio.keys(): if k.startswith('APIC:') and k != 'APIC:': apic = audio.pop(k) apic.desc = '' apic.encoding = 0 audio['APIC:'] = apic audio.save() restart = True break elif k == 'APIC:' and audio[k].encoding != 0: apic = audio.pop(k) apic.desc = '' apic.encoding = 0 audio[k] = apic audio.save() restart = True break if restart: fix_cover(audio)
def cleanup_tags(self) -> None: '''Delete any ReplayGain tags from track. This dicards any unsaved changes, then modifies and saves the track's tags on disk and then reloads the new tags from disk. ''' tags_to_clean = set(rg_tags) # type: Set[str] tags_to_clean.update('QuodLibet::' + tag for tag in rg_tags) tags_to_clean.update('TXXX:' + tag for tag in rg_tags) tags_to_clean.update(['RVA2:track', 'RVA2:album']) tags_to_clean = { tag.lower() for tag in tags_to_clean } # Need a non-easy interface for proper ID3 cleanup t = MusicFile(self.filename, easy=False) tags_to_delete = [] for k in t.keys(): if k.lower() in tags_to_clean: tags_to_delete.append(k) for k in tags_to_delete: logger.debug("Deleting tag: %s", repr(k)) del t[k] t.save() # Re-init to pick up tag changes new_track = type(self.track)(self.filename) self.track = new_track
def updatemusic(): db = model() musiclist = glob.glob(MUSICFOLDER + "*.mp3") musicnames = [mi.split("/")[-1] for mi in musiclist] indb = [ msi.arquivo for msi in db().iterselect(db.musica.arquivo) if msi.arquivo in musicnames ] notindb = list(set(musicnames) - set(indb)) for msi in notindb: tag = File(MUSICFOLDER + msi) tempo = sec2minString(File(MUSICFOLDER + msi).info.length) if ('TIT2' in tag.keys()): db.musica.insert(nome=tag['TIT2'].text[0], cantor=tag['TPE1'].text[0], arquivo=msi, tempo=tempo) else: db.musica.insert(arquivo=msi, tempo=tempo) notindir = [ msi.arquivo for msi in db().iterselect(db.musica.arquivo) if msi.arquivo not in musicnames ] for msi in notindir: db(db.musica.arquivo == msi).delete() db.commit()
def fix_music(rename_format, norename, files): """ Checks whether files already contain album art and album name tags or not. If not, calls other functions to add album art, details. """ for file_path in files: tags = File(file_path) # Gets file name and removes .mp3 for better search results file_name = basename(file_path)[:-4] # Checks whether there is album art and album name if 'APIC:Cover' in tags.keys() and 'TALB' in tags.keys(): print('%s already has tags' % tags["TIT2"]) else: print('> ' + file_path) try: artist, album, song_name, albumart = musictools.get_metadata( file_name, SPOTIFY_CLIENT_ID, SPOTIFY_CLIENT_SECRET) add_lyrics_genius(file_path, file_name) musictools.add_album_art(file_path, albumart) musictools.add_metadata(file_path, song_name, artist, album) except Exception as e: # MetadataNotFound print(e) song_name = file_name album = "Unknown" artist = "Unknown" print('Could not find metadata') print('{}\n{}\n{}\n'.format(song_name, album, artist)) if not norename: song_title = rename_format.format(title=song_name + ' -', artist=artist + ' -', album=album + ' -') song_title = song_title[:-1] if song_title.endswith( '-') else song_title new_path = path.dirname(file_path) + '{}.mp3'.format( song_title) rename(file_path, new_path)
def from_tags(path: str) -> Optional[bytes]: """Get an album cover from a file's meta tags.""" file = File(path) for tag in file.keys(): if tag.startswith("APIC:"): return file.tags[tag].data return None
def fix_cover(audio: File): """ Transfers album cover from audio key APIC:XXXX to APIC: Example audio['APIC: Payday 2.jpg'] = APIC() becomes audio['APIC:'] = APIC() """ for k in audio.keys(): if k.startswith('APIC:') and k != 'APIC:': audio['APIC:'] = audio.pop(k) audio.save() break
def fix_music(): ''' Searches for '.mp3' files in directory and checks whether they already contain album art and album name tags or not. ''' files = [f for f in listdir(music_dir) if f[-4:] == '.mp3'] for file_name in files: tags = File(file_name) if 'APIC:Cover' in tags.keys() and 'TALB' in tags.keys(): print("%s already has tags " % tags["TIT2"]) elif not('APIC:Cover' in tags.keys()) and 'TALB' in tags.keys(): album = tags["TALB"].text[0] print("........................\n") print("%s Adding metadata" % file_name) albumart = get_albumart(album) add_albumart(albumart, file_name) else: print("........................\n") print("%s Adding metadata" % file_name) try: artist, album, song_name, lyrics = get_details_spotify( file_name) # Try finding details through spotify except TypeError: artist, album, song_name, lyrics = get_details_letssingit( file_name) # Use bad scraping method as last resort albumart = get_albumart(album) add_albumart(albumart, file_name) add_details(file_name, song_name, artist, album, lyrics)
def get_cover_art(song): if song.path == 'None': return None file = File(song.path) APIC = None for key in file.keys(): if 'APIC:' in key: APIC = key if APIC is None: return None artwork = file.tags[APIC].data return artwork
def unique_id(filename): f = File(filename) if 'APIC:' in f: del f['APIC:'] if 'COMM::XXX' in f: del f['COMM::XXX'] keys = list(f.keys()) keys.sort() value = '' for k in keys: v = [str(i) for i in f[k].text] v.sort() value = value + '%s;' % (','.join(v)) value = base64.b64encode(value.encode()).decode() return value
def getSongInfo(inputFile): info = {} # detect format and type of tags file = File(inputFile) ''' if 'APIC:' in file.keys(): artwork = file.tags['APIC:'].data # access APIC frame and grab the image with open('./image.jpg', 'wb') as img: img.write(artwork) # write artwork to new image ''' # check for album art existence if 'APIC:' in file.keys(): artwork = file.tags[ 'APIC:'].data # access APIC frame and grab the image # extract image info['image'] = artwork # extract title info['title'] = str(file['TIT2'][0]) # extract artist info['artist'] = str(file['TPE1'][0]) # extract album info['album'] = str(file['TALB'][0]) if 'TDRC' in file.keys(): # extract year info['year'] = str(file['TDRC'][0]) if 'TCON' in file.keys(): # extract genre info['genre'] = str(file['TCON'][0]) if 'TPUB' in file.keys(): # extract publisher info['publisher'] = str(file['TPUB'][0]) # extract length / duration info['length'] = str(round(file.info.length / 60, 2)) return info
def home(): musiclist = glob.glob("static/musics/*.mp3") musicJ = [{"fileName": mi.split("/")[-1], "coverURL": url_for('coverImage', music=mi), "fileURL": url_for('sounds', music=mi), "length": sec2minString(File(mi).info.length), "Tags": None } for mi in musiclist] for i in range(len(musicJ)): tag = File(musiclist[i]) if('TIT2' in tag.keys()): musicJ[i]['tags'] = {'TIT2': tag['TIT2'].text[0], 'TPE1':tag['TPE1'].text[0]} return render_template("home.html", musicJ=musicJ)
def get_file_metadata(self): """ Return current file metadata. Valid only for modes: audio files and collection :return: dictionary with metadata """ meta = {} mode = self.config[CURRENT][MODE] if mode == AUDIO_FILES: folder = self.config[FILE_PLAYBACK][CURRENT_FOLDER] filename = self.config[FILE_PLAYBACK][CURRENT_FILE] elif mode == COLLECTION: folder = self.config[COLLECTION_PLAYBACK][COLLECTION_FOLDER] filename = self.config[COLLECTION_PLAYBACK][COLLECTION_FILE] else: return meta path = os.path.join(folder, filename) if not path: return meta meta["filename"] = filename try: filesize = os.stat(path).st_size meta["filesize"] = filesize m = File(path) for i in INFO: meta[i] = getattr(m.info, i, None) if filename.lower().endswith(EXT_MP4) or filename.lower().endswith( EXT_M4A): metadata = MP4_METADATA else: metadata = METADATA for i, key in enumerate(metadata): if key not in m.keys() or len(m[key][0].replace( " ", "").strip()) == 0: v = None else: v = m[key][0].strip() meta[METADATA[i]] = v except Exception as e: logging.debug(e) return meta
def home(): musiclist = glob.glob('static/musics/*.mp3') musicJ = [{ 'fileName': mi.split("/")[-1], 'coverUrl': url_for('coverImage', music=mi), 'fileUrl': url_for('sounds', music=mi), 'length': sec2minstring(File(mi).info.length), 'Tags': None } for mi in musiclist] for i in range(len(musicJ)): tag = File(musiclist[i]) if ('TIT2' in tag.keys()): musicJ[i]['Tags'] = { 'TIT2': tag['TIT2'].text[0], 'TPE1': tag['TPE1'].text[0] } return render_template("home.html", musicJ=musicJ)
def process_metadata(self, metadata): Log('Reading OGG tags from: ' + self.filename) try: tags = MFile(self.filename) Log('Found tags: ' + str(tags.keys())) except: Log('An error occured while attempting to parse the OGG file: ' + self.filename) return # Genres try: genres = tags.get('genre') if genres is not None and len(genres) > 0: metadata.genres.clear() for genre in genres: for sub_genre in parse_genres(genre): metadata.genres.add(sub_genre.strip()) except Exception, e: Log('Exception reading genre: ' + str(e))
def process_metadata(self, metadata): Log("Reading FLAC tags from: " + self.filename) try: tags = MFile(self.filename) Log("Found tags: " + str(tags.keys())) except: Log("An error occurred while attempting to parse the FLAC file: " + self.filename) return # Genres try: genres = tags.get("genre") if genres is not None and len(genres) > 0: metadata.genres.clear() for genre in genres: for sub_genre in parse_genres(genre): if sub_genre.strip(): metadata.genres.add(sub_genre.strip()) except Exception, e: Log("Exception reading genre: " + str(e))
def process_metadata(self, metadata): Log("Reading MP4 tags from: " + self.filename) try: tags = MFile(self.filename) Log("Found tags: " + str(tags.keys())) except: Log("An error occurred while attempting to parse the MP4 file: " + self.filename) return # Genres try: genres = tags.get("\xa9gen") if genres is not None and len(genres) > 0: for genre in genres: for sub_genre in parse_genres(genre): sub_genre_stripped = sub_genre.strip() if sub_genre_stripped: if sub_genre_stripped not in metadata.genres: metadata.genres.add(sub_genre_stripped) except Exception, e: Log("Exception reading \xa9gen (genre): " + str(e))
def process_metadata(self, metadata): Log('Reading MP4 tags from: ' + self.filename) try: tags = MFile(self.filename) Log('Found tags: ' + str(tags.keys())) except: Log('An error occurred while attempting to parse the MP4 file: ' + self.filename) return # Genres try: genres = tags.get('\xa9gen') if genres is not None and len(genres) > 0: for genre in genres: for sub_genre in parse_genres(genre): sub_genre_stripped = sub_genre.strip() if sub_genre_stripped: if sub_genre_stripped not in metadata.genres: metadata.genres.add(sub_genre_stripped) except Exception, e: Log('Exception reading \xa9gen (genre): ' + str(e))
class OGGAudioHelper(AudioHelper): def __init__(self, filename): super(OGGAudioHelper, self).__init__(filename) try: Log('Reading OGG tags from: ' + self.filename) self.tags = MFile(self.filename) Log('Found OGG tags: ' + str(self.tags.keys())) except: Log('An error occured while attempting to parse the OGG file: ' + self.filename) @classmethod def is_helper_for(cls, tagType): return tagType in ['OggVorbis', 'OggOpus'] def process_metadata(self, metadata, prefs): # Genres try: genres = self.tags.get('genre') if genres is not None and len(genres) > 0: metadata.genres.clear() for genre in genres: for sub_genre in parse_genres(genre): if sub_genre.strip(): metadata.genres.add(sub_genre.strip()) except Exception, e: Log('Exception reading genre: ' + str(e)) # Release Date try: release_date = self.tags.get('date') if release_date is not None and len(release_date) > 0: metadata.originally_available_at = Datetime.ParseDate( release_date[0]) except Exception, e: Log('Exception reading release date' + str(e))
def hydrate(self, bundle): #Translate model field name to audio metadata name tag_name_translator: Dict[str, List[str]] = { 'title': ['title'], } if 'audio' in bundle.data.keys() and bundle.request.method == 'POST': if settings.USE_ACOUSTID: tmp_file_path = bundle.data.get('audio').temporary_file_path() matches = acoustid.match(settings.ACOUSTID_API_KEY, tmp_file_path) try: score, recording_id, title, artist_entry = next(matches) except StopIteration: pass else: musicbrainzngs.set_useragent('Open_Sound_Stream:Server', settings.OSS_VERSION) try: rec = musicbrainzngs.get_recording_by_id( recording_id, includes=['artists', 'tags', 'releases']) except musicbrainzngs.WebServiceError: pass else: bundle_data_translate: Dict[str, Union[List[str], List[Artist], List[Album]]] = { 'title': title, 'mbid': recording_id, } for key, val in bundle_data_translate.items(): if key not in bundle.data: bundle.data[key] = val artists: List[str] = [] artist_obj_list: List[Artist] = [] if "artists" not in bundle.data: artist_list: List[Dict] = rec['recording'][ 'artist-credit'] for artist_entry in artist_list: artist_by_id: Artist = Artist.get_by_mbid( bundle.request.user, artist_entry["artist"]["id"]) if artist_by_id is not None: artists.append("/api/v1/artist/{}/".format( artist_by_id.pk)) artist_obj_list.append(artist_by_id) bundle.data['artists'] = artists else: for artist_entry in bundle.data.getlist('artist'): artist_entry_splitted = artist_entry.split("/") if artist_entry_splitted[-1] == '': del artist_entry_splitted[-1] try: artist_id = int(artist_entry_splitted[-1]) except ValueError: continue try: artist_obj_list.append( Artist.objects.get( user=bundle.request.user, pk=artist_id)) except ObjectDoesNotExist: #dont process any further, let tastypie throw the exception return bundle if "album" not in bundle.data and len( rec['recording']['release-list']) >= 1: release = rec['recording']['release-list'][0] album, created = Album.objects.get_or_create( user=bundle.request.user, name=release['title']) for artist_entry in artist_obj_list: album.artist.add(artist_entry) album.mbid = release["id"] try: img = musicbrainzngs.get_image_list( release["id"]) except musicbrainzngs.ResponseError: pass else: if len(img["images"]) > 0: album.cover_url = img["images"][0]["image"] album.save() bundle.data['album'] = "/api/v1/album/{}/".format( album.pk) metadata = GetTags(fileobj=bundle.data['audio'].file) for field_name, tag_names in tag_name_translator.items(): if field_name not in bundle.data.keys(): for tag_name in tag_names: if tag_name in metadata.keys(): bundle.data[field_name] = metadata.get(tag_name) break return bundle
except KeyError: artist = unicode("") try: album = data["album"][0].strip() except KeyError: album = unicode("") try: title = data["title"][0].strip() except KeyError: title = unicode("") duration = int(data.info.length) print (fp, artist, album, title, duration) cur.execute("insert into songs values(?,?,?,?,?)",(fp, artist, album, title, duration)) con.commit() except KeyError: print fp,data.keys() raise cur.execute("select artist,album, count(title) from songs group by artist,album having count(title)>2 and artist!=\"\"") artists = {} lower = {} d = cur.fetchall() #print d for (artist, album,title) in d: if artist.lower() in lower: artist = lower[artist.lower()] if artist not in artists: artists[artist] = {} lower[artist.lower()] = artist artists[artist][album] = title
class podcast_reader(object): """ Simple podcast MP3 audio reader """ audio_picture = None audio_date = None audio_id = None image_file = None image_fullpath = None image_data = None title = 'foo' type = 'bar' def __init__(self, file_path, output_path): self._path = file_path self._output = output_path self.audio_data = File(file_path) self.duration = int(self.audio_data.info.length / 60) self._load_internal_data() def get_tags(self, tag): return self._get_list(self.audio_data.tags.getall(TAGS[tag])[0]) def text(self): return str(self._tag('TEXTO')[0]).decode('utf-8') def _image(self): # looking for 'APIC:xxxx.ext' for tag in self.audio_data.keys(): if 'APIC:' in tag: self.audio_picture = self.audio_data[tag] image_ext = ".%s" % (self.audio_picture.mime).split("/")[1] self.image_file = path.join( PATH_AUDIO, PATH_IMGS, path.basename(self._path).replace('.mp3', image_ext)) self.image_fullpath = path.join(self._output, PATH_AUDIO, PATH_IMGS) self.image_data = self.audio_picture.data def _title(self): self.title = str(self._tag('TITULO')[0]).decode('utf-8') self.title_safe = self._safe_me(self.title) def _date(self): date = str(self._tag('FECHA')[0]) self.audio_date = datetime.datetime.strptime(date, "%Y-%m-%d") # generate global id - to identify the file (unique_id) def _id(self): # if the user generate an ID, just use it if self._tag('ID'): self.audio_id = str(self._tag('ID')[0]) # we use date and safe version of title string else: self.audio_id = self.audio_date.strftime("%d%m%Y_") self.audio_id += self.title_safe def _type(self): self.type = str(self._tag('TIPO')[0]).decode('utf-8') self.type_safe = self._safe_me(self.type) def _safe_me(self, name): regex = re.compile("[^\w\-]") return regex.sub("", name.replace(" ", "_").lower()) def _tag(self, audio_tag): return self.audio_data.tags.getall(TAGS[audio_tag]) def _get_list(self, audio_tag): return [x.strip() for x in str(audio_tag).decode('utf-8').split(",")] def _load_internal_data(self): self._image() self._title() self._date() self._id() self._type()
class AudioFile(MutableMapping): """A simple class just for tag editing. No internal mutagen tags are exposed, or filenames or anything. So calling clear() won't destroy the filename field or things like that. Use it like a dict, then .write() it to commit the changes. When saving, tags that cannot be saved by the file format will be skipped with a debug message, since this is a common occurrance with MP3/M4A. Optional argument blacklist is a list of regexps matching non-transferrable tags. They will effectively be hidden, nether settable nor gettable. Or grab the actual underlying mutagen format object from the .data field and get your hands dirty. """ def __init__(self, filename: str, blacklist: List[Pattern[str]]=[], easy: bool=True) -> None: self.filename = filename self.data = MusicFile(self.filename, easy=easy) if self.data is None: raise ValueError("Unable to identify %s as a music file" % (repr(filename))) # Also exclude mutagen's internal tags self.blacklist = [ re.compile("^~") ] + blacklist def __getitem__(self, item: str) -> Any: if self.blacklisted(item): logger.debug("Attempted to get blacklisted key: %s." % repr(item)) else: return self.data.__getitem__(item) def __setitem__(self, item: str, value: Any) -> None: if self.blacklisted(item): logger.debug("Attempted to set blacklisted key: %s." % repr(item)) else: try: return self.data.__setitem__(item, value) except KeyError: logger.debug("Skipping unsupported tag %s for file type %s", item, type(self.data)) def __delitem__(self, item: str): if self.blacklisted(item): logger.debug("Attempted to del blacklisted key: %s." % repr(item)) else: return self.data.__delitem__(item) def __len__(self) -> int: return len(list(self.keys())) def __iter__(self) -> Iterable[Any]: return iter(self.keys()) def blacklisted(self, item: str) -> bool: """Return True if tag is blacklisted. Blacklist automatically includes internal mutagen tags (those beginning with a tilde).""" for regex in self.blacklist: if re.search(regex, item): return True else: return False def keys(self) -> Iterable[str]: return [ key for key in self.data.keys() if not self.blacklisted(key) ] def write(self) -> None: return self.data.save()
def fix_music(rename_format, norename=False, recursive=False): ''' Searches for '.mp3' files in directory (optionally recursive) and checks whether they already contain album art and album name tags or not. ''' files = [] if recursive: for dirpath, _, filenames in walk("."): for filename in [f for f in filenames if f.endswith(".mp3")]: if Py3: files += [path.join(dirpath, filename)] else: files += [path.join(dirpath, filename).decode('utf-8')] else: if Py3: files = [f for f in listdir('.') if f.endswith('.mp3')] else: files = [f.decode('utf-8') for f in listdir('.') if f.endswith('.mp3')] for file_path in files: tags = File(file_path) file_name = basename(file_path)[:-4] #Gets file name and removes .mp3 for better search results if 'APIC:Cover' in tags.keys() and 'TALB' in tags.keys(): # Checks whether there is album art and album name log('%s already has tags ' % tags["TIT2"]) elif not('APIC:Cover' in tags.keys()) and 'TALB' in tags.keys(): album = tags["TALB"].text[0] log(LOG_LINE_SEPERATOR) log(file_path) log('> Adding metadata') try: albumart = albumsearch.img_search_google(album) except Exception: albumart = albumsearch.img_search_bing(album) add_albumart(albumart, file_path) else: log(LOG_LINE_SEPERATOR) log(file_path) log('> Adding metadata') try: artist, album, song_name, lyrics, match_bool, score = get_details_spotify( file_name) # Try finding details through spotify except Exception: artist, album, song_name, lyrics, match_bool, score = get_details_letssingit( file_name) # Use bad scraping method as last resort try: log_indented('* Trying to extract album art from Google.com') albumart = albumsearch.img_search_google(artist+' '+album) except Exception: log_indented('* Trying to extract album art from Bing.com') albumart = albumsearch.img_search_bing(arist+' '+album) if match_bool: add_albumart(albumart, file_path) add_details(file_path, song_name, artist, album, lyrics) try: if not norename: song_title = rename_format.format(title=song_name + '-', artist=artist + '-', album=album+'-') song_title = song_title[:-1] if song_title.endswith('-') else song_title rename(file_path, path.dirname(file_path) + '/{song_title}.mp3'.format(song_title=song_title)) except Exception: pass else: log_error("* Couldn't find appropriate details of your song", indented=True) with open(LOG_FILENAME, "a") as problems: problems.write(str(file_path) + '\n') # log song that couldn't be repaired log("Match score: %s/10.0" % round(score * 10, 1)) log(LOG_LINE_SEPERATOR)
def test_add_album_art(): musictools.add_album_art(location, albumart) tags = File(location) assert 'APIC:Cover' in tags.keys() != None
# 3.: copy the tags and rename files oldfiles = sorted(os.listdir(os.getcwd())) for f in oldfiles: if not os.path.isfile(f): oldfiles.remove(f) newfiles = sorted(glob.glob("abcde*/*.flac")) if len(newfiles) != numfiles: print("Anzahl der Tracks stimmt nicht überein!") print(oldfiles) print("---") print(newfiles) sys.exit(1) for i in range(len(oldfiles)): new_audio = File(newfiles[i]) old_audio = File(oldfiles[i]) for key in old_audio.keys(): new_audio[key] = old_audio[key] new_audio.save() newname = oldfiles[i].rsplit(".",1)[0] + ".flac" os.rename(newfiles[i],newname) print("successfully tagged and renamed " + newname) subprocess.call(["rm", "-rf"] + glob.glob("abcde*")) ans = raw_input("Delete ogg files? [Y/n] ").strip() if ans in "yYjJ" or ans == "": for f in oldfiles: os.remove(f)
def updatemusic(): db = model() musiclist = glob.glob(MUSICFOLDER + "*.mp3") musicnames = [mi.split("/")[-1] for mi in musiclist] indb = [msi.arquivo for msi in db().iterselect(db.musica.arquivo) if msi.arquivo in musicnames] notindb = list(set(musicnames) - set(indb)) for msi in notindb: tag = File(MUSICFOLDER + msi) tempo = sec2minString(File(MUSICFOLDER + msi).info.length) if('TIT2'in tag.keys()): db.musica.insert(nome=tag['TIT2'].text[0], cantor=tag['TPE1'].text[0], arquivo=msi, tempo=tempo) else: db.musica.insert(arquivo=msi, tempo=tempo) notindir = [msi.arquivo for msi in db().iterselect(db.musica.arquivo) if msi.arquivo notin musicnames ] for msi in notindir: db(db.musica.arquivo == msi).delete() db.commit() def get_musics(): db = model() musiclist = db().select(db.musica.arquivo, db.musica.tempo, db.musica.cantor, db.musica.cantor, db.musica.nome, orderby = db.musica.arquivo | db.musica.nome)