audiolibrarian 0.16.2__py3-none-any.whl

audiolibrarian/__init__.py

@@ -0,0 +1,19 @@
+"""The audiolibrarian package."""
+
+#
+#  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/>.
+#
+__version__ = "0.16.2"

audiolibrarian/audiofile/__init__.py

@@ -0,0 +1,23 @@
+"""Audio file library."""
+
+#
+#  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 audiolibrarian.audiofile.audiofile import AudioFile
+from audiolibrarian.audiofile.tags import Tags
+
+__all__ = ["AudioFile", "Tags"]

audiolibrarian/audiofile/audiofile.py

@@ -0,0 +1,114 @@
+"""Audio file library."""
+
+#
+#  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 importlib
+import pathlib
+from typing import Any, ClassVar
+
+import mutagen
+
+from audiolibrarian import records
+
+
+class AudioFile(abc.ABC):
+    """Abstract base class for AudioFile classes."""
+
+    _subclass_by_extension: ClassVar[dict[str, type["AudioFile"]]] = {}
+
+    def __init__(self, filepath: pathlib.Path) -> None:
+        """Initialize an AudioFile."""
+        self._filepath = filepath
+        self._mut_file = mutagen.File(self.filepath.absolute())
+        self._one_track = self.read_tags()
+
+    def __init_subclass__(cls, extensions: set[str], **kwargs: dict[str, Any]) -> None:
+        """Initialize an AudioFile subclass."""
+        super().__init_subclass__(**kwargs)
+        for extension in extensions:
+            cls._subclass_by_extension[extension] = cls
+
+    def __repr__(self) -> str:
+        """Return a string representation of the AudioFile."""
+        return f"AudioFile: {self.filepath}"
+
+    @classmethod
+    def extensions(cls) -> set[str]:
+        """Return the list of supported extensions."""
+        return set(cls._subclass_by_extension.keys())
+
+    @classmethod
+    def open(cls, filename: str | pathlib.Path) -> "AudioFile":
+        """Return an AudioFile object based on the filename extension (factory method).
+
+        Args:
+            filename: The filename of a supported audio file.
+
+        Returns:
+            audiofile.AudioFile: An AudioFile object.
+
+        Raises:
+            FileNotFoundError: If the file cannot be found or is not a file.
+            NotImplementedError: If the type of the file is not supported.
+        """
+        if not AudioFile._subclass_by_extension:
+            # Dynamically load submodules.
+            for module_path in (pathlib.Path(__file__).parent / "formats").glob("*.py"):
+                if module_path.name == "__init__.py":
+                    continue
+                importlib.import_module(f"audiolibrarian.audiofile.formats.{module_path.stem}")
+
+        filepath = pathlib.Path(filename).resolve()
+        if not filepath.is_file():
+            raise FileNotFoundError(filepath)
+        if filepath.suffix not in AudioFile._subclass_by_extension:
+            msg = f"Unknown file type: {filepath}"
+            raise NotImplementedError(msg)
+        return AudioFile._subclass_by_extension[filepath.suffix](filepath=filepath)
+
+    @property
+    def filepath(self) -> pathlib.Path:
+        """Return the audio file's path."""
+        return self._filepath
+
+    @property
+    def one_track(self) -> records.OneTrack:
+        """Return the OneTrack representation of the audio file."""
+        return self._one_track
+
+    @one_track.setter
+    def one_track(self, one_track: records.OneTrack) -> None:
+        """Set the OneTrack representation of the audio file."""
+        self._one_track = one_track
+
+    @abc.abstractmethod
+    def read_tags(self) -> records.OneTrack:
+        """Read the tags from the audio file and return a populated OneTrack record."""
+
+    @abc.abstractmethod
+    def write_tags(self) -> None:
+        """Write the tags to the audio file."""
+
+    def _get_tag_sources(self) -> tuple[records.Release, int, records.Medium, int, records.Track]:
+        # Return the objects and information required to generate tags.
+        release = self.one_track.release or records.Release()
+        medium_number = self.one_track.medium_number
+        medium = self.one_track.medium or records.Medium()
+        track_number = self.one_track.track_number
+        track = self.one_track.track or records.Track()
+        return release, medium_number, medium, track_number, track

audiolibrarian/audiofile/formats/__init__.py

@@ -0,0 +1 @@
+"""AudioFile formats."""

audiolibrarian/audiofile/formats/flac.py

@@ -0,0 +1,207 @@
+"""AudioFile support for flac 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/>.
+#
+import re
+from typing import Any
+
+import mutagen.flac
+
+from audiolibrarian import audiofile, records
+
+
+class FlacFile(audiofile.AudioFile, extensions={".flac"}):
+    """AudioFile for Flac files."""
+
+    def read_tags(self) -> records.OneTrack:
+        """Read the tags and return a OneTrack object."""
+
+        def listf(lst: list[Any] | None) -> records.ListF | None:
+            if lst is None:
+                return None
+            return records.ListF(lst)
+
+        mut = self._mut_file
+        front_cover = None
+        if self._mut_file.pictures:
+            cover = self._mut_file.pictures[0]
+            front_cover = records.FrontCover(
+                data=cover.data, desc=cover.desc or "", mime=cover.mime
+            )
+        medium_count = int(mut["disctotal"][0]) if mut.get("disctotal") else None
+        medium_number = int(mut["discnumber"][0]) if mut.get("discnumber") else None
+        track_count = int(mut["tracktotal"][0]) if mut.get("tracktotal") else None
+        track_number = int(mut["tracknumber"][0]) if mut.get("tracknumber") else None
+        release = (
+            records.Release(
+                album=mut.get("album", [None])[0],
+                album_artists=listf(mut.get("albumartist")),
+                album_artists_sort=listf(mut.get("albumartistsort")),
+                asins=mut.get("asin"),
+                barcodes=mut.get("barcode"),
+                catalog_numbers=mut.get("catalognumber"),
+                date=mut.get("date", [None])[0],
+                front_cover=front_cover,
+                genres=listf(mut.get("genre")),
+                labels=mut.get("label"),
+                media={
+                    medium_number: records.Medium(
+                        formats=listf(mut.get("media")),
+                        titles=mut.get("discsubtitle"),
+                        track_count=track_count,
+                        tracks={
+                            track_number: records.Track(
+                                artist=mut.get("artist", [None])[0],
+                                artists=listf(mut.get("artists")),
+                                artists_sort=mut.get("artistsort"),
+                                file_info=records.FileInfo(
+                                    bitrate=mut.info.bitrate // 1000,
+                                    bitrate_mode=records.BitrateMode.CBR,
+                                    path=self.filepath,
+                                    type=records.FileType.FLAC,
+                                ),
+                                isrcs=mut.get("isrc"),
+                                musicbrainz_artist_ids=listf(mut.get("musicbrainz_artistid")),
+                                musicbrainz_release_track_id=mut.get(
+                                    "musicbrainz_releasetrackid", [None]
+                                )[0],
+                                musicbrainz_track_id=mut.get("musicbrainz_trackid", [None])[0],
+                                title=mut.get("title", [None])[0],
+                                track_number=track_number,
+                            )
+                        }
+                        if track_number
+                        else None,
+                    )
+                }
+                if medium_number
+                else None,
+                medium_count=medium_count,
+                musicbrainz_album_artist_ids=listf(mut.get("musicbrainz_albumartistid")),
+                musicbrainz_album_id=mut.get("musicbrainz_albumid", [None])[0],
+                musicbrainz_release_group_id=mut.get("musicbrainz_releasegroupid", [None])[0],
+                original_date=mut.get("originaldate", [None])[0],
+                original_year=mut["originalyear"][0] if mut.get("originalyear") else None,
+                people=(
+                    records.People(
+                        arrangers=mut.get("arranger"),
+                        composers=mut.get("composer"),
+                        conductors=mut.get("conductor"),
+                        engineers=mut.get("engineer"),
+                        lyricists=mut.get("lyricist"),
+                        mixers=mut.get("mixer"),
+                        performers=mut.get("performer")
+                        and self._parse_performer_tag(mut["performer"]),
+                        producers=mut.get("producer"),
+                        writers=mut.get("writer"),
+                    )
+                    or None
+                ),
+                release_countries=mut.get("releasecountry"),
+                release_statuses=mut.get("releasestatus"),
+                release_types=mut.get("releasetype"),
+                script=mut.get("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
+        )
+
+    def write_tags(self) -> None:
+        """Write the tags."""
+        release, medium_number, medium, track_number, track = self._get_tag_sources()
+        tags_ = {
+            "album": [release.album],
+            "albumartist": release.album_artists,
+            "albumartistsort": release.album_artists_sort,
+            "arranger": release.people and release.people.arrangers,
+            "artist": [track.artist],
+            "artists": track.artists,
+            "artistsort": track.artists_sort,
+            "asin": release.asins,
+            "barcode": release.barcodes,
+            "catalognumber": release.catalog_numbers,
+            "composer": release.people and release.people.composers,
+            "conductor": release.people and release.people.conductors,
+            "date": [release.date],
+            "discnumber": [str(medium_number)],
+            "discsubtitle": medium.titles,
+            "disctotal": [str(release.medium_count)],
+            "engineer": release.people and release.people.engineers,
+            "genre": release.genres,
+            "isrc": track.isrcs,
+            "label": release.labels,
+            "lyricist": release.people and release.people.lyricists,
+            "media": medium.formats,
+            "mixer": release.people and release.people.mixers,
+            "musicbrainz_albumartistid": release.musicbrainz_album_artist_ids,
+            "musicbrainz_albumid": [release.musicbrainz_album_id],
+            "musicbrainz_artistid": track.musicbrainz_artist_ids,
+            "musicbrainz_releasegroupid": [release.musicbrainz_release_group_id],
+            "musicbrainz_releasetrackid": [track.musicbrainz_release_track_id],
+            "musicbrainz_trackid": [track.musicbrainz_track_id],
+            "originaldate": [release.original_date],
+            "originalyear": [str(release.original_year)],
+            "performer": self._make_performer_tag(release.people and release.people.performers),
+            "producer": release.people and release.people.producers,
+            "releasecountry": release.release_countries,
+            "releasestatus": release.release_statuses,
+            "releasetype": release.release_types,
+            "script": [release.script],
+            "title": [track.title],
+            "totaldiscs": [str(release.medium_count)],
+            "totaltracks": [str(medium.track_count)],
+            "tracknumber": [str(track_number)],
+            "tracktotal": [str(medium.track_count)],
+            "writer": release.people and release.people.writers,
+        }
+        tags_ = audiofile.Tags(tags_)
+        self._mut_file.delete()  # Clear old tags.
+        self._mut_file.clear_pictures()
+        self._mut_file.update(tags_)
+
+        if release.front_cover is not None:
+            cover = mutagen.flac.Picture()  # type: ignore[no-untyped-call]
+            cover.type = 3
+            cover.mime = release.front_cover.mime
+            cover.desc = release.front_cover.desc or ""
+            cover.data = release.front_cover.data
+            self._mut_file.add_picture(cover)
+
+        self._mut_file.save()
+
+    @staticmethod
+    def _make_performer_tag(performers: list[records.Performer] | None | Any) -> list[str] | None:  # noqa: ANN401
+        # Return a list of performer tag strings "name (instrument)".
+        if performers is None:
+            return None
+        return [f"{p.name} ({p.instrument})" for p in performers]
+
+    @staticmethod
+    def _parse_performer_tag(performers_tag: list[str]) -> list[records.Performer]:
+        # Parse a list of performer tags and return a list of Performer objects.
+        performer_re = re.compile(r"(?P<name>.*)\((?P<instrument>.*)\)")
+        performers = []
+        for tag in performers_tag:
+            if match := performer_re.match(tag):
+                name = match.groupdict()["name"].strip()
+                instrument = match.groupdict()["instrument"].strip()
+                performers.append(records.Performer(name=name, instrument=instrument))
+        return performers

audiolibrarian/audiofile/formats/m4a.py

@@ -0,0 +1,221 @@
+"""AudioFile support for m4a 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 logging import getLogger
+from typing import Any
+
+import mutagen.mp4
+
+from audiolibrarian import audiofile, records
+
+log = getLogger(__name__)
+ITUNES = "----:com.apple.iTunes"
+
+
+class M4aFile(audiofile.AudioFile, extensions={".m4a"}):
+    """AudioFile for M4A files."""
+
+    def read_tags(self) -> records.OneTrack:
+        """Read the tags and return a OneTrack object."""
+
+        def get_str(key: str) -> str | None:
+            # Return first element for the given key, utf8-decoded.
+            if mut.get(key) is None:
+                return None
+            return str(mut.get(key)[0].decode("utf8"))
+
+        def get_strl(key: str) -> records.ListF | None:
+            # Return all elements for a given key, utf8-decoded.
+            if mut.get(key) is None:
+                return None
+            return records.ListF([x.decode("utf8") for x in mut.get(key)])
+
+        def listf(key: str) -> records.ListF | None:
+            # Return a ListF object for a given key.
+            if mut.get(key) is None:
+                return None
+            return records.ListF(mut.get(key))
+
+        mut = self._mut_file
+
+        front_cover = None
+        if mut.get("covr"):
+            cover = mut["covr"][0]
+            # noinspection PyUnresolvedReferences
+            mime = (
+                "image/png" if cover.imageformat == mutagen.mp4.AtomDataType.PNG else "image/jpg"
+            )
+            front_cover = records.FrontCover(data=bytes(cover), mime=mime)
+        medium_count = int(mut["disk"][0][1]) if mut.get("disk") else None
+        medium_number = int(mut["disk"][0][0]) if mut.get("disk") else None
+        track_count = int(mut["trkn"][0][1]) if mut.get("trkn") else None
+        track_number = int(mut["trkn"][0][0]) if mut.get("trkn") else None
+        release = (
+            records.Release(
+                album=mut.get("\xa9alb", [None])[0],
+                album_artists=listf("aART"),
+                album_artists_sort=listf("soaa"),
+                asins=get_strl(f"{ITUNES}:ASIN"),
+                barcodes=get_strl(f"{ITUNES}:BARCODE"),
+                catalog_numbers=get_strl(f"{ITUNES}:CATALOGNUMBER"),
+                date=mut.get("\xa9day", [None])[0],
+                front_cover=front_cover,
+                genres=listf("\xa9gen"),
+                labels=get_strl(f"{ITUNES}:LABEL"),
+                media={
+                    medium_number: records.Medium(
+                        formats=get_strl(f"{ITUNES}:MEDIA"),
+                        titles=get_strl(f"{ITUNES}:DISCSUBTITLE"),
+                        track_count=track_count,
+                        tracks={
+                            track_number: records.Track(
+                                artist=mut.get("\xa9ART", [None])[0],
+                                artists=get_strl(f"{ITUNES}:ARTISTS"),
+                                artists_sort=mut.get("soar"),
+                                file_info=records.FileInfo(
+                                    bitrate=mut.info.bitrate // 1000,
+                                    bitrate_mode=records.BitrateMode.CBR,
+                                    path=self.filepath,
+                                    type=records.FileType.AAC,
+                                ),
+                                isrcs=get_strl(f"{ITUNES}:ISRC"),
+                                musicbrainz_artist_ids=get_strl(f"{ITUNES}:MusicBrainz Artist Id"),
+                                musicbrainz_release_track_id=get_str(
+                                    f"{ITUNES}:MusicBrainz Release Track Id"
+                                ),
+                                musicbrainz_track_id=get_str(f"{ITUNES}:MusicBrainz Track Id"),
+                                title=mut.get("\xa9nam", [None])[0],
+                                track_number=int(mut["trkn"][0][0]) if mut.get("trkn") else None,
+                            )
+                        }
+                        if track_number
+                        else None,
+                    )
+                }
+                if medium_number
+                else None,
+                medium_count=medium_count,
+                musicbrainz_album_artist_ids=get_strl(f"{ITUNES}:MusicBrainz Album Artist Id"),
+                musicbrainz_album_id=get_str(f"{ITUNES}:MusicBrainz Album Id"),
+                musicbrainz_release_group_id=get_str(f"{ITUNES}:MusicBrainz Release Group Id"),
+                original_date=get_str(f"{ITUNES}:originaldate"),
+                original_year=get_str(f"{ITUNES}:originalyear") or None,
+                people=(
+                    records.People(
+                        arrangers=get_strl(f"{ITUNES}:ARRANGER"),
+                        composers=get_strl(f"{ITUNES}:COMPOSER"),
+                        conductors=get_strl(f"{ITUNES}:CONDUCTOR"),
+                        engineers=get_strl(f"{ITUNES}:ENGINEER"),
+                        lyricists=get_strl(f"{ITUNES}:LYRICIST"),
+                        mixers=get_strl(f"{ITUNES}:MIXER"),
+                        producers=get_strl(f"{ITUNES}:PRODUCER"),
+                        performers=None,
+                        writers=get_strl(f"{ITUNES}:WRITER"),
+                    )
+                    or None
+                ),
+                release_countries=get_strl(f"{ITUNES}:MusicBrainz Album Release Country"),
+                release_statuses=get_strl(f"{ITUNES}:MusicBrainz Album Status"),
+                release_types=get_strl(f"{ITUNES}:MusicBrainz Album Type"),
+                script=get_str(f"{ITUNES}:SCRIPT"),
+            )
+            or None
+        )
+        if release:
+            release.source = records.Source.TAGS
+        return records.OneTrack(
+            release=release, medium_number=medium_number, track_number=track_number
+        )
+
+    def write_tags(self) -> None:
+        """Write the tags."""
+
+        def ff(text: int | str | None) -> bytes | None:
+            if text is None:
+                return None
+            return mutagen.mp4.MP4FreeForm(bytes(str(text), "utf8"))  # type: ignore[no-untyped-call]
+
+        def ffl(list_: list[str] | None | Any) -> records.ListF | None:  # noqa: ANN401
+            if not list_:
+                return None
+            return records.ListF([ff(x) for x in list_])
+
+        # Note: We don't write "performers" to m4a files.
+        release, medium_number, medium, track_number, track = self._get_tag_sources()
+        front_cover = None
+        if (cover := release.front_cover) is not None:
+            # noinspection PyUnresolvedReferences
+            image_format = (
+                mutagen.mp4.AtomDataType.PNG
+                if cover.mime == "image/png"
+                else mutagen.mp4.AtomDataType.JPEG
+            )
+            front_cover = [
+                mutagen.mp4.MP4Cover(cover.data, imageformat=image_format)  # type: ignore[no-untyped-call]
+            ]
+        tags_ = {
+            f"{ITUNES}:ARRANGER": ffl(release.people and release.people.arrangers),
+            f"{ITUNES}:ARTISTS": ffl(track.artists),
+            f"{ITUNES}:ASIN": ffl(release.asins),
+            f"{ITUNES}:BARCODE": ffl(release.barcodes),
+            f"{ITUNES}:CATALOGNUMBER": ffl(release.catalog_numbers),
+            f"{ITUNES}:COMPOSER": ffl(release.people and release.people.composers),
+            f"{ITUNES}:CONDUCTOR": ffl(release.people and release.people.conductors),
+            f"{ITUNES}:DISCSUBTITLE": ffl(medium.titles),
+            f"{ITUNES}:ENGINEER": ffl(release.people and release.people.engineers),
+            f"{ITUNES}:ISRC": ffl(track.isrcs),
+            f"{ITUNES}:LABEL": ffl(release.labels),
+            f"{ITUNES}:LYRICIST": ffl(release.people and release.people.lyricists),
+            f"{ITUNES}:MEDIA": ffl(medium.formats),
+            f"{ITUNES}:MIXER": ffl(release.people and release.people.mixers),
+            f"{ITUNES}:MusicBrainz Album Artist Id": ffl(release.musicbrainz_album_artist_ids),
+            f"{ITUNES}:MusicBrainz Album Id": [ff(release.musicbrainz_album_id)],
+            f"{ITUNES}:MusicBrainz Album Release Country": ffl(release.release_countries),
+            f"{ITUNES}:MusicBrainz Album Status": ffl(release.release_statuses),
+            f"{ITUNES}:MusicBrainz Album Type": ffl(release.release_types),
+            f"{ITUNES}:MusicBrainz Artist Id": ffl(track.musicbrainz_artist_ids),
+            f"{ITUNES}:MusicBrainz Release Group Id": [ff(release.musicbrainz_release_group_id)],
+            f"{ITUNES}:MusicBrainz Release Track Id": [ff(track.musicbrainz_release_track_id)],
+            f"{ITUNES}:MusicBrainz Track Id": [ff(track.musicbrainz_track_id)],
+            f"{ITUNES}:originaldate": [ff(release.original_date)],
+            f"{ITUNES}:originalyear": [ff(release.original_year)],
+            f"{ITUNES}:PRODUCER": ffl(release.people and release.people.producers),
+            f"{ITUNES}:SCRIPT": [ff(release.script)],
+            f"{ITUNES}:WRITER": ffl(release.people and release.people.writers),
+            "\xa9alb": [release.album],
+            "\xa9ART": [track.artist],
+            "\xa9day": [release.date],
+            "\xa9gen": release.genres,
+            "\xa9nam": [track.title],
+            "aART": release.album_artists,
+            "covr": front_cover,
+            "disk": [(medium_number, release.medium_count)] if medium_number else None,
+            "soaa": release.album_artists_sort,
+            "soar": track.artists_sort,
+            "trkn": [(track_number, medium.track_count)] if track_number else None,
+        }
+        tags_ = audiofile.Tags(tags_)
+
+        for key, value in tags_.items():
+            try:
+                self._mut_file[key] = value
+            except Exception:  # pragma: no cover
+                log.critical("ERROR: %s %s", key, value)
+                raise
+
+        self._mut_file.save()