eyeD3 0.9.8a1__py3-none-any.whl

eyed3/plugins/genres.py

@@ -0,0 +1,48 @@
+import math
+from eyed3 import id3
+from eyed3.plugins import Plugin
+
+
+class GenreListPlugin(Plugin):
+    SUMMARY = "Display the full list of standard ID3 genres."
+    DESCRIPTION = "ID3 v1 defined a list of genres and mapped them to "\
+                  "to numeric values so they can be stored as a single "\
+                  "byte.\nIt is *recommended* that these genres are used "\
+                  "although most newer software (including eyeD3) does not "\
+                  "care."
+    NAMES = ["genres"]
+
+    def __init__(self, arg_parser):
+        super(GenreListPlugin, self).__init__(arg_parser)
+        self.arg_group.add_argument("-1", "--single-column", action="store_true",
+                                    help="List on genre per line.")
+
+    def start(self, args, config):
+        self._printGenres(args)
+
+    @staticmethod
+    def _printGenres(args):
+        # Filter out 'Unknown'
+        genre_ids = [i for i in id3.genres
+                        if type(i) is int and id3.genres[i] is not None]
+        genre_ids.sort()
+
+        if args.single_column:
+            for gid in genre_ids:
+                print("%3d: %s" % (gid, id3.genres[gid]))
+        else:
+            offset = int(math.ceil(float(len(genre_ids)) / 2))
+            for i in range(offset):
+                if i < len(genre_ids):
+                    c1 = "%3d: %s" % (i, id3.genres[i])
+                else:
+                    c1 = ""
+                if (i * 2) < len(genre_ids):
+                    try:
+                        c2 = "%3d: %s" % (i + offset, id3.genres[i + offset])
+                    except IndexError:
+                        break
+                else:
+                    c2 = ""
+                print(c1 + (" " * (40 - len(c1))) + c2)
+            print("")

eyed3/plugins/itunes.py

@@ -0,0 +1,64 @@
+from eyed3.plugins import LoaderPlugin
+from eyed3.id3.apple import PCST, PCST_FID, WFED, WFED_FID
+
+
+class Podcast(LoaderPlugin):
+    NAMES = ['itunes-podcast']
+    SUMMARY = "Adds (or removes) the tags necessary for Apple iTunes to "\
+              "identify the file as a podcast."
+
+    def __init__(self, arg_parser):
+        super(Podcast, self).__init__(arg_parser)
+        g = self.arg_group
+        g.add_argument("--add", action="store_true",
+                       help="Add the podcast frames.")
+        g.add_argument("--remove", action="store_true",
+                       help="Remove the podcast frames.")
+
+    def _add(self, tag):
+        save = False
+        if PCST_FID not in tag.frame_set:
+            tag.frame_set[PCST_FID] = PCST()
+            save = True
+        if WFED_FID not in tag.frame_set:
+            tag.frame_set[WFED_FID] = WFED("http://eyeD3.nicfit.net/")
+            save = True
+
+        if save:
+            print("\tAdding...")
+            tag.save(backup=self.args.backup)
+            self._printStatus(tag)
+
+    def _remove(self, tag):
+        save = False
+        for fid in [PCST_FID, WFED_FID]:
+            try:
+                del tag.frame_set[fid]
+                save = True
+            except KeyError:
+                continue
+
+        if save:
+            print("\tRemoving...")
+            tag.save(backup=self.args.backup)
+            self._printStatus(tag)
+
+    def _printStatus(self, tag):
+        status = ":-("
+        if PCST_FID in tag.frame_set:
+            status = ":-/"
+            if WFED_FID in tag.frame_set:
+                status = ":-)"
+        print("\tiTunes podcast? %s" % status)
+
+    def handleFile(self, f):
+        super(Podcast, self).handleFile(f)
+
+        if self.audio_file and self.audio_file.tag:
+            print(f)
+            tag = self.audio_file.tag
+            self._printStatus(tag)
+            if self.args.remove:
+                self._remove(self.audio_file.tag)
+            elif self.args.add:
+                self._add(self.audio_file.tag)

eyed3/plugins/jsontag.py

@@ -0,0 +1,133 @@
+import base64
+import inspect
+import dataclasses
+from json import dumps
+
+import eyed3.core
+import eyed3.plugins
+import eyed3.id3.tag
+import eyed3.id3.headers
+
+from eyed3.utils.log import getLogger
+
+log = getLogger(__name__)
+
+
+class JsonTagPlugin(eyed3.plugins.LoaderPlugin):
+    NAMES = ["json"]
+    SUMMARY = "Outputs all tags as JSON."
+
+    def __init__(self, arg_parser):
+        super().__init__(arg_parser, cache_files=True, track_images=False)
+        g = self.arg_group
+        g.add_argument("-c", "--compact", action="store_true",
+                       help="Output in compact form, wound new lines or indentation.")
+        g.add_argument("-s", "--sort", action="store_true", help="Output JSON in sorted by key.")
+
+    def handleFile(self, f, *args, **kwargs):
+        super().handleFile(f)
+        if self.audio_file and self.audio_file.info and self.audio_file.tag:
+            json = audioFileToJson(self.audio_file)
+            print(dumps(json, indent=2 if not self.args.compact else None,
+                        sort_keys=self.args.sort))
+
+
+def audioFileToJson(audio_file):
+    tag = audio_file.tag
+
+    tdict = dict(path=audio_file.path, info=dataclasses.asdict(audio_file.info))
+
+    # Tag fields
+    for name in [m for m in sorted(dir(tag)) if not m.startswith("_") and m not in _tag_exclusions]:
+        member = getattr(tag, name)
+
+        if name not in _tag_map:
+            if not inspect.ismethod(member) and not inspect.isfunction(member):
+                log.warning(f"Unhandled Tag member: {name}")
+            continue
+        elif member is None:
+            continue
+        elif member.__class__ is not _tag_map[name]:
+            log.warning(f"Unexpected type for member {name}: {member.__class__}")
+            continue
+
+        if isinstance(member, (str, int, bool)):
+            tdict[name] = member
+        elif isinstance(member, eyed3.core.Date):
+            tdict[name] = str(member)
+        elif isinstance(member, eyed3.id3.Genre):
+            tdict[name] = member.name
+        elif isinstance(member, bytes):
+            tdict[name] = base64.b64encode(member).decode("ascii")
+        elif isinstance(member, eyed3.id3.tag.ArtistOrigin):
+            ...  # TODO
+        elif isinstance(member, (eyed3.core.CountAndTotalTuple,)):
+            if any(member):
+                tdict[name] = member._asdict()
+        elif isinstance(member, (list, tuple)):
+            ...  # TODO
+        elif isinstance(member, eyed3.id3.tag.AccessorBase):
+            ...  # TODO
+        elif isinstance(member, (eyed3.id3.tag.TagHeader, eyed3.id3.tag.ExtendedTagHeader,
+                                 eyed3.id3.tag.FileInfo, eyed3.id3.frames.FrameSet)):
+            ...  # TODO
+        else:
+            log.warning(f"Unhandled tag member {name}, type {member.__class__.__name__})")
+
+    tdict["_eyeD3"] = eyed3.__about__.__version__
+    return tdict
+
+
+_tag_map = {
+    'album': str,
+    'album_artist': str,
+    'album_type': str,
+    'artist': str,
+    'original_artist': str,
+    'artist_origin': list,
+    'artist_url': str,
+    'audio_file_url': str,
+    'audio_source_url': str,
+    'best_release_date': eyed3.core.Date,
+    'bpm': int,
+    'cd_id': bytes,
+    'chapters': eyed3.id3.tag.ChaptersAccessor,
+    'comments': eyed3.id3.tag.CommentsAccessor,
+    'commercial_url': str,
+    'composer': str,
+    'copyright_url': str,
+    'disc_num': eyed3.core.CountAndTotalTuple,
+    'encoding_date': eyed3.core.Date,
+    'extended_header': eyed3.id3.headers.ExtendedTagHeader,
+    'file_info': eyed3.id3.tag.FileInfo,
+    'frame_set': eyed3.id3.frames.FrameSet,
+    'genre': eyed3.id3.Genre,
+    'header': eyed3.id3.headers.TagHeader,
+    'images': eyed3.id3.tag.ImagesAccessor,
+    'internet_radio_url': str,
+    'lyrics': eyed3.id3.tag.LyricsAccessor,
+    'non_std_genre': eyed3.id3.Genre,
+    'objects': eyed3.id3.tag.ObjectsAccessor,
+    'original_release_date': eyed3.core.Date,
+    'payment_url': str,
+    'play_count': int,
+    'popularities': eyed3.id3.tag.PopularitiesAccessor,
+    'privates': eyed3.id3.tag.PrivatesAccessor,
+    'publisher': str,
+    'publisher_url': str,
+    'recording_date': eyed3.core.Date,
+    'release_date': eyed3.core.Date,
+    'table_of_contents': eyed3.id3.tag.TocAccessor,
+    'tagging_date': eyed3.core.Date,
+    'terms_of_use': str,
+    'title': str,
+    'track_num': eyed3.core.CountAndTotalTuple,
+    'unique_file_ids': eyed3.id3.tag.UniqueFileIdAccessor,
+    'user_text_frames': eyed3.id3.tag.UserTextsAccessor,
+    'user_url_frames': eyed3.id3.tag.UserUrlsAccessor,
+    'version': tuple,
+}
+
+_tag_exclusions = {
+    "read_only": bool,
+}

eyed3/plugins/lameinfo.py

@@ -0,0 +1,86 @@
+import math
+from eyed3.utils import formatSize
+from eyed3.utils.console import printMsg, getTtySize
+from eyed3.plugins import LoaderPlugin
+
+
+class LameInfoPlugin(LoaderPlugin):
+    NAMES = ["lameinfo", "xing"]
+    SUMMARY = "Outputs lame header (if one exists) for file."
+    DESCRIPTION = (
+        "The 'lame' (or xing) header provides extra information about the mp3 "
+        "that is useful to players and encoders but not officially part of "
+        "the mp3 specification. Variable bit rate mp3s, for example, use this "
+        "header.\n\n"
+        "For more details see `here <http://gabriel.mp3-tech.org/mp3infotag.html>`_"
+       )
+
+    def printHeader(self, file_path):
+        w = getTtySize()[1]
+        printMsg(self._getFileHeader(file_path, w))
+        printMsg(self._getHardRule(w))
+
+    def handleFile(self, f, *_, **__):
+        super().handleFile(f)
+        if self.audio_file is None:
+            return
+
+        self.printHeader(f)
+        if (self.audio_file.info is None
+                or not self.audio_file.info.lame_tag):
+            printMsg("No LAME Tag")
+            return
+
+        lt = self.audio_file.info.lame_tag
+        if "infotag_crc" not in lt:
+            try:
+                printMsg(f"Encoder Version: {lt['encoder_version']}")
+            except KeyError:
+                pass
+            return
+
+        values = [("Encoder Version", lt['encoder_version']),
+                  ("LAME Tag Revision", lt['tag_revision']),
+                  ("VBR Method", lt['vbr_method']),
+                  ("Lowpass Filter", lt['lowpass_filter']),
+                  ]
+
+        if "replaygain" in lt:
+            try:
+                peak = lt["replaygain"]["peak_amplitude"]
+                db = 20 * math.log10(peak)
+                val = "%.8f (%+.1f dB)" % (peak, db)
+                values.append(("Peak Amplitude", val))
+            except KeyError:
+                pass
+            for type_ in ["radio", "audiofile"]:
+                try:
+                    gain = lt["replaygain"][type_]
+                    name = "%s Replay Gain" % gain['name'].capitalize()
+                    val = "%s dB (%s)" % (gain['adjustment'],
+                                          gain['originator'])
+                    values.append((name, val))
+                except KeyError:
+                    pass
+
+        values.append(("Encoding Flags", " ".join((lt["encoding_flags"]))))
+        if lt["nogap"]:
+            values.append(("No Gap", " and ".join(lt["nogap"])))
+        values.append(("ATH Type", lt["ath_type"]))
+        values.append(("Bitrate (%s)" % lt["bitrate"][1], lt["bitrate"][0]))
+        values.append(("Encoder Delay", "%s samples" % lt["encoder_delay"]))
+        values.append(("Encoder Padding", "%s samples" % lt["encoder_padding"]))
+        values.append(("Noise Shaping", lt["noise_shaping"]))
+        values.append(("Stereo Mode", lt["stereo_mode"]))
+        values.append(("Unwise Settings", lt["unwise_settings"]))
+        values.append(("Sample Frequency", lt["sample_freq"]))
+        values.append(("MP3 Gain", "%s (%+.1f dB)" % (lt["mp3_gain"],
+                                                      lt["mp3_gain"] * 1.5)))
+        values.append(("Preset", lt["preset"]))
+        values.append(("Surround Info", lt["surround_info"]))
+        values.append(("Music Length", "%s" % formatSize(lt["music_length"])))
+        values.append(("Music CRC-16", "%04X" % lt["music_crc"]))
+        values.append(("LAME Tag CRC-16", "%04X" % lt["infotag_crc"]))
+
+        for v in values:
+            printMsg(f"{v[0]:<20}: {v[1]}")

eyed3/plugins/lastfm.py

@@ -0,0 +1,50 @@
+from pylast import SIZE_EXTRA_LARGE, SIZE_LARGE, SIZE_MEDIUM, SIZE_MEGA, SIZE_SMALL
+from pylast import LastFMNetwork, WSError
+
+api_k = "a5f0ac61e7db2481b054ba52ff9a654f"
+api_s = "0c4a52ae5dcdbba1f9e782833a50b623"
+_network = None
+
+
+def Client():
+    global _network
+    if not _network:
+        _network = LastFMNetwork(api_key=api_k, api_secret=api_s)
+        _network.enable_rate_limit()
+    return _network
+
+
+def getArtist(artist):
+    return Client().get_artist(artist)
+
+
+def getAlbum(artist, title):
+    return Client().get_album(artist, title)
+
+
+def getAlbumArt(artist, title, size=SIZE_EXTRA_LARGE):
+    return _getArt(getAlbum(artist, title), size=size)
+
+
+def getArtistArt(artist, size=SIZE_EXTRA_LARGE):
+    return _getArt(getArtist(artist), size=size)
+
+
+def _getArt(obj, size=SIZE_EXTRA_LARGE):
+    try:
+        return obj.get_cover_image(size)
+    except WSError:
+        raise ValueError("{} not found.".format(obj.__class__.__name__))
+
+
+if __name__ == "__main__":
+    album = getAlbum("Melvins", "Houdini")
+    for sz in (SIZE_SMALL, SIZE_MEGA, SIZE_MEDIUM, SIZE_LARGE,
+               SIZE_EXTRA_LARGE):
+        print(album.get_cover_image(sz))
+
+    melvins = getArtist("Melvins")
+    print(melvins)
+    for sz in (SIZE_SMALL, SIZE_MEGA, SIZE_MEDIUM, SIZE_LARGE,
+               SIZE_EXTRA_LARGE):
+        print(melvins.get_cover_image(sz))

eyed3/plugins/mimetype.py

@@ -0,0 +1,93 @@
+import time
+import pprint
+import eyed3
+import eyed3.utils
+from pathlib import Path
+from collections import Counter
+from eyed3.mimetype import guessMimetype
+from eyed3.utils.log import getLogger
+
+log = getLogger(__name__)
+
+# python-magic
+try:
+    import magic
+
+    class MagicTypes(magic.Magic):
+        def __init__(self):
+            magic.Magic.__init__(self, mime=True, mime_encoding=False, keep_going=True)
+
+        def guess_type(self, filename, all_types=False):
+            try:
+                types = self.from_file(filename)
+            except UnicodeEncodeError:
+                # https://github.com/ahupp/python-magic/pull/144
+                types = self.from_file(filename.encode("utf-8", 'surrogateescape'))
+
+            delim = r"\012- "
+            if all_types:
+                return types.split(delim)
+            else:
+                return types.split(delim)[0]
+
+    _python_magic = MagicTypes()
+
+except ImportError:
+    _python_magic = None
+
+
+class MimetypesPlugin(eyed3.plugins.LoaderPlugin):
+    NAMES = ["mimetypes"]
+
+    def __init__(self, arg_parser):
+        self._num_visited = 0
+        super().__init__(arg_parser, cache_files=False, track_images=False)
+
+        g = self.arg_group
+        g.add_argument("--status", action="store_true", help="Print dot status.")
+        g.add_argument("--parse-files", action="store_true", help="Parse each file.")
+        g.add_argument("--hide-notfound", action="store_true")
+        if _python_magic:
+            g.add_argument("-M", "--use-pymagic", action="store_true",
+                           help="Use python-magic to determine mimetype.")
+        self.magic = None
+        self.start_t = None
+        self.mime_types = Counter()
+
+    def start(self, args, config):
+        super().start(args, config)
+        self.magic = "pymagic" if self.args.use_pymagic else "filetype"
+        self.start_t = time.time()
+
+    def handleFile(self, f, *args, **kwargs):
+
+        self._num_visited += 1
+        if self.args.parse_files:
+            try:
+                super().handleFile(f)
+            except Exception as ex:
+                log.critical(ex, exc_info=ex)
+        else:
+            self._num_loaded += 1
+
+            if self.magic == "pymagic":
+                mtype = _python_magic.guess_type(f)
+            else:
+                mtype = guessMimetype(f)
+
+            self.mime_types[mtype] += 1
+            if not self.args.hide_notfound:
+                if mtype is None and Path(f).suffix.lower() in (".mp3",):
+                    print("None mimetype:", f)
+
+        if self.args.status:
+            print(".", end="", flush=True)
+
+    def handleDone(self):
+        t = time.time() - self.start_t
+        print(f"\nVisited {self._num_visited} files")
+        print(f"Processed {self._num_loaded} files")
+        print(f"magic: {self.magic}")
+        print(f"time: {eyed3.utils.formatTime(t)} seconds")
+        if self.mime_types:
+            pprint.pprint(self.mime_types)

eyed3/plugins/nfo.py

@@ -0,0 +1,123 @@
+import time
+import eyed3
+from eyed3.utils.console import printMsg
+from eyed3.utils import formatSize, formatTime
+from eyed3.id3 import versionToString
+from eyed3.plugins import LoaderPlugin
+
+
+class NfoPlugin(LoaderPlugin):
+    NAMES = ["nfo"]
+    SUMMARY = "Create NFO files for each directory scanned."
+    DESCRIPTION = "Each directory scanned is treated as an album and a "\
+                  "`NFO <http://en.wikipedia.org/wiki/.nfo>`_ file is "\
+                  "written to standard out.\n\n"\
+                  "NFO files are often found in music archives."
+
+    def __init__(self, arg_parser):
+        super(NfoPlugin, self).__init__(arg_parser)
+        self.albums = {}
+
+    def handleFile(self, f):
+        super(NfoPlugin, self).handleFile(f)
+
+        if self.audio_file and self.audio_file.tag:
+            tag = self.audio_file.tag
+            album = tag.album
+            if album and album not in self.albums:
+                self.albums[album] = []
+                self.albums[album].append(self.audio_file)
+            elif album:
+                self.albums[album].append(self.audio_file)
+
+    def handleDone(self):
+        if not self.albums:
+            printMsg("No albums found.")
+            return
+
+        for album in self.albums:
+            audio_files = self.albums[album]
+            if not audio_files:
+                continue
+            audio_files.sort(key=lambda af: (af.tag.track_num[0] or 999,
+                                             af.tag.track_num[1] or 999))
+
+            max_title_len = 0
+            avg_bitrate = 0
+            encoder_info = ''
+            for audio_file in audio_files:
+                tag = audio_file.tag
+                # Compute maximum title length
+                title_len = len(tag.title or "")
+                if title_len > max_title_len:
+                    max_title_len = title_len
+                # Compute average bitrate
+                avg_bitrate += audio_file.info.bit_rate[1]
+                # Grab the last lame version in case not all files have one
+                if "encoder_version" in audio_file.info.lame_tag:
+                    version = audio_file.info.lame_tag['encoder_version']
+                    encoder_info = (version or encoder_info)
+            avg_bitrate = avg_bitrate / len(audio_files)
+
+            printMsg("")
+            printMsg("Artist   : %s" % audio_files[0].tag.artist)
+            printMsg("Album    : %s" % album)
+            printMsg("Released : %s" %
+                     (audio_files[0].tag.original_release_date or
+                      audio_files[0].tag.release_date))
+            printMsg("Recorded : %s" % audio_files[0].tag.recording_date)
+            genre = audio_files[0].tag.genre
+            if genre:
+                genre = genre.name
+            else:
+                genre = ""
+            printMsg("Genre    : %s" % genre)
+
+            printMsg("")
+            printMsg("Source  : ")
+            printMsg("Encoder : %s" % encoder_info)
+            printMsg("Codec   : mp3")
+            printMsg("Bitrate : ~%s K/s @ %s Hz, %s" %
+                     (avg_bitrate, audio_files[0].info.sample_freq,
+                      audio_files[0].info.mode))
+            printMsg("Tag     : ID3 %s" %
+                     versionToString(audio_files[0].tag.version))
+
+            printMsg("")
+            printMsg("Ripped By: ")
+
+            printMsg("")
+            printMsg("Track Listing")
+            printMsg("-------------")
+            count = 0
+            total_time = 0
+            total_size = 0
+            for audio_file in audio_files:
+                tag = audio_file.tag
+                count += 1
+
+                title = tag.title or ""
+                title_len = len(title)
+                padding = " " * ((max_title_len - title_len) + 3)
+                time_secs = audio_file.info.time_secs
+                total_time += time_secs
+                total_size += audio_file.info.size_bytes
+
+                zero_pad = "0" * (len(str(len(audio_files))) - len(str(count)))
+                printMsg(" %s%d. %s%s(%s)" %
+                         (zero_pad, count, title, padding,
+                          formatTime(time_secs)))
+
+            printMsg("")
+            printMsg("Total play time : %s" %
+                     formatTime(total_time))
+            printMsg("Total size      : %s" %
+                     formatSize(total_size))
+
+            printMsg("")
+            printMsg("=" * 78)
+            printMsg(".NFO file created with eyeD3 %s on %s" %
+                     (eyed3.version, time.asctime()))
+            printMsg("For more information about eyeD3 go to %s" %
+                     "http://eyeD3.nicfit.net/")
+            printMsg("=" * 78)

eyed3/plugins/pymod.py

@@ -0,0 +1,72 @@
+import os
+import importlib.machinery
+from eyed3.plugins import LoaderPlugin
+
+_DEFAULT_MOD = "eyeD3mod.py"
+
+
+class PyModulePlugin(LoaderPlugin):
+    SUMMARY = "Imports a Python module file and calls its functions for the "\
+              "the various plugin events."
+    DESCRIPTION = f'''
+If no module if provided a file named {_DEFAULT_MOD} in the current working directory is
+imported. If any of the following methods exist they still be invoked:
+
+def audioFile(audio_file):
+    """Invoked for every audio file that is encountered. The ``audio_file``
+    is of type ``eyed3.core.AudioFile``; currently this is the concrete type
+    ``eyed3.mp3.Mp3AudioFile``."""
+    pass
+
+def audioDir(d, audio_files, images):
+    """This function is invoked for any directory (``d``) that contains audio
+    (``audio_files``) or image (``images``) media."""
+    pass
+
+def done():
+    """This method is invoke before successful exit."""
+    pass
+'''
+    NAMES = ["pymod"]
+
+    def __init__(self, arg_parser):
+        super(PyModulePlugin, self).__init__(arg_parser, cache_files=True,
+                                             track_images=True)
+        self._mod = None
+        self.arg_group.add_argument("-m", "--module", dest="module",
+                                    help="The Python module module to invoke. "
+                                         f"The default is ./{_DEFAULT_MOD}")
+
+    def start(self, args, config):
+        mod_file = args.module or _DEFAULT_MOD
+        try:
+            mod_name = os.path.splitext(os.path.basename(mod_file))[0]
+            loader = importlib.machinery.SourceFileLoader(mod_name, mod_file)
+            mod = loader.load_module()
+            self._mod = mod
+        except IOError:
+            raise IOError("Module file not found: %s" % mod_file)
+        except (NameError, ImportError, SyntaxError) as ex:
+            raise IOError("Module load error: %s" % str(ex))
+
+    def handleFile(self, f):
+        super(PyModulePlugin, self).handleFile(f)
+        if not self.audio_file:
+            return
+
+        if "audioFile" in dir(self._mod):
+            self._mod.audioFile(self.audio_file)
+
+    def handleDirectory(self, d, _):
+        if not self._file_cache and not self._dir_images:
+            return
+
+        if "audioDir" in dir(self._mod):
+            self._mod.audioDir(d, self._file_cache, self._dir_images)
+
+        super(PyModulePlugin, self).handleDirectory(d, _)
+
+    def handleDone(self):
+        super(PyModulePlugin, self).handleDone()
+        if "done" in dir(self._mod):
+            self._mod.done()