eyeD3 0.9.8a1__py3-none-any.whl

eyed3/plugins/extract.py

@@ -0,0 +1,61 @@
+import sys
+import binascii
+from pathlib import Path
+
+import eyed3.id3
+import eyed3.plugins
+from eyed3.utils.log import getLogger
+
+log = getLogger(__name__)
+
+
+class ExtractPlugin(eyed3.plugins.LoaderPlugin):
+    NAMES = ["extract"]
+    SUMMARY = "Extract tags from audio files."
+
+    def __init__(self, arg_parser):
+        super().__init__(arg_parser, cache_files=True, track_images=False)
+        self.arg_group.add_argument("-o", "--output-file",
+                                    help="The the tag is written to this file in native format.")
+        self.arg_group.add_argument("-H", "--hex", action="store_true",
+                                    help="Output hexadecimal format.")
+        self.arg_group.add_argument("--strip-padding", action="store_true",
+                                    help="Exclude tag padding, if any.")
+
+    def handleFile(self, f, *args, **kwargs):
+        super().handleFile(f)
+        if self.audio_file is None or self.audio_file.tag is None:
+            return
+
+        tag = self.audio_file.tag
+        if not isinstance(tag, eyed3.id3.Tag):
+            print("Only ID3 tags can be extracted currently.", file=sys.stderr)
+            return 1
+
+        with open(tag.file_info.name, "rb") as tag_file:
+            if tag.version[0] != 1:
+                # info.tag_size includes padding.
+                tag_data = tag_file.read(tag.file_info.tag_size)
+                if self.args.strip_padding and tag.file_info.tag_padding_size:
+                    # --strip-padding
+                    tag_data = tag_data[:-tag.file_info.tag_padding_size]
+            else:
+                # ID3 v1.x
+                tag_data = tag_file.read()[-128:]
+
+        if self.args.output_file:
+            # --output-file
+
+            if Path(tag.file_info.name).resolve() == Path(self.args.output_file).resolve():
+                print("Input file overwriting not allowed, choose a different -o/--output-file",
+                      file=sys.stderr)
+                return 1
+
+            with open(self.args.output_file, "wb") as out_file:
+                out_file.write(tag_data)
+        else:
+            if self.args.hex:
+                # --hex
+                tag_data = str(binascii.hexlify(tag_data), "ascii")
+
+            print(tag_data)

eyed3/plugins/fixup.py

@@ -0,0 +1,631 @@
+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.",
+}