eyeD3 0.9.8a1__py3-none-any.whl

eyed3/plugins/stats.py

@@ -0,0 +1,479 @@
+import os
+import sys
+import operator
+from collections import Counter
+
+from eyed3 import id3, mp3
+from eyed3.core import AUDIO_MP3
+from eyed3.mimetype import guessMimetype
+from eyed3.utils.console import Fore, Style, printMsg
+from eyed3.plugins import LoaderPlugin
+from eyed3.id3 import frames
+
+ID3_VERSIONS = [id3.ID3_V1_0, id3.ID3_V1_1,
+                id3.ID3_V2_2, id3.ID3_V2_3, id3.ID3_V2_4]
+
+_OP_STRINGS = {operator.le: "<=",
+               operator.lt: "< ",
+               operator.ge: ">=",
+               operator.gt: "> ",
+               operator.eq: "= ",
+               operator.ne: "!=",
+              }
+
+
+class Rule:
+    def test(self, path, audio_file):
+        raise NotImplementedError()
+
+
+PREFERRED_ID3_VERSIONS = [id3.ID3_V2_3,
+                          id3.ID3_V2_4,
+                         ]
+
+
+class Id3TagRules(Rule):
+    def test(self, path, audio_file):
+        scores = []
+
+        if audio_file is None:
+            return None
+
+        if not audio_file.tag:
+            return [(-75, "Missing ID3 tag")]
+
+        tag = audio_file.tag
+        if tag.version not in PREFERRED_ID3_VERSIONS:
+            scores.append((-30, "ID3 version not in %s" %
+                                PREFERRED_ID3_VERSIONS))
+        if not tag.title:
+            scores.append((-30, "Tag missing title"))
+        if not tag.artist:
+            scores.append((-28, "Tag missing artist"))
+        if not tag.album:
+            scores.append((-26, "Tag missing album"))
+        if not tag.track_num[0]:
+            scores.append((-24, "Tag missing track number"))
+        if not tag.track_num[1]:
+            scores.append((-22, "Tag missing total # of tracks"))
+
+        if not tag.getBestDate():
+            scores.append((-30, "Tag missing any useful dates"))
+        else:
+            if not tag.original_release_date:
+                # Original release date is so rarely used but is almost always
+                # what I mean or wanna know.
+                scores.append((-10, "No original release date"))
+            elif not tag.release_date:
+                scores.append((-5, "No release date"))
+
+        # TLEN, best gotten from audio_file.info.time_secs but having it in
+        # the tag is good, I guess.
+        if b"TLEN" not in tag.frame_set:
+            scores.append((-5, "No TLEN frame"))
+
+        return scores
+
+
+class BitrateRule(Rule):
+    BITRATE_DEDUCTIONS = [(128, -20), (192, -10)]
+
+    def test(self, path, audio_file):
+        scores = []
+
+        if not audio_file:
+            return None
+
+        if not audio_file.info:
+            # Detected as an audio file but not real audio data found.
+            return [(-90, "No audio data found")]
+
+        is_vbr, bitrate = audio_file.info.bit_rate
+        for threshold, score in self.BITRATE_DEDUCTIONS:
+            if bitrate < threshold:
+                scores.append((score, "Bit rate < %d" % threshold))
+                break
+
+        return scores
+
+
+VALID_MIME_TYPES = mp3.MIME_TYPES + ["image/png",
+                                     "image/gif",
+                                     "image/jpeg",
+                                    ]
+
+
+class FileRule(Rule):
+    def test(self, path, audio_file):
+        mt = guessMimetype(path)
+
+        for name in os.path.split(path):
+            if name.startswith('.'):
+                return [(-100, "Hidden file type")]
+
+        if mt not in VALID_MIME_TYPES:
+            return [(-100, "Unsupported file type: %s" % mt)]
+        return None
+
+
+VALID_ARTWORK_NAMES = ("cover", "cover-front", "cover-back")
+
+
+class ArtworkRule(Rule):
+    def test(self, path, audio_file):
+        mt = guessMimetype(path)
+        if mt and mt.startswith("image/"):
+            name, ext = os.path.splitext(os.path.basename(path))
+            if name not in VALID_ARTWORK_NAMES:
+                return [(-10, "Artwork file not in %s" %
+                              str(VALID_ARTWORK_NAMES))]
+
+        return None
+
+
+BAD_FRAMES = [frames.PRIVATE_FID, frames.OBJECT_FID]
+
+
+class Id3FrameRules(Rule):
+    def test(self, path, audio_file):
+        scores = []
+        if not audio_file or not audio_file.tag:
+            return
+
+        tag = audio_file.tag
+        for fid in tag.frame_set:
+            if fid[0] == 'T' and fid != "TXXX" and len(tag.frame_set[fid]) > 1:
+                scores.append((-10, "Multiple %s frames" % fid.decode('ascii')))
+            elif fid in BAD_FRAMES:
+                scores.append((-13, "%s frames are bad, mmmkay?" %
+                               fid.decode('ascii')))
+
+        return scores
+
+
+class Stat(Counter):
+    TOTAL = "total"
+
+    def __init__(self, *args, **kwargs):
+        super(Stat, self).__init__(*args, **kwargs)
+        self[self.TOTAL] = 0
+        self._key_names = {}
+
+    def compute(self, file, audio_file):
+        self[self.TOTAL] += 1
+        self._compute(file, audio_file)
+
+    def _compute(self, file, audio_file):
+        pass
+
+    def report(self):
+        self._report()
+
+    def _sortedKeys(self, most_common=False):
+        def keyDisplayName(k):
+            return self._key_names[k] if k in self._key_names else k
+
+        key_map = {}
+        for k in list(self.keys()):
+            key_map[keyDisplayName(k)] = k
+
+        if not most_common:
+            sorted_names = [k for k in key_map.keys() if k]
+            sorted_names.remove(self.TOTAL)
+            sorted_names.sort()
+            sorted_names.append(self.TOTAL)
+        else:
+            most_common = self.most_common()
+            sorted_names = []
+            remainder_names = []
+            for k, v in most_common:
+                if k != self.TOTAL and v > 0:
+                    sorted_names.append(keyDisplayName(k))
+                elif k != self.TOTAL:
+                    remainder_names.append(keyDisplayName(k))
+
+            remainder_names.sort()
+            sorted_names = sorted_names + remainder_names
+            sorted_names.append(self.TOTAL)
+
+        return [key_map[name] for name in sorted_names]
+
+    def _report(self, most_common=False):
+        keys = self._sortedKeys(most_common=most_common)
+
+        key_col_width = 0
+        val_col_width = 0
+        for key in keys:
+            key = self._key_names[key] if key in self._key_names else key
+            key_col_width = max(key_col_width, len(str(key)))
+            val_col_width = max(val_col_width, len(str(self[key])))
+        key_col_width += 1
+        val_col_width += 1
+
+        for k in keys:
+            key_name = self._key_names[k] if k in self._key_names else k
+            if type(key_name) is bytes:
+                key_name = key_name.decode("latin1")
+            value = self[k]
+            percent = self.percent(k) if value and k != "total" else ""
+            print("{padding}{key}:{value}{percent}".format(
+                padding=' ' * 4,
+                key=str(key_name).ljust(key_col_width),
+                value=str(value).rjust(val_col_width),
+                percent=" ( %s%.2f%%%s )" % (Fore.GREEN, percent, Fore.RESET)
+                                              if percent else "",
+                 ))
+
+    def percent(self, key):
+        return (float(self[key]) / float(self["total"])) * 100
+
+
+class AudioStat(Stat):
+    def compute(self, audio_file):
+        self["total"] += 1
+        self._compute(audio_file)
+
+    def _compute(self, audio_file):
+        pass
+
+
+class FileCounterStat(Stat):
+    SUPPORTED_AUDIO = "audio"
+    UNSUPPORTED_AUDIO = "audio (unsupported)"
+    HIDDEN_FILES = "hidden"
+    OTHER_FILES = "other"
+
+    def __init__(self):
+        super(FileCounterStat, self).__init__()
+        for k in ("audio", "hidden", "audio (unsupported)"):
+            self[k] = 0
+
+    def _compute(self, file, audio_file):
+        mt = guessMimetype(file)
+
+        if audio_file:
+            self[self.SUPPORTED_AUDIO] += 1
+        elif mt and mt.startswith("audio/"):
+            self[self.UNSUPPORTED_AUDIO] += 1
+        elif os.path.basename(file).startswith('.'):
+            self[self.HIDDEN_FILES] += 1
+        else:
+            self[self.OTHER_FILES] += 1
+
+    def _report(self):
+        print(Style.BRIGHT + Fore.YELLOW + "Files:" + Style.RESET_ALL)
+        super(FileCounterStat, self)._report()
+
+
+class MimeTypeStat(Stat):
+    def _compute(self, file, audio_file):
+        mt = guessMimetype(file)
+        self[mt] += 1
+
+    def _report(self):
+        print(Style.BRIGHT + Fore.YELLOW + "Mime-Types:" + Style.RESET_ALL)
+        super(MimeTypeStat, self)._report(most_common=True)
+
+
+class Id3VersionCounter(AudioStat):
+    def __init__(self):
+        super(Id3VersionCounter, self).__init__()
+        for v in ID3_VERSIONS:
+            self[v] = 0
+            self._key_names[v] = id3.versionToString(v)
+
+    def _compute(self, audio_file):
+        if audio_file.tag:
+            self[audio_file.tag.version] += 1
+        else:
+            self[None] += 1
+
+    def _report(self):
+        print(Style.BRIGHT + Fore.YELLOW + "ID3 versions:" + Style.RESET_ALL)
+        super(Id3VersionCounter, self)._report()
+
+
+class Id3FrameCounter(AudioStat):
+    def _compute(self, audio_file):
+        if audio_file.tag:
+            for frame_id in audio_file.tag.frame_set:
+                self[frame_id] += len(audio_file.tag.frame_set[frame_id])
+
+    def _report(self):
+        print(Style.BRIGHT + Fore.YELLOW + "ID3 frames:" + Style.RESET_ALL)
+        super(Id3FrameCounter, self)._report(most_common=True)
+
+
+class BitrateCounter(AudioStat):
+    def __init__(self):
+        super(BitrateCounter, self).__init__()
+        self["cbr"] = 0
+        self["vbr"] = 0
+        self.bitrate_keys = [(operator.le, 96),
+                             (operator.le, 112),
+                             (operator.le, 128),
+                             (operator.le, 160),
+                             (operator.le, 192),
+                             (operator.le, 256),
+                             (operator.le, 320),
+                             (operator.gt, 320),
+                            ]
+        for k in self.bitrate_keys:
+            self[k] = 0
+            op, bitrate = k
+            self._key_names[k] = "%s %d" % (_OP_STRINGS[op], bitrate)
+
+    def _compute(self, audio_file):
+        if audio_file.type != AUDIO_MP3 or audio_file.info is None:
+            self["total"] -= 1
+            return
+
+        vbr, br = audio_file.info.bit_rate
+        if vbr:
+            self["vbr"] += 1
+        else:
+            self["cbr"] += 1
+
+        for key in self.bitrate_keys:
+            key_op, key_br = key
+            if key_op(br, key_br):
+                self[key] += 1
+                break
+
+    def _report(self):
+        print(Style.BRIGHT + Fore.YELLOW + "MP3 bitrates:" + Style.RESET_ALL)
+        super(BitrateCounter, self)._report(most_common=True)
+
+    def _sortedKeys(self, most_common=False):
+        keys = super(BitrateCounter, self)._sortedKeys(most_common=most_common)
+        keys.remove("cbr")
+        keys.remove("vbr")
+        keys.insert(0, "cbr")
+        keys.insert(1, "vbr")
+        return keys
+
+
+class RuleViolationStat(Stat):
+    def _report(self):
+        print(Style.BRIGHT + Fore.YELLOW + "Rule Violations:" + Style.RESET_ALL)
+        super(RuleViolationStat, self)._report(most_common=True)
+
+
+class Id3ImageTypeCounter(AudioStat):
+    def __init__(self):
+        super(Id3ImageTypeCounter, self).__init__()
+
+        self._key_names = {}
+        for attr in dir(frames.ImageFrame):
+            val = getattr(frames.ImageFrame, attr)
+            if isinstance(val, int) and not attr.endswith("_TYPE") and not attr.startswith("_"):
+                self._key_names[val] = attr
+
+        for v in self._key_names:
+            self[v] = 0
+
+    def _compute(self, audio_file):
+        if audio_file.tag:
+            for img in audio_file.tag.images:
+                self[img.picture_type] += 1
+
+    def _report(self):
+        print(Style.BRIGHT + Fore.YELLOW + "APIC image types:" + Style.RESET_ALL)
+        super(Id3ImageTypeCounter, self)._report()
+
+
+class StatisticsPlugin(LoaderPlugin):
+    NAMES = ['stats']
+    SUMMARY = "Computes statistics for all audio files scanned."
+
+    def __init__(self, arg_parser):
+        super(StatisticsPlugin, self).__init__(arg_parser)
+
+        self.arg_group.add_argument(
+                "--verbose", action="store_true", default=False,
+                help="Show details for each file with rule violations.")
+
+        self._stats = []
+        self._rules_stat = RuleViolationStat()
+
+        self._stats.append(FileCounterStat())
+        self._stats.append(MimeTypeStat())
+        self._stats.append(Id3VersionCounter())
+        self._stats.append(Id3FrameCounter())
+        self._stats.append(Id3ImageTypeCounter())
+        self._stats.append(BitrateCounter())
+
+        self._score_sum = 0
+        self._score_count = 0
+        self._rules_log = {}
+        self._rules = [Id3TagRules(),
+                       FileRule(),
+                       ArtworkRule(),
+                       BitrateRule(),
+                       Id3FrameRules(),
+                      ]
+
+    def handleFile(self, path):
+        super(StatisticsPlugin, self).handleFile(path)
+        if not self.args.quiet:
+            sys.stdout.write('.')
+            sys.stdout.flush()
+
+        for stat in self._stats:
+            if isinstance(stat, AudioStat):
+                if self.audio_file:
+                    stat.compute(self.audio_file)
+            else:
+                stat.compute(path, self.audio_file)
+
+        self._score_count += 1
+        total_score = 100
+        for rule in self._rules:
+            scores = rule.test(path, self.audio_file) or []
+            if scores:
+                if path not in self._rules_log:
+                    self._rules_log[path] = []
+
+                for score, text in scores:
+                    self._rules_stat[text] += 1
+                    self._rules_log[path].append((score, text))
+                    # += because negative values are returned
+                    total_score += score
+
+        if total_score != 100:
+            self._rules_stat[Stat.TOTAL] += 1
+
+        self._score_sum += total_score
+
+    def handleDone(self):
+        if self._num_loaded == 0:
+            super(StatisticsPlugin, self).handleDone()
+            return
+
+        print()
+        for stat in self._stats + [self._rules_stat]:
+            stat.report()
+            print()
+
+        # Detailed rule violations
+        if self.args.verbose:
+            for path in self._rules_log:
+                printMsg(path)  # does the right thing for unicode
+                for score, text in self._rules_log[path]:
+                    print(f"\t{Fore.RED}{str(score).center(3)}{Fore.RESET} ({text})")
+
+        def prettyScore():
+            s = float(self._score_sum) / float(self._score_count)
+            if s > 80:
+                c = Fore.GREEN
+            elif s > 70:
+                c = Fore.YELLOW
+            else:
+                c = Fore.RED
+            return s, c
+
+        score, color = prettyScore()
+        print(f"{Style.BRIGHT}Score{Style.RESET_BRIGHT} = {color}{score}%%{Fore.RESET}")
+        if not self.args.verbose:
+            print("Run with --verbose to see files and their rule violations")
+        print()

eyed3/plugins/xep_118.py

@@ -0,0 +1,45 @@
+from pathlib import Path
+from xml.sax.saxutils import escape
+
+from eyed3.plugins import LoaderPlugin
+from eyed3.utils.console import printMsg
+
+
+class Xep118Plugin(LoaderPlugin):
+    NAMES = ["xep-118"]
+    SUMMARY = "Outputs all tags in XEP-118 XML format. "\
+              "(see: http://xmpp.org/extensions/xep-0118.html)"
+
+    def __init__(self, arg_parser):
+        super().__init__(arg_parser, cache_files=True, track_images=False)
+        g = self.arg_group
+        g.add_argument("--no-pretty-print", action="store_true",
+                       help="Output without new lines or indentation.")
+
+    def handleFile(self, f, *args, **kwargs):
+        super().handleFile(f)
+
+        if self.audio_file and self.audio_file.tag:
+            xml = self.getXML(self.audio_file)
+            printMsg(xml)
+
+    def getXML(self, audio_file):
+        tag = audio_file.tag
+
+        pprint = not self.args.no_pretty_print
+        nl = "\n" if pprint else ""
+        indent = (" " * 2) if pprint else ""
+
+        xml = f"<tune xmlns='http://jabber.org/protocol/tune'>{nl}"
+        if tag.artist:
+            xml += f"{indent}<artist>{escape(tag.artist)}</artist>{nl}"
+        if tag.title:
+            xml += f"{indent}<title>{escape(tag.title)}</title>{nl}"
+        if tag.album:
+            xml += f"{indent}<source>{escape(tag.album)}</source>{nl}"
+        xml += f"{indent}<track>file://{escape(str(Path(audio_file.path).absolute()))}</track>{nl}"
+        if audio_file.info:
+            xml += f"{indent}<length>{audio_file.info.time_secs:.2f}</length>{nl}"
+        xml += "</tune>"
+
+        return xml

eyed3/plugins/yamltag.py

@@ -0,0 +1,25 @@
+import eyed3.plugins
+from eyed3 import log
+from eyed3.plugins.jsontag import audioFileToJson
+
+try:
+    import yaml as _yaml
+except ImportError:
+    _yaml = None
+    log.info("yaml plugin: Install `PyYAML` for YAML plugin support.")
+
+
+if _yaml:
+    class YamlTagPlugin(eyed3.plugins.LoaderPlugin):
+        NAMES = ["yaml"]
+        SUMMARY = "Outputs all tags as YAML."
+
+        def __init__(self, arg_parser):
+            super().__init__(arg_parser, cache_files=True, track_images=False)
+
+        def handleFile(self, f, *args, **kwargs):
+            super().handleFile(f)
+            if self.audio_file and self.audio_file.info and self.audio_file.tag:
+                print(_yaml.safe_dump(audioFileToJson(self.audio_file),
+                                      indent=2, default_flow_style=False,
+                                      explicit_start=True))