Initial Commit

lottie/parsers/baseporter.py

@@ -0,0 +1,140 @@
+import sys
+import os
+import pkgutil
+import argparse
+import importlib
+
+
+class Baseporter:
+    def __init__(self, name, extensions, callback, extra_options=[], generic_options=set(), slug=None):
+        self.name = name
+        self.extensions = extensions
+        self.callback = callback
+        self.extra_options = extra_options
+        self.generic_options = generic_options
+        self.slug = slug if slug is not None else extensions[0]
+
+    def process(self, *a, **kw):
+        return self.callback(*a, **kw)
+
+    def __repr__(self):
+        return "<%s %s>" % (self.__class__.__name__, self.slug)
+
+    def argparse_options(self, ns):
+        o_options = {}
+        for opt in self.extra_options:
+            o_options[opt.dest] = getattr(ns, opt.nsvar(self.slug))
+        for opt in self.generic_options:
+            o_options[opt] = getattr(ns, opt)
+        return o_options
+
+
+class ExtraOption:
+    def __init__(self, name, **kwargs):
+        self.name = name
+        self.kwargs = kwargs
+        if "action" not in self.kwargs:
+            self.kwargs["metavar"] = self.name
+        self.dest = kwargs.pop("dest", name)
+
+    def add_argument(self, slug, parser):
+        opt = "--%s-%s" % (slug, self.name.replace("_", "-"))
+        parser.add_argument(opt, dest=self.nsvar(slug), **self.kwargs)
+
+    def nsvar(self, slug):
+        return "%s_%s" % (slug, self.dest)
+
+
+def _add_options(parser, ie, object):
+    if not object.extra_options:
+        return
+
+    suf = " %sing options" % ie
+    group = parser.add_argument_group(object.name + suf)
+    for op in object.extra_options:
+        op.add_argument(object.slug, group)
+
+
+class Loader:
+    def __init__(self, module_path, module_name, ie):
+        self._loaded = False
+        self._registry = {}
+        self._module_path = os.path.dirname(module_path)
+        self._module_name = module_name.replace(".base", "")
+        self._ie = ie
+        self._failed = {}
+
+    def load_modules(self):
+        self._loaded = True
+
+        for _, modname, _ in pkgutil.iter_modules([self._module_path]):
+            if modname == "base":
+                continue
+
+            full_modname = "." + modname
+            try:
+                importlib.import_module(full_modname, self._module_name)
+            except ImportError as e:
+                self._failed[modname] = e.name
+
+    @property
+    def failed_modules(self):
+        if not self._loaded:
+            self.load_modules()
+
+        return self._failed
+
+    @property
+    def items(self):
+        if not self._loaded:
+            self.load_modules()
+        return self._registry
+
+    def __iter__(self):
+        return iter(self.items.values())
+
+    def get(self, slug):
+        return self.items.get(slug, None)
+
+    def __getitem__(self, key):
+        return self.get(key)
+
+    def get_from_filename(self, filename):
+        return self.get_from_extension(os.path.splitext(filename)[1][1:])
+
+    def get_from_extension(self, ext):
+        for p in self.items.values():
+            if ext in p.extensions:
+                return p
+        return None
+
+    def set_options(self, parser):
+        for exporter in self.items.values():
+            _add_options(parser, self._ie, exporter)
+
+    def keys(self):
+        return self.items.keys()
+
+    def decorator(self, name, extensions, extra_options=[], generic_options=set(), slug=None):
+        def decorator(callback):
+            porter = Baseporter(name, extensions, callback, extra_options, generic_options, slug)
+            self._registry[porter.slug] = porter
+            return callback
+        return decorator
+
+
+class IoProgressReporter:
+    def report_progress(self, title, value, total):
+        sys.stderr.write("\r%s %s/%s" % (title, value, total))
+        sys.stderr.flush()
+
+    def report_message(self, message):
+        sys.stderr.write("\r" + message + "\n")
+        sys.stderr.flush()
+
+
+IoProgressReporter.instance = IoProgressReporter()
+
+
+def io_progress():
+    return IoProgressReporter.instance