import os from collections import defaultdict from eyed3.id3 import ID3_V2_4 from eyed3.id3.tag import TagTemplate from eyed3.plugins import LoaderPlugin from eyed3.utils import art from eyed3.utils.prompt import prompt from eyed3.utils.console import printMsg, Style, Fore from eyed3 import core from eyed3.core import (ALBUM_TYPE_IDS, TXXX_ALBUM_TYPE, EP_MAX_SIZE_HINT, LP_TYPE, EP_TYPE, COMP_TYPE, VARIOUS_TYPE, DEMO_TYPE, LIVE_TYPE, SINGLE_TYPE, VARIOUS_ARTISTS) NORMAL_FNAME_FORMAT = "${artist} - ${track:num} - ${title}" VARIOUS_FNAME_FORMAT = "${track:num} - ${artist} - ${title}" SINGLE_FNAME_FORMAT = "${artist} - ${title}" NORMAL_DNAME_FORMAT = "${best_date:prefer_release} - ${album}" LIVE_DNAME_FORMAT = "${best_date:prefer_recording} - ${album}" def _printChecking(msg, end='\n'): print(Style.BRIGHT + Fore.GREEN + "Checking" + Style.RESET_ALL + " %s" % msg, end=end) def _fixCase(s): if s: fixed_values = [] for word in s.split(): fixed_values.append(word.capitalize()) return " ".join(fixed_values) else: return s def dirDate(d): s = str(d) if "T" in s: s = s.split("T")[0] return s.replace('-', '.') class FixupPlugin(LoaderPlugin): NAMES = ["fixup"] SUMMARY = "Performs various checks and fixes to directories of audio files." DESCRIPTION = """ Operates on directories at a time, fixing each as a unit (album, compilation, live set, etc.). All of these should have common dates, for example but other characteristics may vary. The ``--type`` should be used whenever possible, ``lp`` is the default. The following test and fixes always apply: 1. Every file will be given an ID3 tag if one is missing. 2. Set ID3 v2.4. 3. Set a consistent album name for all files in the directory. 4. Set a consistent artist name for all files, unless the type is ``various`` in which case the artist may vary (but must exist). 5. Ensure each file has a title. 6. Ensure each file has a track # and track total. 7. Ensure all files have a release and original release date, unless the type is ``live`` in which case the recording date is set. 8. All ID3 frames of the following types are removed: USER, PRIV 9. All ID3 files have TLEN (track length in ms) set (or updated). 10. The album/dir type is set in the tag. Types of ``lp`` and ``various`` do not have this field set since the latter is the default and the former can be determined during sync. In ID3 terms the value is in TXXX (description: ``%(TXXX_ALBUM_TYPE)s``). 11. Files are renamed as follows: - Type ``various``: %(VARIOUS_FNAME_FORMAT)s - Type ``single``: %(SINGLE_FNAME_FORMAT)s - All other types: %(NORMAL_FNAME_FORMAT)s - A rename template can be supplied in --file-rename-pattern 12. Directories are renamed as follows: - Type ``live``: %(LIVE_DNAME_FORMAT)s - All other types: %(NORMAL_DNAME_FORMAT)s - A rename template can be supplied in --dir-rename-pattern Album types: - ``lp``: A traditinal "album" of songs from a single artist. No extra info is written to the tag since this is the default. - ``ep``: A short collection of songs from a single artist. The string 'ep' is written to the tag's ``%(TXXX_ALBUM_TYPE)s`` field. - ``various``: A collection of songs from different artists. The string 'various' is written to the tag's ``%(TXXX_ALBUM_TYPE)s`` field. - ``live``: A collection of live recordings from a single artist. The string 'live' is written to the tag's ``%(TXXX_ALBUM_TYPE)s`` field. - ``compilation``: A collection of songs from various recordings by a single artist. The string 'compilation' is written to the tag's ``%(TXXX_ALBUM_TYPE)s`` field. Compilation dates, unlike other types, may differ. - ``demo``: A demo recording by a single artist. The string 'demo' is written to the tag's ``%(TXXX_ALBUM_TYPE)s`` field. - ``single``: A track that should no be associated with an album (even if it has album metadata). The string 'single' is written to the tag's ``%(TXXX_ALBUM_TYPE)s`` field. """ % globals() def __init__(self, arg_parser): super(FixupPlugin, self).__init__(arg_parser, cache_files=True, track_images=True) g = self.arg_group self._handled_one = False g.add_argument("--type", choices=ALBUM_TYPE_IDS, dest="dir_type", default=None, help=ARGS_HELP["--type"]) g.add_argument("--fix-case", action="store_true", dest="fix_case", help=ARGS_HELP["--fix-case"]) g.add_argument("-n", "--dry-run", action="store_true", dest="dry_run", help=ARGS_HELP["--dry-run"]) g.add_argument("--no-prompt", action="store_true", dest="no_prompt", help=ARGS_HELP["--no-prompt"]) g.add_argument("--dotted-dates", action="store_true", help=ARGS_HELP["--dotted-dates"]) g.add_argument("--file-rename-pattern", dest="file_rename_pattern", help=ARGS_HELP["--file-rename-pattern"]) g.add_argument("--dir-rename-pattern", dest="dir_rename_pattern", help=ARGS_HELP["--dir-rename-pattern"]) g.add_argument("--no-dir-rename", action="store_true", help=ARGS_HELP["--no-dir-rename"]) self._curr_dir_type = None self._dir_files_to_remove = set() def _getOne(self, key, values, default=None, Type=str, required=True): values = set(values) if None in values: values.remove(None) if len(values) != 1: printMsg( "Detected %s %s names%s" % ("0" if len(values) == 0 else "multiple", key, "." if not values else (":\n\t%s" % "\n\t".join([str(v) for v in values])), )) value = prompt("Enter %s" % key.title(), default=default, type_=Type, required=required) else: value = values.pop() return value def _getDates(self, audio_files): tags = [f.tag for f in audio_files if f.tag] rel_dates = set([t.release_date for t in tags if t.release_date]) orel_dates = set([t.original_release_date for t in tags if t.original_release_date]) rec_dates = set([t.recording_date for t in tags if t.recording_date]) release_date, original_release_date, recording_date = None, None, None def reduceDate(type_str, dates_set, default_date=None): if len(dates_set or []) != 1: reduced = self._getOne(type_str, dates_set, default=str(default_date) if default_date else None, Type=core.Date.parse) else: reduced = dates_set.pop() return reduced if (False not in [a.tag.album_type == LIVE_TYPE for a in audio_files] or self._curr_dir_type == LIVE_TYPE): # The recording date is most meaningful for live music. recording_date = reduceDate("recording date", rec_dates | orel_dates | rel_dates) rec_dates = {recording_date} # Want when these set if they may recording time. orel_dates.difference_update(rec_dates) rel_dates.difference_update(rec_dates) if orel_dates: original_release_date = reduceDate("original release date", orel_dates | rel_dates) orel_dates = {original_release_date} if rel_dates | orel_dates: release_date = reduceDate("release date", rel_dates | orel_dates) elif (False not in [a.tag.album_type == COMP_TYPE for a in audio_files] or self._curr_dir_type == COMP_TYPE): # The release date is most meaningful for comps, other track dates # may differ. if len(rel_dates) != 1: release_date = reduceDate("release date", rel_dates | orel_dates) else: release_date = list(rel_dates)[0] else: if len(orel_dates) != 1: # The original release date is most meaningful for studio music. original_release_date = reduceDate("original release date", orel_dates | rel_dates | rec_dates) orel_dates = {original_release_date} else: original_release_date = list(orel_dates)[0] if len(rel_dates) != 1: release_date = reduceDate("release date", rel_dates | orel_dates) rel_dates = {release_date} else: release_date = list(rel_dates)[0] if rec_dates.difference(orel_dates | rel_dates): recording_date = reduceDate("recording date", rec_dates) return release_date, original_release_date, recording_date def _resolveArtistInfo(self, audio_files): assert(self._curr_dir_type != SINGLE_TYPE) tags = [f.tag for f in audio_files if f.tag] artists = set([t.album_artist for t in tags if t.album_artist]) # There can be 0 or 1 album artist values. album_artist = None if len(artists) > 1: album_artist = self._getOne("album artist", artists, required=False) elif artists: album_artist = artists.pop() artists = list(set([t.artist for t in tags if t.artist])) if len(artists) > 1: # There can be more then 1 artist when VARIOUS_TYPE or # album_artist != None. if not album_artist and self._curr_dir_type != VARIOUS_TYPE: if prompt("Multiple artist names exist, process directory as " "various artists", default=True): self._curr_dir_type = VARIOUS_TYPE else: artists = [self._getOne("artist", artists, required=True)] elif (album_artist == VARIOUS_ARTISTS and self._curr_dir_type != VARIOUS_TYPE): self._curr_dir_type = VARIOUS_TYPE elif len(artists) == 0: artists = [self._getOne("artist", [], required=True)] # Fix up artist and album artist discrepancies if len(artists) == 1 and album_artist: artist = artists[0] if album_artist != artist: print("When there is only one artist it should match the " "album artist. Choices are: ") for s in [artist, album_artist]: print("\t%s" % s) album_artist = prompt("Select common artist and album artist", choices=[artist, album_artist]) artists = [album_artist] if self.args.fix_case: album_artist = _fixCase(album_artist) artists = [_fixCase(a) for a in artists] return album_artist, artists def _getAlbum(self, audio_files): tags = [f.tag for f in audio_files if f.tag] albums = set([t.album for t in tags if t.album]) album_name = (albums.pop() if len(albums) == 1 else self._getOne("album", albums)) assert album_name return album_name if not self.args.fix_case else _fixCase(album_name) def _checkCoverArt(self, directory, audio_files): valid_cover = False # Check for cover file. _printChecking("for cover art...") for dimg in self._dir_images: art_type = art.matchArtFile(dimg) if art_type == art.FRONT_COVER: dimg_name = os.path.basename(dimg) print(f"\t{dimg_name}") valid_cover = True if not valid_cover: # FIXME: move the logic out fixup and into art. # Look for a cover in the tags. for tag in [af.tag for af in audio_files if af.tag]: if valid_cover: # It could be set below... break for img in tag.images: if img.picture_type == img.FRONT_COVER: file_name = img.makeFileName("cover") print("\tFound front cover in tag, writing '%s'" % file_name) with open(os.path.join(directory, file_name), "wb") as img_file: img_file.write(img.image_data) img_file.close() valid_cover = True # TODO: force rename of cover file to single/consistent name (e.g. cover) return valid_cover def start(self, args, config): import eyed3.utils.prompt eyed3.utils.prompt.DISABLE_PROMPT = "exit" if args.no_prompt else None super(FixupPlugin, self).start(args, config) def handleFile(self, f, *args, **kwargs): super(FixupPlugin, self).handleFile(f, *args, **kwargs) if not self.audio_file and f not in self._dir_images: self._dir_files_to_remove.add(f) def handleDirectory(self, directory, _): if not self._file_cache: return directory = os.path.abspath(directory) print("\n" + Style.BRIGHT + Fore.YELLOW + "Scanning directory%s %s" % (Style.RESET_ALL, directory)) def _path(af): return af.path self._handled_one = True # Make sure all of the audio files has a tag. for f in self._file_cache: if f.tag is None: f.initTag() audio_files = sorted(list(self._file_cache), key=_path) self._file_cache = [] edited_files = set() self._curr_dir_type = self.args.dir_type if self._curr_dir_type is None: types = set([a.tag.album_type for a in audio_files]) if len(types) == 1: self._curr_dir_type = types.pop() # Check for corrections to LP, EP, COMP if (self._curr_dir_type is None and len(audio_files) < EP_MAX_SIZE_HINT): # Do you want EP? if False in [a.tag.album_type == EP_TYPE for a in audio_files]: if prompt("Only %d audio files, process directory as an EP" % len(audio_files), default=True): self._curr_dir_type = EP_TYPE else: self._curr_dir_type = EP_TYPE elif (self._curr_dir_type in (EP_TYPE, DEMO_TYPE) and len(audio_files) > EP_MAX_SIZE_HINT): # Do you want LP? if prompt("%d audio files is large for type %s, process " "directory as an LP" % (len(audio_files), self._curr_dir_type), default=True): self._curr_dir_type = LP_TYPE last = defaultdict(lambda: None) album_artist = None artists = set() album = None if self._curr_dir_type != SINGLE_TYPE: album_artist, artists = self._resolveArtistInfo(audio_files) print(Fore.BLUE + "Album artist: " + Style.RESET_ALL + (album_artist or "")) print(Fore.BLUE + "Artist" + ("s" if len(artists) > 1 else "") + ": " + Style.RESET_ALL + ", ".join(artists)) album = self._getAlbum(audio_files) print(Fore.BLUE + "Album: " + Style.RESET_ALL + album) rel_date, orel_date, rec_date = self._getDates(audio_files) for what, d in [("Release", rel_date), ("Original", orel_date), ("Recording", rec_date)]: print(f"{Fore.BLUE} {what} date: {Style.RESET_ALL} {d}") num_audio_files = len(audio_files) track_nums = set([f.tag.track_num[0] for f in audio_files]) fix_track_nums = set(range(1, num_audio_files + 1)) != track_nums new_track_nums = [] dir_type = self._curr_dir_type for f in sorted(audio_files, key=_path): print(Style.BRIGHT + Fore.GREEN + "Checking" + Fore.RESET + Style.BRIGHT + (" %s" % os.path.basename(f.path)) + Style.RESET_ALL) if not f.tag: print("\tAdding new tag") f.initTag() edited_files.add(f) tag = f.tag if tag.version != ID3_V2_4: print("\tConverting to ID3 v2.4") tag.version = ID3_V2_4 edited_files.add(f) if dir_type != SINGLE_TYPE and album_artist != tag.album_artist: print("\tSetting album artist: %s" % album_artist) tag.album_artist = album_artist edited_files.add(f) if not tag.artist and dir_type in (VARIOUS_TYPE, SINGLE_TYPE): # Prompt artist tag.artist = prompt("Artist name", default=last["artist"]) last["artist"] = tag.artist elif len(artists) == 1 and tag.artist != artists[0]: assert(dir_type != SINGLE_TYPE) print("\tSetting artist: %s" % artists[0]) tag.artist = artists[0] edited_files.add(f) if tag.album != album and dir_type != SINGLE_TYPE: print("\tSetting album: %s" % album) tag.album = album edited_files.add(f) orig_title = tag.title if not tag.title: tag.title = prompt("Track title") tag.title = tag.title.strip() if self.args.fix_case: tag.title = _fixCase(tag.title) if orig_title != tag.title: print("\tSetting title: %s" % tag.title) edited_files.add(f) if dir_type != SINGLE_TYPE: # Track numbers tnum, ttot = tag.track_num update = False if ttot != num_audio_files: update = True ttot = num_audio_files if fix_track_nums or not (1 <= tnum <= num_audio_files): tnum = None while tnum is None: tnum = int(prompt("Track #", type_=int)) if not (1 <= tnum <= num_audio_files): print(Fore.RED + "Out of range: " + Fore.RESET + "1 <= %d <= %d" % (tnum, num_audio_files)) tnum = None elif tnum in new_track_nums: print(Fore.RED + "Duplicate value: " + Fore.RESET + str(tnum)) tnum = None else: update = True new_track_nums.append(tnum) if update: tag.track_num = (tnum, ttot) print("\tSetting track numbers: %s" % str(tag.track_num)) edited_files.add(f) else: # Singles if tag.track_num != (None, None): tag.track_num = (None, None) edited_files.add(f) if dir_type != SINGLE_TYPE: # Dates if rec_date and tag.recording_date != rec_date: print("\tSetting %s date (%s)" % ("recording", str(rec_date))) tag.recording_date = rec_date edited_files.add(f) if rel_date and tag.release_date != rel_date: print("\tSetting %s date (%s)" % ("release", str(rel_date))) tag.release_date = rel_date edited_files.add(f) if orel_date and tag.original_release_date != orel_date: print("\tSetting %s date (%s)" % ("original release", str(orel_date))) tag.original_release_date = orel_date edited_files.add(f) for frame in list(tag.frameiter(["USER", "PRIV"])): print("\tRemoving %s frames: %s" % (frame.id, frame.owner_id if frame.id == b"PRIV" else frame.text)) tag.frame_set[frame.id].remove(frame) edited_files.add(f) # Add TLEN tlen = tag.getTextFrame("TLEN") if tlen is not None: real_tlen_ms = f.info.time_secs * 1000 tlen_ms = float(tlen) if tlen_ms != real_tlen_ms: print("\tSetting TLEN (%d)" % real_tlen_ms) tag.setTextFrame("TLEN", str(real_tlen_ms)) edited_files.add(f) # Add custom album type if special and otherwise not able to be # determined. curr_type = tag.album_type if curr_type != dir_type: print("\tSetting %s = %s" % (TXXX_ALBUM_TYPE, dir_type)) tag.album_type = dir_type edited_files.add(f) try: if not self._checkCoverArt(directory, audio_files): if not prompt("Proceed without valid cover file", default=True): return finally: self._dir_images = [] # Determine other changes, like file and/or directory renames # so they can be reported before save confirmation. # File renaming file_renames = [] if self.args.file_rename_pattern: format_str = self.args.file_rename_pattern else: if dir_type == SINGLE_TYPE: format_str = SINGLE_FNAME_FORMAT elif dir_type in (VARIOUS_TYPE, COMP_TYPE): format_str = VARIOUS_FNAME_FORMAT else: format_str = NORMAL_FNAME_FORMAT for f in audio_files: orig_name, orig_ext = os.path.splitext(os.path.basename(f.path)) new_name = TagTemplate(format_str).substitute(f.tag, zeropad=True) if orig_name != new_name: printMsg("Rename file to %s%s" % (new_name, orig_ext)) file_renames.append((f, new_name, orig_ext)) # Directory renaming dir_rename = None if not self.args.no_dir_rename and dir_type != SINGLE_TYPE: if self.args.dir_rename_pattern: dir_format = self.args.dir_rename_pattern else: if dir_type == LIVE_TYPE: dir_format = LIVE_DNAME_FORMAT else: dir_format = NORMAL_DNAME_FORMAT template = TagTemplate(dir_format, dotted_dates=self.args.dotted_dates) pref_dir = template.substitute(audio_files[0].tag, zeropad=True) if os.path.basename(directory) != pref_dir: new_dir = os.path.join(os.path.dirname(directory), pref_dir) printMsg("Rename directory to %s" % new_dir) dir_rename = (directory, new_dir) # Cruft files to remove file_removes = [] if self._dir_files_to_remove: for f in self._dir_files_to_remove: print("Remove file: " + os.path.basename(f)) file_removes.append(f) self._dir_files_to_remove = set() if not self.args.dry_run: confirmed = False if (edited_files or file_renames or dir_rename or file_removes): confirmed = prompt("\nSave changes", default=True) if confirmed: for f in edited_files: print("Saving %s" % os.path.basename(f.path)) f.tag.save(version=ID3_V2_4, preserve_file_time=True) for f, new_name, orig_ext in file_renames: printMsg("Renaming file to %s%s" % (new_name, orig_ext)) f.rename(new_name, preserve_file_time=True) if file_removes: for f in file_removes: printMsg("Removing file %s" % os.path.basename(f)) os.remove(f) if dir_rename: printMsg("Renaming directory to %s" % dir_rename[1]) s = os.stat(dir_rename[0]) os.rename(dir_rename[0], dir_rename[1]) # With a rename use the origianl access time os.utime(dir_rename[1], (s.st_atime, s.st_atime)) else: printMsg("\nNo changes made (run without -n/--dry-run)") def handleDone(self): if not self._handled_one: printMsg("Nothing to do") def _getTemplateKeys(): from eyed3.id3.tag import TagTemplate keys = list(TagTemplate("")._makeMapping(None, False).keys()) keys.sort() return ", ".join(["$%s" % v for v in keys]) ARGS_HELP = { "--type": "How to treat each directory. The default is '%s', " "although you may be prompted for an alternate choice " "if the files look like another type." % ALBUM_TYPE_IDS[0], "--fix-case": "Fix casing on each string field by capitalizing each " "word.", "--dry-run": "Only print the operations that would take place, but do " "not execute them.", "--no-prompt": "Exit if prompted.", "--dotted-dates": "Separate date with '.' instead of '-' when naming " "directories.", "--file-rename-pattern": "Rename file (the extension is not affected) " "based on data in the tag using substitution " "variables: " + _getTemplateKeys(), "--dir-rename-pattern": "Rename directory based on data in the tag " "using substitution variables: " + _getTemplateKeys(), "--no-dir-rename": "Do not rename the directory.", }