audiolibrarian 0.16.2__py3-none-any.whl

audiolibrarian/commands.py

@@ -0,0 +1,283 @@
+"""Command line commands."""
+
+#
+#  Copyright (c) 2020 Stephen Jibson
+#
+#  This file is part of audiolibrarian.
+#
+#  Audiolibrarian is free software: you can redistribute it and/or modify it under the terms of the
+#  GNU General Public License as published by the Free Software Foundation, either version 3 of the
+#  License, or (at your option) any later version.
+#
+#  Audiolibrarian is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+#  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
+#  the GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License along with audiolibrarian.
+#  If not, see <https://www.gnu.org/licenses/>.
+#
+import argparse
+import logging
+import pathlib
+import re
+from typing import Any
+
+from audiolibrarian import __version__, audiofile, audiosource, base, genremanager
+
+log = logging.getLogger(__name__)
+
+
+class _Command:
+    # Base class for commands.
+    help = ""
+    parser = argparse.ArgumentParser()
+
+    @staticmethod
+    def validate_args(args: argparse.Namespace) -> bool:
+        """Validate command line arguments."""
+        _ = args
+        return True
+
+
+class Convert(_Command, base.Base):
+    """AudioLibrarian tool for converting and tagging audio files.
+
+    This class performs all of its tasks on instantiation and provides no public members or
+    methods.
+    """
+
+    command = "convert"
+    help = "convert music from files"
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--artist", "-a", help="provide artist (ignore tags)")
+    parser.add_argument("--album", "-m", help="provide album (ignore tags)")
+    parser.add_argument("--mb-artist-id", help="Musicbrainz artist ID")
+    parser.add_argument("--mb-release-id", help="Musicbrainz release ID")
+    parser.add_argument("--disc", "-d", help="format: x/y: disc x of y for multi-disc release")
+    parser.add_argument("filename", nargs="+", help="directory name or audio file name")
+
+    def __init__(self, args: argparse.Namespace) -> None:
+        """Initialize a Convert command handler."""
+        super().__init__(args)
+        self._source_is_cd = False
+        self._audio_source = audiosource.FilesAudioSource([pathlib.Path(x) for x in args.filename])
+        self._get_tag_info()
+        self._convert()
+        self._write_manifest()
+
+    @staticmethod
+    def validate_args(args: argparse.Namespace) -> bool:
+        """Validate command line arguments."""
+        return _validate_disc_arg(args)
+
+
+class Genre(_Command):
+    """Do stuff with genres."""
+
+    command = "genre"
+    help = "manage MB genre"
+    parser = argparse.ArgumentParser(
+        description=(
+            "Process all audio files in the given directory(ies), allowing the user to *update* "
+            "the genre in Musicbrainz or *tag* audio files with the user-defined genre in "
+            "Musicbrainz."
+        )
+    )
+    parser.add_argument("directory", nargs="+", help="root of directory tree to process")
+    parser_action = parser.add_mutually_exclusive_group()
+    parser_action.add_argument("--tag", action="store_true", help="update tags")
+    parser_action.add_argument("--update", action="store_true", help="update Musicbrainz")
+
+    def __init__(self, args: argparse.Namespace) -> None:
+        """Initialize a Genre command handler."""
+        genremanager.GenreManager(args)
+
+
+class Manifest(_Command, base.Base):
+    """AudioLibrarian tool for writing manifest.yaml files.
+
+    This class performs all of its tasks on instantiation and provides no public members or
+    methods.
+    """
+
+    command = "manifest"
+    help = "create the Manifest.yaml file"
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--artist", "-a", help="provide artist (ignore tags)")
+    parser.add_argument("--album", "-m", help="provide album (ignore tags)")
+    parser.add_argument("--cd", "-c", action="store_true", help="original source was a CD")
+    parser.add_argument("--mb-artist-id", help="Musicbrainz artist ID")
+    parser.add_argument("--mb-release-id", help="Musicbrainz release ID")
+    parser.add_argument("--disc", "-d", help="format: x/y: disc x of y for multi-disc release")
+    parser.add_argument("filename", nargs="+", help="directory name or audio file name")
+
+    def __init__(self, args: argparse.Namespace) -> None:
+        """Initialize a Manifest command handler."""
+        super().__init__(args)
+        self._source_is_cd = args.cd
+        self._audio_source = audiosource.FilesAudioSource([pathlib.Path(x) for x in args.filename])
+        source_filenames = self._audio_source.get_source_filenames()
+        self._source_example = audiofile.AudioFile.open(source_filenames[0]).read_tags()
+        self._get_tag_info()
+        self._write_manifest()
+
+    @staticmethod
+    def validate_args(args: argparse.Namespace) -> bool:
+        """Validate command line arguments."""
+        return _validate_disc_arg(args)
+
+
+class Reconvert(_Command, base.Base):
+    """AudioLibrarian tool for re-converting and tagging audio files from existing source files.
+
+    This class performs all of its tasks on instantiation and provides no public members or
+    methods.
+    """
+
+    command = "reconvert"
+    help = "re-convert files from an existing source directory"
+    parser = argparse.ArgumentParser()
+    parser.add_argument("directories", nargs="+", help="source directories")
+
+    def __init__(self, args: argparse.Namespace) -> None:
+        """Initialize a Reconvert command handler."""
+        super().__init__(args)
+        self._source_is_cd = False
+        manifest_paths = self._find_manifests(args.directories)
+        count = len(manifest_paths)
+        for i, manifest_path in enumerate(manifest_paths):
+            print(f"Processing {i + 1} of {count} ({i / count:.0%}): {manifest_path}...")
+            self._audio_source = audiosource.FilesAudioSource([manifest_path.parent])
+            manifest = self._read_manifest(manifest_path)
+            self._disc_number, self._disc_count = manifest["disc_number"], manifest["disc_count"]
+            self._get_tag_info()
+            self._convert(make_source=False)
+
+    @staticmethod
+    def validate_args(args: argparse.Namespace) -> bool:
+        """Validate command line arguments."""
+        return _validate_directories_arg(args)
+
+
+class Rename(_Command, base.Base):
+    """AudioLibrarian tool for renaming audio files based on their tags.
+
+    This class performs all of its tasks on instantiation and provides no public members or
+    methods.
+    """
+
+    command = "rename"
+    help = "rename files based on tags or MusicBrainz data"
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--dry-run", action="store_true", help="don't actually rename files")
+    parser.add_argument("directories", nargs="+", help="audio file directories")
+
+    def __init__(self, args: argparse.Namespace) -> None:
+        """Initialize a Rename command handler."""
+        super().__init__(args)
+        self._source_is_cd = False
+        print("Finding audio files...")
+        for audio_file in self._find_audio_files(args.directories):
+            filepath = audio_file.filepath
+            if audio_file.one_track.track is None:
+                log.warning("%s has no title", filepath)
+                continue
+            depth = 3 if filepath.parent.name.startswith("disc") else 2
+            old_name = filepath
+            new_name = (
+                filepath.parents[depth]
+                / audio_file.one_track.get_artist_album_disc_path()
+                / audio_file.one_track.track.get_filename(filepath.suffix)
+            )
+            if old_name != new_name:
+                print(f"Renaming:\n  {old_name} -> \n  {new_name}")
+                if args.dry_run:
+                    continue
+                old_parent = old_name.parent
+                new_parent = new_name.parent
+                new_parent.mkdir(parents=True, exist_ok=True)
+                old_name.rename(new_name)
+                if not old_parent.samefile(new_parent):
+                    # Move the Manifest if it's the only file left.
+                    man = "Manifest.yaml"
+                    if [f.name for f in old_parent.glob("*")] == [man]:
+                        print(f"Renaming:\n  {old_parent / man} -> \n  {new_parent / man}")
+                        (old_parent / man).rename(new_parent / man)
+                    for idx in range(depth):
+                        if not list(old_name.parents[idx].glob("*")):
+                            print(f"Removing: {old_name.parents[idx]}")
+                            old_name.parents[idx].rmdir()
+
+            else:
+                log.debug("Not renaming %s", filepath)
+
+    @staticmethod
+    def validate_args(args: argparse.Namespace) -> bool:
+        """Validate command line arguments."""
+        return _validate_directories_arg(args)
+
+
+class Rip(_Command, base.Base):
+    """AudioLibrarian tool for ripping, converting and tagging audio files.
+
+    This class performs all of its tasks on instantiation and provides no public members or
+    methods.
+    """
+
+    command = "rip"
+    help = "rip music from a CD"
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--artist", "-a", help="provide artist")
+    parser.add_argument("--album", "-m", help="provide album")
+    parser.add_argument("--mb-artist-id", help="Musicbrainz artist ID")
+    parser.add_argument("--mb-release-id", help="Musicbrainz release ID")
+    parser.add_argument("--disc", "-d", help="x/y: disc x of y; multi-disc release")
+
+    def __init__(self, args: argparse.Namespace) -> None:
+        """Initialize a Rip command handler."""
+        super().__init__(args)
+        self._source_is_cd = True
+        self._audio_source = audiosource.CDAudioSource()
+        self._get_tag_info()
+        self._convert()
+        self._write_manifest()
+
+    @staticmethod
+    def validate_args(args: argparse.Namespace) -> bool:
+        """Validate command line arguments."""
+        return _validate_disc_arg(args)
+
+
+class Version(_Command):
+    """Print the version."""
+
+    command = "version"
+    help = "display the program version"
+
+    def __init__(self, args: argparse.Namespace) -> None:
+        """Initialize a Version command handler."""
+        _ = args
+        print(f"audiolibrarian {__version__}")
+
+
+def _validate_directories_arg(args: argparse.Namespace) -> bool:
+    for directory in args.directories:
+        if not pathlib.Path(directory).is_dir():
+            print(f"Directory not found: {directory}")
+            return False
+    return True
+
+
+def _validate_disc_arg(args: argparse.Namespace) -> bool:
+    if "disc" in args and args.disc:
+        if not re.match(r"\d+/\d+", args.disc):
+            print("Invalid --disc specification; should be 'x/y'")
+            return False
+        x, y = args.disc.split("/")
+        if int(x) > int(y) or int(x) < 1 or int(y) < 1:
+            print("Invalid --disc specification; should be 'x/y' where x <= y and x and y  >= 1")
+            return False
+    return True
+
+
+COMMANDS: set[Any] = {Convert, Genre, Manifest, Reconvert, Rename, Rip, Version}

audiolibrarian/genremanager.py

@@ -0,0 +1,176 @@
+"""Genre Manager."""
+
+#
+#  Copyright (c) 2020 Stephen Jibson
+#
+#  This file is part of audiolibrarian.
+#
+#  Audiolibrarian is free software: you can redistribute it and/or modify it under the terms of the
+#  GNU General Public License as published by the Free Software Foundation, either version 3 of the
+#  License, or (at your option) any later version.
+#
+#  Audiolibrarian is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+#  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
+#  the GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License along with audiolibrarian.
+#  If not, see <https://www.gnu.org/licenses/>.
+#
+import argparse
+import logging
+import pathlib
+import pickle
+import typing
+import webbrowser
+from typing import Any
+
+import mutagen
+import mutagen.flac
+import mutagen.id3
+import mutagen.mp4
+
+from audiolibrarian import musicbrainz, text
+from audiolibrarian.settings import SETTINGS
+
+log = logging.getLogger(__name__)
+
+
+class GenreManager:
+    """Manage genres."""
+
+    def __init__(self, args: argparse.Namespace) -> None:
+        """Initialize a GenreManager instance."""
+        self._args = args
+        self._mb = musicbrainz.MusicBrainzSession()
+        self._paths = self._get_all_paths()
+        self._paths_by_artist = self._get_paths_by_artist()
+        _u, _c = self._get_genres_by_artist()
+        self._user_genres_by_artist, self._community_genres_by_artist = _u, _c
+        if self._args.update:
+            self._update_user_artists()
+        elif self._args.tag:
+            self._update_tags()  # type: ignore[no-untyped-call]
+
+    @typing.no_type_check  # The mutagen library doesn't provide type hints.
+    def _update_tags(self) -> None:
+        """Set the genre tags for all songs to the user-based genre."""
+        for artist_id, paths in self._paths_by_artist.items():
+            genre = self._user_genres_by_artist.get(artist_id)
+            if not genre:
+                continue
+            for path in paths:
+                if path.suffix == ".flac":
+                    flac_song = mutagen.flac.FLAC(str(path))
+                    current_genre = flac_song.tags["genre"][0]
+                    if current_genre != genre:
+                        flac_song.tags["genre"] = genre
+                        flac_song.save()
+                        print(f"{path}: {current_genre} --> {genre}")
+                elif path.suffix == ".m4a":
+                    m4a_song = mutagen.mp4.MP4(str(path))
+                    current_genre = m4a_song.tags["\xa9gen"][0]
+                    if current_genre != genre:
+                        m4a_song.tags["\xa9gen"] = genre
+                        m4a_song.save()
+                        print(f"{path}: {current_genre} --> {genre}")
+                elif path.suffix == ".mp3":
+                    mp3_song = mutagen.File(str(path))
+                    current_genre = str(mp3_song.tags["TCON"])
+                    if current_genre != genre:
+                        id3 = mutagen.id3.ID3(str(path))
+                        id3.add(mutagen.id3.TCON(encoding=3, text=genre))
+                        id3.save()
+                        print(f"{path}: {current_genre} --> {genre}")
+
+    def _update_user_artists(self) -> None:
+        """Pull up a web page to allow the user to set the genre.
+
+        Update the genre for all artists that only have community-base genres.
+        """
+        for artist_id, artist in sorted(
+            self._community_genres_by_artist.items(),
+            key=lambda x: x[1]["name"],
+        ):
+            artist_name = artist["name"]
+            i = (
+                text.input_(f"Continue with {artist_name} (YES, no, skip)[Y, n, s]: ")
+                .lower()
+                .strip()
+            )
+            if i == "n":
+                break
+            if i != "s":
+                webbrowser.open(f"https://musicbrainz.org/artist/{artist_id}/tags")
+
+    def _get_all_paths(self) -> list[pathlib.Path]:
+        """Return a list of paths for all files in the directories specified in the args."""
+        paths = []
+        for directory in self._args.directory:
+            paths.extend([p for p in list(pathlib.Path(directory).glob("**/*")) if p.is_file()])
+        return paths
+
+    def _get_paths_by_artist(self) -> dict[str, list[pathlib.Path]]:
+        """Return a map of artist-IDs to paths representing audio files by that artist."""
+        artists: dict[str, list[pathlib.Path]] = {}
+        for path in self._paths:
+            artist_id = None
+            song = mutagen.File(str(path))
+            if path.suffix == ".flac":
+                artist_id = str(
+                    song.tags.get("musicbrainz_albumartistid", [""])[0]
+                    or song.tags.get("musicbrainz_artistid", [""])[0]
+                )
+            elif path.suffix == ".m4a":
+                artist_id = (
+                    song.tags.get("----:com.apple.iTunes:MusicBrainz Album Artist Id", [""])[0]
+                    or song.tags.get("----:com.apple.iTunes:MusicBrainz Artist Id", [""])[0]
+                ).decode("utf8")
+            elif path.suffix == ".mp3":
+                artist_id = str(
+                    song.tags.get("TXXX:MusicBrainz Album Artist Id", [""])[0]
+                    or song.tags.get("TXXX:MusicBrainz Artist Id", [""])[0]
+                )
+            if artist_id:
+                if artist_id not in artists:
+                    artists[artist_id] = []
+                artists[artist_id].append(path)
+        return artists
+
+    def _get_genres_by_artist(
+        self,
+    ) -> tuple[dict[str, str], dict[str, dict[str, Any]]]:
+        """Return two dicts mapping Musicbrainz-artist-ID to user and community.
+
+        Returns:
+          user: a single genre, set in Musicbrainz by this app's user
+          community: a list genre records (dicts) set in Musicbrainz by the community
+                     with "name" and "count" fields
+        """
+        user: dict[str, str] = {}
+        community: dict[str, dict[str, Any]] = {}
+        user_modified = False
+        cache_file = SETTINGS.work_dir / "user-genres.pickle"
+        if cache_file.exists():
+            with cache_file.open(mode="rb") as cache_file_obj:
+                user = pickle.load(cache_file_obj)  # noqa: S301
+        for artist_id in self._paths_by_artist:
+            if artist_id in user:
+                log.debug("Cache hit: %s %s", artist_id, user[artist_id])
+                continue  # Already in the cache.
+            artist = self._mb.get_artist_by_id(artist_id, includes=["genres", "user-genres"])
+            if artist["user-genres"]:
+                genre = artist["user-genres"][0]["name"].title()
+                user[artist_id] = genre
+                user_modified = True
+            elif artist["genres"]:
+                community[artist_id] = {
+                    "name": artist["name"],
+                    "genres": [{"name": x["name"], "count": x["count"]} for x in artist["genres"]],
+                }
+        if user_modified:
+            cache_file.parent.mkdir(exist_ok=True)
+            with cache_file.open(mode="wb") as cache_file_obj:
+                # noinspection PyTypeChecker
+                pickle.dump(user, cache_file_obj)
+
+        return user, community