eyeD3 0.9.8a1__py3-none-any.whl

eyed3/main.py

@@ -0,0 +1,305 @@
+import os
+import sys
+import textwrap
+import warnings
+import deprecation
+
+from io import StringIO
+from configparser import ConfigParser
+from configparser import Error as ConfigParserError
+
+import eyed3
+import eyed3.utils
+import eyed3.utils.console
+import eyed3.plugins
+import eyed3.__about__
+
+from eyed3.utils.log import initLogging
+
+DEFAULT_PLUGIN = "classic"
+DEFAULT_CONFIG = os.path.expandvars("${HOME}/.config/eyeD3/config.ini")
+USER_PLUGINS_DIR = os.path.expandvars("${HOME}/.config/eyeD3/plugins")
+DEFAULT_CONFIG_DEPRECATED = os.path.expandvars("${HOME}/.eyeD3/config.ini")
+USER_PLUGINS_DIR_DEPRECATED = os.path.expandvars("${HOME}/.eyeD3/plugins")
+
+
+def main(args, config):
+    if "list_plugins" in args and args.list_plugins:
+        _listPlugins(config)
+        return 0
+
+    args.plugin.start(args, config)
+
+    recursive = False
+    if "non_recursive" in args:
+        recursive = not args.non_recursive
+    elif "recursive" in args:
+        recursive = args.recursive
+
+    # Process paths (files/directories)
+    for p in args.paths:
+        eyed3.utils.walk(args.plugin, p, excludes=args.excludes, fs_encoding=args.fs_encoding,
+                         recursive=recursive)
+
+    retval = args.plugin.handleDone()
+
+    return retval or 0
+
+
+def _listPlugins(config):
+    from eyed3.utils.console import Fore, Style
+
+    def header(name):
+        is_default = name == DEFAULT_PLUGIN
+        return (Style.BRIGHT + (Fore.GREEN if is_default else '') + "* " +
+                name + Style.RESET_ALL)
+
+    all_plugins = eyed3.plugins.load(reload=True, paths=_getPluginPath(config))
+    # Create a new dict for sorted display
+    plugin_names = []
+    for plugin in set(all_plugins.values()):
+        plugin_names.append(plugin.NAMES[0])
+
+    print("\nType 'eyeD3 --plugin=<name> --help' for more help\n")
+
+    plugin_names.sort()
+    for name in plugin_names:
+        plugin = all_plugins[name]
+
+        alt_names = plugin.NAMES[1:]
+        alt_names = f" ({', '.join(alt_names)})" if alt_names else ""
+
+        print(f"{header(name)} {alt_names}:")
+        for txt in textwrap.wrap(plugin.SUMMARY, initial_indent=' ' * 2, subsequent_indent=' ' * 2):
+            print(f"{Fore.YELLOW}{txt}{Style.RESET_ALL}")
+        print("")
+
+
+@deprecation.deprecated(deprecated_in="0.9a2", removed_in="1.0",
+                        current_version=eyed3.__about__.__version__,
+                        details=f"Default eyeD3 config moved to {DEFAULT_CONFIG}")
+def _deprecatedConfigFileCheck(_):
+    """This here to add deprecation."""
+
+
+def _loadConfig(args):
+    config_files = []
+
+    if args.config:
+        config_files.append(os.path.abspath(args.config))
+
+    if args.no_config is False:
+        config_files.append(DEFAULT_CONFIG)
+        config_files.append(DEFAULT_CONFIG_DEPRECATED)
+
+    if not config_files:
+        return None
+
+    for config_file in config_files:
+        if os.path.isfile(config_file):
+            _deprecatedConfigFileCheck(config_file)
+
+            try:
+                config = ConfigParser()
+                config.read(config_file)
+            except ConfigParserError as ex:
+                eyed3.log.warning(f"User config error: {ex}")
+                return None
+            else:
+                return config
+        elif config_file != DEFAULT_CONFIG and config_file != DEFAULT_CONFIG_DEPRECATED:
+            raise IOError(f"User config not found: {config_file}")
+
+
+def _getPluginPath(config):
+    plugin_path = [USER_PLUGINS_DIR]
+
+    if config and config.has_option("default", "plugin_path"):
+        val = config.get("default", "plugin_path")
+        plugin_path += [os.path.expanduser(os.path.expandvars(d)) for d
+                            in val.split(':') if val]
+    return plugin_path
+
+
+def profileMain(args, config):  # pragma: no cover
+    """This is the main function for profiling
+    http://code.google.com/appengine/kb/commontasks.html#profiling
+    """
+    import cProfile
+    import pstats
+
+    eyed3.log.debug("driver profileMain")
+    prof = cProfile.Profile()
+    prof = prof.runctx("main(args)", globals(), locals())
+
+    stream = StringIO()
+    stats = pstats.Stats(prof, stream=stream)
+    stats.sort_stats("time")  # Or cumulative
+    stats.print_stats(100)  # 80 = how many to print
+
+    # The rest is optional.
+    stats.print_callees()
+    stats.print_callers()
+    sys.stderr.write("Profile data:\n%s\n" % stream.getvalue())
+
+    return 0
+
+
+def setFileScannerOpts(arg_parser, default_recursive=False, paths_metavar="PATH",
+                       paths_help="Files or directory paths"):
+
+    if default_recursive is False:
+        arg_parser.add_argument("-r", "--recursive", action="store_true", dest="recursive",
+                                help="Recurse into subdirectories.")
+    else:
+        arg_parser.add_argument("-R", "--non-recursive", action="store_true", dest="non_recursive",
+                                help="Do not recurse into subdirectories.")
+
+    arg_parser.add_argument("--exclude", action="append", metavar="PATTERN", dest="excludes",
+                            help="A regular expression for path exclusion. May be specified "
+                                 "multiple times.")
+    arg_parser.add_argument("--fs-encoding", action="store", dest="fs_encoding",
+                            default=eyed3.LOCAL_FS_ENCODING, metavar="ENCODING",
+                            help="Use the specified file system encoding for filenames. "
+                                 f"Default as it was detected is '{eyed3.LOCAL_FS_ENCODING}' but "
+                                 "this option is still useful when reading from mounted file "
+                                 "systems.")
+    arg_parser.add_argument("paths", metavar=paths_metavar, nargs="*", help=paths_help)
+
+
+def makeCmdLineParser(subparser=None):
+    from eyed3.utils import ArgumentParser
+
+    p = ArgumentParser(prog=eyed3.__about__.__project_name__, add_help=True)\
+            if not subparser else subparser
+
+    setFileScannerOpts(p)
+
+    p.add_argument("-L", "--plugins", action="store_true", default=False,
+                   dest="list_plugins", help="List all available plugins")
+    p.add_argument("-P", "--plugin", action="store", dest="plugin",
+                   default=None, metavar="NAME",
+                   help=f"Specify which plugin to use. The default is '{DEFAULT_PLUGIN}'")
+    p.add_argument("-C", "--config", action="store", dest="config",
+                   default=None, metavar="FILE",
+                   help="Supply a configuration file. The default is "
+                        f"'{DEFAULT_CONFIG}', although even that is optional.")
+    p.add_argument("--backup", action="store_true", dest="backup",
+                   help="Plugins should honor this option such that "
+                        "a backup is made of any file modified. The backup "
+                        "is made in same directory with a '.orig' "
+                        "extension added.")
+    p.add_argument("-Q", "--quiet", action="store_true", dest="quiet",
+                   default=False, help="A hint to plugins to output less.")
+    p.add_argument("--no-color", action="store_true", dest="no_color",
+                   help="Suppress color codes in console output. "
+                        "This will happen automatically if the output is "
+                        "not a TTY (e.g. when redirecting to a file)")
+    p.add_argument("--no-config",
+                   action="store_true", dest="no_config",
+                   help=f"Do not load the default user config '{DEFAULT_CONFIG}'. "
+                        "The -c/--config options are still honored if present.")
+
+    return p
+
+
+def parseCommandLine(cmd_line_args=None):
+
+    cmd_line_args = list(cmd_line_args) if cmd_line_args else list(sys.argv[1:])
+
+    # Remove any options not related to plugin/config for first parse. These
+    # determine the parser for the next stage.
+    stage_one_args = []
+    idx, auto_append = 0, False
+    while idx < len(cmd_line_args):
+        opt = cmd_line_args[idx]
+        if auto_append:
+            stage_one_args.append(opt)
+            auto_append = False
+
+        if opt in ("-C", "--config", "-P", "--plugin", "--no-config"):
+            stage_one_args.append(opt)
+            if opt != "--no-config":
+                auto_append = True
+        elif (opt.startswith("-C=") or opt.startswith("--config=") or
+                opt.startswith("-P=") or opt.startswith("--plugin=")):
+            stage_one_args.append(opt)
+        idx += 1
+
+    parser = makeCmdLineParser()
+    args = parser.parse_args(stage_one_args)
+
+    config = _loadConfig(args)
+
+    if args.plugin:
+        # Plugin on the command line takes precedence over config.
+        plugin_name = args.plugin
+    elif config and config.has_option("default", "plugin"):
+        # Get default plugin from config or use DEFAULT_CONFIG
+        plugin_name = config.get("default", "plugin")
+        if not plugin_name:
+            plugin_name = DEFAULT_PLUGIN
+    else:
+        plugin_name = DEFAULT_PLUGIN
+
+    PluginClass = eyed3.plugins.load(plugin_name, paths=_getPluginPath(config))
+    if PluginClass is None:
+        eyed3.utils.console.printError("Plugin not found: %s" % plugin_name)
+        parser.exit(1)
+    plugin = PluginClass(parser)
+
+    if config and config.has_option("default", "options"):
+        cmd_line_args.extend(config.get("default", "options").split())
+    if config and config.has_option(plugin_name, "options"):
+        cmd_line_args.extend(config.get(plugin_name, "options").split())
+
+    # Re-parse the command line including options from the config.
+    args = parser.parse_args(args=cmd_line_args)
+
+    args.plugin = plugin
+    eyed3.log.debug("command line args: %s", args)
+    eyed3.log.debug("plugin is: %s", plugin)
+
+    return args, parser, config
+
+
+def _main():
+    """Entry point"""
+    initLogging()
+
+    args = None
+    try:
+        args, _, config = parseCommandLine()
+
+        eyed3.utils.console.AnsiCodes.init(not args.no_color)
+
+        mainFunc = main if args.debug_profile is False else profileMain
+        retval = mainFunc(args, config)
+    except KeyboardInterrupt:
+        retval = 0
+    except (StopIteration, IOError) as ex:
+        eyed3.utils.console.printError(str(ex))
+        retval = 1
+    except Exception as ex:
+        eyed3.utils.console.printError(f"Uncaught exception: {ex}\n")
+        eyed3.log.exception(ex)
+        retval = 1
+
+        if args.debug_pdb:
+            try:
+                with warnings.catch_warnings():
+                    warnings.simplefilter("ignore", PendingDeprecationWarning)
+                    # Must delay the import of ipdb as say as possible because
+                    # of https://github.com/gotcha/ipdb/issues/48
+                    import ipdb as pdb  # noqa
+            except ImportError:
+                import pdb  # noqa
+
+            e, m, tb = sys.exc_info()
+            pdb.post_mortem(tb)
+
+    sys.exit(retval)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    _main()

eyed3/mimetype.py

@@ -0,0 +1,107 @@
+import pathlib
+import filetype
+from io import BytesIO
+from .id3 import ID3_MIME_TYPE, ID3_MIME_TYPE_EXTENSIONS
+from .mp3 import MIME_TYPES as MP3_MIME_TYPES
+from .utils.log import getLogger
+from filetype.utils import _NUM_SIGNATURE_BYTES
+
+log = getLogger(__name__)
+
+
+def guessMimetype(filename):
+    """Return the mime-type for `filename`."""
+
+    path = pathlib.Path(filename) if not isinstance(filename, pathlib.Path) else filename
+
+    with path.open("rb") as signature:
+        # Since filetype only reads 262 of file many mp3s starting with null bytes will not find
+        # a header, so ignoring null bytes and using the bytes interface...
+        buf = b""
+        while not buf:
+            data = signature.read(_NUM_SIGNATURE_BYTES)
+            if not data:
+                break
+
+            data = data.lstrip(b"\x00")
+            if data:
+                data_len = len(data)
+                if data_len >= _NUM_SIGNATURE_BYTES:
+                    buf = data[:_NUM_SIGNATURE_BYTES]
+                else:
+                    buf = data + signature.read(_NUM_SIGNATURE_BYTES - data_len)
+
+        # Special casing .id3/.tag because extended filetype with add_type() prepends, meaning
+        # all mp3 would be labeled mimetype id3, while appending would mean each .id3 would be
+        # mime mpeg.
+        if path.suffix in ID3_MIME_TYPE_EXTENSIONS:
+            if Id3Tag().match(buf) or Id3TagExt().match(buf):
+                return Id3TagExt.MIME
+
+        return filetype.guess_mime(buf)
+
+
+class Mp2x(filetype.Type):
+    """Implements the MP2.x audio type matcher."""
+    MIME = MP3_MIME_TYPES[0]
+    EXTENSION = "mp3"
+
+    def __init__(self):
+        super().__init__(mime=self.__class__.MIME, extension=self.__class__.EXTENSION)
+
+    def match(self, buf):
+        from .mp3.headers import findHeader
+
+        return (len(buf) > 2 and
+                buf[0] == 0xff and buf[1] in (0xf3, 0xe3) and
+                findHeader(BytesIO(buf), 0)[1])
+
+
+class Mp3Invalids(filetype.Type):
+    """Implements a MP3 audio type matcher this is odd or/corrupt mp3."""
+    MIME = MP3_MIME_TYPES[0]
+    EXTENSION = "mp3"
+
+    def __init__(self):
+        super().__init__(mime=self.__class__.MIME, extension=self.__class__.EXTENSION)
+
+    def match(self, buf):
+        from .mp3.headers import findHeader
+
+        header = findHeader(BytesIO(buf), 0)[1]
+        log.debug(f"Mp3Invalid, found: {header}")
+        return bool(header)
+
+
+class Id3Tag(filetype.Type):
+    """Implements a MP3 audio type matcher this is odd or/corrupt mp3."""
+    MIME = ID3_MIME_TYPE
+    EXTENSION = "id3"
+
+    def __init__(self):
+        super().__init__(mime=self.__class__.MIME, extension=self.__class__.EXTENSION)
+
+    def match(self, buf):
+        return buf[:3] in (b"ID3", b"TAG") or len(buf) == 0
+
+
+class Id3TagExt(Id3Tag):
+    EXTENSION = "tag"
+
+
+class M3u(filetype.Type):
+    """Implements the m3u playlist matcher."""
+    MIME = "audio/x-mpegurl"
+    EXTENSION = "m3u"
+
+    def __init__(self):
+        super().__init__(mime=self.__class__.MIME, extension=self.__class__.EXTENSION)
+
+    def match(self, buf):
+        return len(buf) > 6 and buf.startswith(b"#EXTM3U")
+
+
+# Not using `add_type()`, to append
+filetype.types.append(Mp2x())
+filetype.types.append(M3u())
+filetype.types.append(Mp3Invalids())

eyed3/mp3/__init__.py

@@ -0,0 +1,188 @@
+import os
+import re
+import stat
+
+from .. import Error
+from .. import id3
+from .. import core
+
+from ..utils.log import getLogger
+log = getLogger(__name__)
+
+
+class Mp3Exception(Error):
+    """Used to signal mp3-related errors."""
+    pass
+
+
+NAME = "mpeg"
+# Mime-types that are recognized at MP3
+MIME_TYPES = ["audio/mpeg", "audio/mp3", "audio/x-mp3", "audio/x-mpeg",
+              "audio/mpeg3", "audio/x-mpeg3", "audio/mpg", "audio/x-mpg",
+              "audio/x-mpegaudio", "audio/mpegapplication/x-tar",
+             ]
+
+# Mime-types that have been seen to contain mp3 data.
+OTHER_MIME_TYPES = ['application/octet-stream',  # ???
+                    'audio/x-hx-aac-adts',  # ???
+                    'audio/x-wav',  # RIFF wrapped mp3s
+                   ]
+
+# Valid file extensions.
+EXTENSIONS = [".mp3"]
+
+
+class Mp3AudioInfo(core.AudioInfo):
+    def __init__(self, file_obj, start_offset, tag):
+        from . import headers
+        from .headers import timePerFrame
+
+        log.debug("mp3 header search starting @ %x" % start_offset)
+
+        self.mp3_header = None
+        self.xing_header = None
+        self.vbri_header = None
+        # If not ``None``, the Lame header.
+        # See :class:`eyed3.mp3.headers.LameHeader`
+        self.lame_tag = None
+        # 2-tuple, (vrb?:boolean, bitrate:int)
+        self.bit_rate = (None, None)
+
+        header_pos = 0
+        while self.mp3_header is None:
+            # Find first mp3 header
+            (header_pos,
+             header_int,
+             header_bytes) = headers.findHeader(file_obj, start_offset)
+            if not header_int:
+                try:
+                    fname = file_obj.name
+                except AttributeError:
+                    fname = 'unknown'
+                raise headers.Mp3Exception(
+                    "Unable to find a valid mp3 frame in '%s'" % fname)
+
+            try:
+                self.mp3_header = headers.Mp3Header(header_int)
+                log.debug("mp3 header %x found at position: 0x%x" %
+                          (header_int, header_pos))
+            except headers.Mp3Exception as ex:
+                log.debug("Invalid mp3 header: %s" % str(ex))
+                # keep looking...
+                start_offset += 4
+
+        file_obj.seek(header_pos)
+        mp3_frame = file_obj.read(self.mp3_header.frame_length)
+        if re.compile(b'Xing|Info').search(mp3_frame):
+            # Check for Xing/Info header information.
+            self.xing_header = headers.XingHeader()
+            if not self.xing_header.decode(mp3_frame):
+                log.debug("Ignoring corrupt Xing header")
+                self.xing_header = None
+        elif mp3_frame.find(b'VBRI') >= 0:
+            # Check for VBRI header information.
+            self.vbri_header = headers.VbriHeader()
+            if not self.vbri_header.decode(mp3_frame):
+                log.debug("Ignoring corrupt VBRI header")
+                self.vbri_header = None
+
+        # Check for LAME Tag
+        self.lame_tag = headers.LameHeader(mp3_frame)
+
+        # Set file size
+        size_bytes = os.stat(file_obj.name)[stat.ST_SIZE]
+
+        # Compute track play time.
+        if self.xing_header and self.xing_header.vbr:
+            tpf = timePerFrame(self.mp3_header, True)
+            time_secs = tpf * self.xing_header.numFrames
+        elif self.vbri_header and self.vbri_header.version == 1:
+            tpf = timePerFrame(self.mp3_header, True)
+            time_secs = tpf * self.vbri_header.num_frames
+        else:
+            tpf = timePerFrame(self.mp3_header, False)
+            length = size_bytes
+            if tag and tag.isV2():
+                length -= tag.header.SIZE + tag.header.tag_size
+                # Handle the case where there is a v2 tag and a v1 tag.
+                file_obj.seek(-128, 2)
+                if file_obj.read(3) == "TAG":
+                    length -= 128
+            elif tag and tag.isV1():
+                length -= 128
+            time_secs = (length / self.mp3_header.frame_length) * tpf
+
+        # Compute bitrate
+        if (self.xing_header and self.xing_header.vbr and
+                self.xing_header.numFrames):  # if xing_header.numFrames == 0, ZeroDivisionError
+            br = int((self.xing_header.numBytes * 8) /
+                     (tpf * self.xing_header.numFrames * 1000))
+            vbr = True
+        else:
+            br = self.mp3_header.bit_rate
+            vbr = False
+        self.bit_rate = (vbr, br)
+
+        self.sample_freq = self.mp3_header.sample_freq
+        self.mode = self.mp3_header.mode
+
+        super().__init__(time_secs, size_bytes)
+
+    ##
+    # Helper to get the bitrate as a string. The prefix '~' is used to denote
+    # variable bit rates.
+    @property
+    def bit_rate_str(self):
+        (vbr, bit_rate) = self.bit_rate
+        return f"{'~' if vbr else ''}{bit_rate} kb/s"
+
+
+class Mp3AudioFile(core.AudioFile):
+    """Audio file container for mp3 files."""
+
+    def __init__(self, path, version=id3.ID3_ANY_VERSION):
+        self._tag_version = version
+
+        super().__init__(path)
+        assert self.type == core.AUDIO_MP3
+
+    def _read(self):
+        with open(self.path, "rb") as file_obj:
+            self._tag = id3.Tag()
+            tag_found = self._tag.parse(file_obj, self._tag_version)
+
+            # Compute offset for starting mp3 data search
+            if tag_found and self._tag.isV1():
+                mp3_offset = 0
+            elif tag_found and self._tag.isV2():
+                mp3_offset = self._tag.header.SIZE + self._tag.header.tag_size
+            else:
+                mp3_offset = 0
+                self._tag = None
+
+            try:
+                self._info = Mp3AudioInfo(file_obj, mp3_offset, self._tag)
+            except Mp3Exception as ex:
+                # Only logging a warning here since we can still operate on
+                # the tag.
+                log.warning(ex)
+                self._info = None
+
+            self.type = core.AUDIO_MP3
+
+    def initTag(self, version=id3.ID3_DEFAULT_VERSION):
+        """Add a id3.Tag to the file (removing any existing tag if one exists)."""
+        self.tag = id3.Tag()
+        self.tag.version = version
+        self.tag.file_info = id3.FileInfo(self.path)
+        return self.tag
+
+    @core.AudioFile.tag.setter
+    def tag(self, t):
+        if t:
+            t.file_info = id3.FileInfo(self.path)
+            if self._tag and self._tag.file_info:
+                t.file_info.tag_size = self._tag.file_info.tag_size
+                t.file_info.tag_padding_size = \
+                    self._tag.file_info.tag_padding_size
+        self._tag = t