audiolibrarian 0.16.2__py3-none-any.whl

audiolibrarian/audiofile/formats/mp3.py

@@ -0,0 +1,259 @@
+"""AudioFile support for mp3 files."""
+
+#
+#  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/>.
+#
+from typing import Any, no_type_check
+
+import mutagen
+import mutagen.id3
+
+from audiolibrarian import audiofile, records
+
+APIC = mutagen.id3.APIC
+TXXX = mutagen.id3.TXXX
+UFID = mutagen.id3.UFID
+MB_UFID = "http://musicbrainz.org"
+
+
+class Mp3File(audiofile.AudioFile, extensions={".mp3"}):
+    """AudioFile for MP3 files."""
+
+    @no_type_check  # The mutagen library doesn't provide type hints.
+    def read_tags(self) -> records.OneTrack:
+        """Read the tags and return a OneTrack object."""
+
+        def get_l(key: str) -> records.ListF | None:
+            if (value := mut.get(key)) is None:
+                return None
+            if "/" in str(value):
+                return records.ListF(str(value).split("/"))
+            return records.ListF(value)
+
+        mut = self._mut_file
+        front_cover = None
+        if apic := mut.get("APIC:front cover", mut.get("APIC:front", mut.get("APIC:"))):
+            front_cover = records.FrontCover(data=apic.data, desc=apic.desc, mime=apic.mime)
+        tipl = mut["TIPL"].people if mut.get("TIPL") else []
+        roles = ("arranger", "composer", "conductor", "engineer", "mix", "producer", "writer")
+        medium_count = int(mut["TPOS"][0].split("/")[1]) if mut.get("TPOS") else None
+        medium_number = int(mut["TPOS"][0].split("/")[0]) if mut.get("TPOS") else None
+        track_count = int(mut["TRCK"][0].split("/")[1]) if mut.get("TRCK") else None
+        track_number = int(mut["TRCK"][0].split("/")[0]) if mut.get("TRCK") else None
+        bitrate = mut.info.bitrate // 1000
+        bitrate_mode = records.BitrateMode.__members__[
+            str(mut.info.bitrate_mode).rsplit(".", maxsplit=1)[-1]
+        ]
+        # Shortcut for common CBRs.
+        if bitrate_mode == records.BitrateMode.UNKNOWN and bitrate in (128, 160, 192, 320):
+            bitrate_mode = records.BitrateMode.CBR
+        release = (
+            records.Release(
+                album=mut.get("TALB", [None])[0],
+                album_artists=get_l("TPE2"),
+                album_artists_sort=get_l("TSO2"),
+                asins=get_l("TXXX:ASIN"),
+                barcodes=get_l("TXXX:BARCODE"),
+                catalog_numbers=get_l("TXXX:CATALOGNUMBER"),
+                date=(mut.get("TDRC", [mutagen.id3.ID3TimeStamp("")])[0]).text or None,
+                front_cover=front_cover,
+                genres=get_l("TCON"),
+                labels=get_l("TPUB"),
+                media={
+                    medium_number: records.Medium(
+                        formats=get_l("TMED"),
+                        titles=get_l("TSST"),
+                        track_count=track_count,
+                        tracks={
+                            track_number: records.Track(
+                                artist=mut.get("TPE1", [None])[0],
+                                artists=get_l("TXXX:ARTISTS"),
+                                artists_sort=get_l("TSOP"),
+                                file_info=records.FileInfo(
+                                    bitrate=bitrate,
+                                    bitrate_mode=bitrate_mode,
+                                    path=self.filepath,
+                                    type=records.FileType.MP3,
+                                ),
+                                isrcs=get_l("TSRC"),
+                                musicbrainz_artist_ids=get_l("TXXX:MusicBrainz Artist Id"),
+                                musicbrainz_release_track_id=mut.get(
+                                    "TXXX:MusicBrainz Release Track Id", [None]
+                                )[0],
+                                musicbrainz_track_id=mut.get(
+                                    f"UFID:{MB_UFID}", UFID()
+                                ).data.decode("utf8")
+                                or None,
+                                title=mut.get("TIT2", [None])[0],
+                                track_number=track_number,
+                            )
+                        }
+                        if track_number
+                        else None,
+                    )
+                }
+                if medium_number
+                else None,
+                medium_count=medium_count,
+                musicbrainz_album_artist_ids=get_l("TXXX:MusicBrainz Album Artist Id"),
+                musicbrainz_album_id=mut.get("TXXX:MusicBrainz Album Id", [None])[0],
+                musicbrainz_release_group_id=mut.get("TXXX:MusicBrainz Release Group Id", [None])[
+                    0
+                ],
+                original_year=str((mut["TDOR"][0]).year) if mut.get("TDOR") else None,
+                people=(
+                    records.People(
+                        arrangers=[name for role, name in tipl if role == "arranger"] or None,
+                        composers=[name for role, name in tipl if role == "composer"] or None,
+                        conductors=[name for role, name in tipl if role == "conductor"] or None,
+                        engineers=[name for role, name in tipl if role == "engineer"] or None,
+                        lyricists=get_l("TEXT"),
+                        mixers=[name for role, name in tipl if role == "mix"] or None,
+                        producers=[name for role, name in tipl if role == "producer"] or None,
+                        performers=[
+                            records.Performer(name=n, instrument=i)
+                            for i, n in tipl
+                            if i not in roles
+                        ]
+                        or None,
+                        writers=[name for role, name in tipl if role == "writer"] or None,
+                    )
+                    or None
+                ),
+                release_countries=get_l("TXXX:MusicBrainz Album Release Country"),
+                release_statuses=get_l("TXXX:MusicBrainz Album Status"),
+                release_types=get_l("TXXX:MusicBrainz Album Type"),
+                script=mut.get("TXXX:SCRIPT", [None])[0],
+            )
+            or None
+        )
+        if release:
+            release.source = records.Source.TAGS
+        return records.OneTrack(
+            release=release, medium_number=medium_number, track_number=track_number
+        )
+
+    @no_type_check  # The mutagen library doesn't provide type hints.
+    def write_tags(self) -> None:  # noqa: C901, PLR0912, PLR0915
+        """Write the tags."""
+
+        def slash(text: list[str] | records.ListF) -> str:
+            return "/".join(text)
+
+        release, medium_number, medium, track_number, track = self._get_tag_sources()
+        tipl_people = (
+            [["arranger", x] for x in (release.people and release.people.arrangers) or []]
+            + [["composer", x] for x in (release.people and release.people.composers) or []]
+            + [["conductor", x] for x in (release.people and release.people.conductors) or []]
+            + [["engineer", x] for x in (release.people and release.people.engineers) or []]
+            + [["mix", x] for x in (release.people and release.people.mixers) or []]
+            + [["producer", x] for x in (release.people and release.people.producers) or []]
+            + [
+                [p.instrument, p.name]
+                for p in (release.people and release.people.performers) or []
+            ]
+            + [["writer", x] for x in (release.people and release.people.writers) or []]
+        )
+        tags: list[mutagen.id3.Frame] = []
+        # noinspection PyUnusedLocal
+        tag: Any = None
+        if tag := release.album:
+            tags.append(mutagen.id3.TALB(encoding=1, text=tag))
+        if tag := release.people and release.people.composers:
+            tags.append(mutagen.id3.TCOM(encoding=1, text=slash(tag)))
+        if tag := release.genres:
+            tags.append(mutagen.id3.TCON(encoding=3, text=slash(tag)))
+        if tag := release.original_year:
+            tags.append(mutagen.id3.TDOR(encoding=0, text=str(tag)))
+        if tag := release.date:
+            tags.append(mutagen.id3.TDRC(encoding=0, text=tag))
+        if tag := release.people and release.people.lyricists:
+            tags.append(mutagen.id3.TEXT(encoding=1, text=slash(tag)))
+        if people := tipl_people:
+            tags.append(mutagen.id3.TIPL(encoding=1, people=people))
+        if tag := track.title:
+            tags.append(mutagen.id3.TIT2(encoding=1, text=tag))
+        if tag := medium.formats:
+            tags.append(mutagen.id3.TMED(encoding=1, text=slash(tag)))
+        if tag := track.artist:
+            tags.append(mutagen.id3.TPE1(encoding=1, text=tag))
+        if tag := release.album_artists:
+            tags.append(mutagen.id3.TPE2(encoding=1, text=slash(tag)))
+        if tag := release.people and release.people.conductors:
+            tags.append(mutagen.id3.TPE3(encoding=1, text=slash(tag)))
+        if (num := medium_number) and (tag := release.medium_count):
+            tags.append(mutagen.id3.TPOS(encoding=0, text=f"{num}/{tag}"))
+        if tag := release.labels:
+            tags.append(mutagen.id3.TPUB(encoding=1, text=slash(tag)))
+        if (num := track_number) and (tag := medium.track_count):
+            tags.append(mutagen.id3.TRCK(encoding=0, text=f"{num}/{tag}"))
+        if tag := release.album_artists_sort:
+            tags.append(mutagen.id3.TSO2(encoding=1, text=slash(tag)))
+        if tag := track.artists_sort:
+            tags.append(mutagen.id3.TSOP(encoding=1, text=slash(tag)))
+        if tag := track.isrcs:
+            tags.append(mutagen.id3.TSRC(encoding=1, text=slash(tag)))
+        if tag := medium.titles:
+            tags.append(mutagen.id3.TSST(encoding=1, text=slash(tag)))
+        if tag := track.artists:
+            tags.append(TXXX(encoding=1, desc="ARTISTS", text=slash(tag)))
+        if tag := release.asins:
+            tags.append(TXXX(encoding=1, desc="ASIN", text=slash(tag)))
+        if tag := release.barcodes:
+            tags.append(TXXX(encoding=1, desc="BARCODE", text=slash(tag)))
+        if tag := release.catalog_numbers:
+            tags.append(TXXX(encoding=1, desc="CATALOGNUMBER", text=slash(tag)))
+        if tag := release.musicbrainz_album_artist_ids:
+            tags.append(TXXX(encoding=1, desc="MusicBrainz Album Artist Id", text=slash(tag)))
+        if tag := release.musicbrainz_album_id:
+            tags.append(TXXX(encoding=1, desc="MusicBrainz Album Id", text=tag))
+        if tag := release.release_countries:
+            tags.append(
+                TXXX(encoding=1, desc="MusicBrainz Album Release Country", text=slash(tag))
+            )
+        if tag := release.release_statuses:
+            tags.append(TXXX(encoding=1, desc="MusicBrainz Album Status", text=slash(tag)))
+        if tag := release.release_types:
+            tags.append(TXXX(encoding=1, desc="MusicBrainz Album Type", text=slash(tag)))
+        if tag := track.musicbrainz_artist_ids:
+            tags.append(TXXX(encoding=1, desc="MusicBrainz Artist Id", text=slash(tag)))
+        if tag := release.musicbrainz_release_group_id:
+            tags.append(TXXX(encoding=1, desc="MusicBrainz Release Group Id", text=tag))
+        if tag := track.musicbrainz_release_track_id:
+            tags.append(TXXX(encoding=1, desc="MusicBrainz Release Track Id", text=tag))
+        if tag := release.script:
+            tags.append(TXXX(encoding=1, desc="SCRIPT", text=tag))
+        if tag := release.original_year:
+            tags.append(TXXX(encoding=1, desc="originalyear", text=str(tag)))
+        if id_ := track.musicbrainz_track_id:
+            tags.append(UFID(owner=MB_UFID, data=bytes(id_, "utf8")))
+        if (cover := release.front_cover) is not None:
+            tags.append(
+                APIC(encoding=0, mime=cover.mime, type=3, desc=cover.desc, data=cover.data)
+            )
+
+        try:
+            id3 = mutagen.id3.ID3(self.filepath)
+        except mutagen.id3.ID3NoHeaderError:
+            self._mut_file.add_tags()
+            self._mut_file.save()
+            id3 = mutagen.id3.ID3(self.filepath)
+
+        id3.delete()
+        for tag in tags:
+            id3.add(tag)
+        id3.save()
+        self._mut_file = mutagen.File(self.filepath.absolute())

audiolibrarian/audiofile/tags.py

@@ -0,0 +1,48 @@
+"""Manage tags."""
+
+#
+#  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/>.
+#
+from typing import Any
+
+
+# noinspection PyMissingConstructor
+class Tags(dict[Any, Any]):
+    """A dict-like object that silently drops keys with None in their values.
+
+    A key will be dropped if:
+    * its value is None
+    * its value is a list containing None
+    * its value is a dict with None in its values
+    """
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:  # noqa: ANN401
+        """Initialize a Tags object."""
+        self.update(*args, **kwargs)
+
+    def __setitem__(self, k: Any, v: Any) -> None:  # noqa: ANN401
+        """Set an item only if it should not be dropped."""
+        if not (
+            v is None
+            or (isinstance(v, list) and (None in v or "None" in v))
+            or (isinstance(v, dict) and (None in v.values() or "None" in v.values()))
+        ):
+            super().__setitem__(k, v)
+
+    def update(self, *args: Any, **kwargs: Any) -> None:  # noqa: ANN401
+        """See base class."""
+        for key, value in dict(*args, **kwargs).items():
+            self[key] = value

audiolibrarian/audiosource.py

@@ -0,0 +1,215 @@
+"""AudioSource."""
+
+#
+#  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 abc
+import logging
+import os
+import pathlib
+import shutil
+import subprocess
+import tempfile
+from collections.abc import Callable  # noqa: TC003
+
+import discid
+
+from audiolibrarian import audiofile, records, sh, text
+from audiolibrarian.settings import SETTINGS
+
+log = logging.getLogger(__name__)
+
+
+class AudioSource(abc.ABC):
+    """An abstract base class for AudioSource classes."""
+
+    def __init__(self) -> None:
+        """Initialize an AudioSource."""
+        self._temp_dir: pathlib.Path = pathlib.Path(tempfile.mkdtemp())
+        self._source_list: list[pathlib.Path | None] | None = None
+
+    def __del__(self) -> None:
+        """Remove any temp files."""
+        if self._temp_dir.is_dir():
+            shutil.rmtree(self._temp_dir)
+
+    @property
+    def source_list(self) -> list[pathlib.Path | None]:
+        """Return a list with source file paths and blanks.
+
+        The list will be ordered by track number, with None in spaces where no
+        filename is present for that track number.
+        """
+        if not self._source_list:
+            source_filenames = self.get_source_filenames()
+            length = max(text.get_track_number(str(f.name)) for f in source_filenames)
+            result: list[pathlib.Path | None] = [None] * length
+            if length:
+                for filename in source_filenames:
+                    idx = text.get_track_number(str(filename.name)) - 1
+                    result[idx] = filename
+            self._source_list = result
+        return self._source_list
+
+    def copy_wavs(self, dest_dir: pathlib.Path) -> None:
+        """Copy wav files to the given destination directory."""
+        for filename in self.get_wav_filenames():
+            shutil.copy2(filename, dest_dir / filename.name)
+
+    def get_front_cover(self) -> records.FrontCover | None:
+        """Return a FrontCover record or None."""
+        return None
+
+    @abc.abstractmethod
+    def get_search_data(self) -> dict[str, str]:
+        """Return a dictionary of search data useful for doing a MusicBrainz search."""
+
+    @abc.abstractmethod
+    def get_source_filenames(self) -> list[pathlib.Path]:
+        """Return a list of the original source file paths."""
+
+    def get_wav_filenames(self) -> list[pathlib.Path]:
+        """Return a list of the prepared wav file paths."""
+        return sorted(self._temp_dir.glob("*.wav"), key=text.alpha_numeric_key)
+
+    @abc.abstractmethod
+    def prepare_source(self) -> None:
+        """Convert the source to wav files."""
+
+
+class CDAudioSource(AudioSource):
+    """AudioSource from a compact disc."""
+
+    def __init__(self) -> None:
+        """Initialize a CDAudioSource."""
+        super().__init__()
+        self._cd = discid.read(SETTINGS.discid_device, features=["mcn"])
+
+    def get_search_data(self) -> dict[str, str]:
+        """Return a dictionary of search data useful for doing a MusicBrainz search."""
+        return {"disc_id": self._cd.id, "disc_mcn": self._cd.mcn}
+
+    def get_source_filenames(self) -> list[pathlib.Path]:
+        """Return a list of the original source file paths.
+
+        Since we're working with a CD, these files may not yet exist if they have not been
+        read from the disc.
+        """
+        return [
+            self._temp_dir / f"track{str(n + 1).zfill(2)}.cdda.wav"
+            for n in range(self._cd.last_track_num)
+        ]
+
+    def prepare_source(self) -> None:
+        """Pull audio from the CD to wav files."""
+        cwd = pathlib.Path.cwd()
+        os.chdir(self._temp_dir)
+        try:
+            subprocess.run(("cd-paranoia", "-B"), check=True)  # noqa: S603
+        finally:
+            os.chdir(cwd)
+        subprocess.run(("eject",), check=False)  # noqa: S603
+
+
+class FilesAudioSource(AudioSource):
+    """AudioSource from local files."""
+
+    def __init__(self, filenames: list[pathlib.Path]) -> None:
+        """Initialize a FilesAudioSource."""
+        super().__init__()
+        self._filenames = filenames
+        if len(filenames) == 1 and filenames[0].is_dir():
+            # If we're given a directory, figure out what's in there.
+            for file_type in ("flac", "wav", "m4a", "mp3"):
+                if fns := sorted(filenames[0].glob(f"*.{file_type}"), key=text.alpha_numeric_key):
+                    self._filenames = list(fns)
+                    break
+        self._file_type = self._filenames[0].suffix.lstrip(".")
+
+    def get_front_cover(self) -> records.FrontCover | None:
+        """Return a FrontCover record or None."""
+        for filename in self._filenames:
+            one_track = audiofile.AudioFile.open(filename).one_track
+            release = one_track.release
+            if release.front_cover:
+                return release.front_cover
+        return None
+
+    def get_search_data(self) -> dict[str, str]:
+        """Return a dictionary of search data useful for doing a MusicBrainz search."""
+        for filename in self._filenames:
+            one_track = audiofile.AudioFile.open(filename).one_track
+            release = one_track.release
+            track = one_track.track
+
+            artist = track.artist or track.artists.first or "" if track else ""
+            album = release.album or "" if release else ""
+            mb_artist_id = (
+                release.musicbrainz_album_artist_ids.first
+                if release and release.musicbrainz_album_artist_ids
+                else "" or track.musicbrainz_artist_ids.first
+                if track and track.musicbrainz_artist_ids
+                else "" or ""
+            )
+            mb_release_id = release.musicbrainz_album_id or "" if release else ""
+            log.info("Artist from tags: %s", artist)
+            log.info("Album from tags: %s", album)
+            log.info("MB Artist ID from tags: %s", mb_artist_id)
+            log.info("MB Release ID from tags: %s", mb_release_id)
+            if mb_artist_id and mb_release_id:
+                return {"mb_artist_id": mb_artist_id, "mb_release_id": mb_release_id}
+            if artist and album:
+                return {"artist": artist, "album": album}
+        return {}
+
+    def get_source_filenames(self) -> list[pathlib.Path]:
+        """Return a list of the original source file paths."""
+        return self._filenames
+
+    def prepare_source(self) -> None:
+        """Convert the source files to wav files.
+
+        Raises:
+             ValueError if the file type is not supported.
+        """
+        decoders: dict[str, Callable[[str, str], tuple[str, ...]]] = {
+            "flac": lambda i, o: ("flac", "--silent", "--decode", f"--output-name={o}", i),
+            "m4a": lambda i, o: ("faad", "-q", "-o", o, i),
+            "mp3": lambda i, o: ("mpg123", "-q", "-w", o, i),
+        }
+        try:
+            decode = decoders[self._file_type]
+        except KeyError as err:
+            msg = f"Unsupported source file type: {self._file_type}"
+            raise ValueError(msg) from err
+        tmp_dir = self._temp_dir / "__tmp__"
+        tmp_dir.mkdir(parents=True)
+        commands: list[tuple[str, ...]] = []
+        for track_number, filepath in enumerate(self.source_list, 1):
+            if filepath:
+                in_ = str(filepath)
+                out_path = tmp_dir / f"{str(track_number).zfill(2)}__.wav"
+                out = str(out_path)
+                commands.append(decode(in_, out))
+                log.info("DECODING: %s -> %s", filepath.name, out_path.name)
+        sh.parallel(f"Making {len(commands)} wav files...", commands)
+        sh.touch(tmp_dir.glob("*.wav"))
+        for filename in sorted(tmp_dir.glob("*.wav"), key=text.alpha_numeric_key):
+            subprocess.run(  # noqa: S603
+                ("sndfile-convert", "-pcm16", filename, str(filename).replace("/__tmp__/", "/")),
+                check=True,
+            )
+        shutil.rmtree(tmp_dir)