importutils.py

from __future__ import absolute_import, print_function, unicode_literals

import os
from importlib import import_module

from wolframclient.utils import six


def module_path(module, *args):
    if isinstance(module, six.string_types):
        try:
            module = import_module(module)
        except ImportError:
            return None
    return os.path.join(os.path.dirname(os.path.realpath(module.__file__)), *args)


def import_string(dotted_path):
    """
    Import a dotted module path and return the attribute/class designated by the
    last name in the path. Raise ImportError if the import failed.
    """

    if not isinstance(dotted_path, six.string_types):
        return dotted_path

    try:
        module_path, class_name = dotted_path.rsplit(".", 1)
    except ValueError:
        raise ImportError("%s doesn't look like a module path" % dotted_path)

    module = import_module(module_path)

    if class_name == "__module__":
        return module

    try:
        return getattr(module, class_name)
    except AttributeError:
        raise ImportError(
            'Module "{}" does not define a "{}" attribute/class'.format(
                module_path, class_name
            )
        )


def safe_import_string(f):
    if isinstance(f, (list, tuple)):
        for path in f:
            try:
                return import_string(path)
            except ImportError:
                pass
        raise ImportError("Cannot import {}".format(f))
    if isinstance(f, six.string_types):
        return import_string(f)
    return f


def safe_import_string_and_call(f, *args, **kw):
    return safe_import_string(f)(*args, **kw)


class API:
    def __init__(self, importer=safe_import_string, **mapping):
        self.__dict__["importer"] = importer
        self.__dict__["mapping"] = mapping
        self.__dict__["imports"] = {}

    def __getattr__(self, value):
        key = self.__dict__["mapping"][value]
        try:
            return self.__dict__["imports"][key]
        except KeyError:
            self.__dict__["imports"][key] = self.__dict__["importer"](key)
            return self.__dict__["imports"][key]

    def __getitem__(self, key):
        try:
            return getattr(self, key)
        except AttributeError:
            raise KeyError("unregistred module %s" % key)

    def __len__(self):
        return len(self.__dict__["mapping"])

    def __bool__(self):
        return bool(self.__dict__["mapping"])

    def keys(self):
        return iter(self)

    def values(self):
        for key in self:
            yield self[key]

    def items(self):
        return zip(self.keys(), self.values())

    def __repr__(self):
        return "<{} {}>".format(self.__class__.__name__, ", ".join(sorted(self)))

    def __dir__(self):
        return list(self)

    def __iter__(self):
        return iter(self.__dict__["mapping"].keys())